RubyGems - joffice_redis - Versions diffs - 0.1.1 - Mend

joffice_redis 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

data/.gitignore +1 -0
data/LICENSE-2.0.txt +202 -0
data/README.markdown +11 -0
data/Rakefile +29 -0
data/lib/joffice_redis.rb +35 -0
data/lib/joffice_redis/cache_model.rb +205 -0
data/lib/joffice_redis/hash_table.rb +73 -0
data/lib/joffice_redis/marshal.rb +65 -0
data/lib/joffice_redis/model_factory.rb +417 -0
data/lib/joffice_redis/redis_client_base.rb +121 -0
data/lib/joffice_redis/redis_manager.rb +213 -0
data/lib/joffice_redis/redis_method_factory.rb +445 -0
data/lib/joffice_redis/storages/presence_redis.rb +80 -0
metadata +132 -0

data/lib/joffice_redis/hash_table.rb ADDED Viewed

@@ -0,0 +1,73 @@
+#encoding: utf-8
+=begin
+Copyright 2010 Denis Kokorin <[email protected]>
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+       http://www.apache.org/licenses/LICENSE-2.0
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+=end
+module JOffice::Redis
+  class HashTable
+    attr_reader :redis
+    def initialize(id, redis)
+      @id, @redis, @_attributes=id, redis,{}
+    end
+    def [](key)
+      get(key)
+    end
+    def get(key)
+      @_attributes[key]||=((v=redis.get(hash_key(key))) ? Marshal.load(v) : v)
+    end
+    def []=(key, value)
+      set(key, value)
+    end
+    def set(key, value, expire=nil)
+      if value
+        @_attributes[key]=value unless expire
+        k=hash_key(key)
+        redis.set(k, Marshal.dump(value))
+        redis.expire(k, expire) if expire
+      else
+        redis.del(hash_key(key))
+        @_attributes.delete(key)
+      end
+      value
+    end
+    def hash_key(key)
+      "#{@id}:#{key}".force_encoding('ASCII-8BIT')
+    end
+    def exists?(key)
+      k=hash_key(key)
+      (@_attributes.has_key?(k) || redis.exists?(k))
+    end
+    def delete(key)
+      redis.del(hash_key(key))
+      @_attributes.delete(key)
+    end
+    class << self
+      def keys(id, redis)
+       (r=redis.keys("#{id}:*")) ? r : []
+      end
+    end
+  end
+end

data/lib/joffice_redis/marshal.rb ADDED Viewed

@@ -0,0 +1,65 @@
+#encoding: utf-8
+=begin
+Copyright 2010 Denis Kokorin <[email protected]>
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+       http://www.apache.org/licenses/LICENSE-2.0
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+=end
+require 'msgpack'
+module JOffice::Redis
+  module MarshalValue
+    def unbox_object(value)
+      value.blank? ? value : Marshal.load(value)
+    end
+    module_function :unbox_object
+    def box_object(value)
+      value.blank? ? value : Marshal.dump(value)
+    end
+    module_function :box_object
+    def unbox_string(value)
+      value.blank? ? '' : MessagePack.unpack(value).encode2utf8
+    end
+    module_function :unbox_string
+    def box_string(value)
+     (value || '').to_s.to_msgpack
+    end
+    module_function :box_string
+    def unbox_integer(value)
+      value.to_i
+    end
+    module_function :unbox_integer
+    def box_integer(value)
+      value ? value.to_s : '0'
+    end
+    module_function :box_integer
+    def unbox_boolean(value)
+      '1' == value
+    end
+    module_function :unbox_boolean
+    def box_boolean(value)
+      value ? '1' : '0'
+    end
+    module_function :box_boolean
+  end
+end

data/lib/joffice_redis/model_factory.rb ADDED Viewed

@@ -0,0 +1,417 @@
+#encoding: utf-8
+=begin
+Copyright 2010 Denis Kokorin <[email protected]>
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+       http://www.apache.org/licenses/LICENSE-2.0
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+=end
+require 'fileutils'
+require 'digest/sha1'
+module JOffice::Redis
+  class ModelFactory
+    attr_reader :parent
+    attr_reader :attributes
+    attr_reader :attributes_hash
+    attr_reader :attribute_lists
+    attr_reader :unique_indexes
+    attr_accessor :prefix
+    attr_reader :logger
+    attr_reader :class_module_name
+    attr_reader :instance_module_name
+    def initialize(parent, logger)
+      @parent=parent
+      @logger=logger
+      @consts=[]
+      @static_methods=[]
+      @instance_methods=[]
+      @indexes={}
+      @composite_indexes={}
+      @static_alias=[]
+      @index_by_field={}
+      @attributes,@attributes_hash,@attribute_lists,@unique_indexes = {},{},{},{}
+      yield self if block_given?
+      #@class_name="CS#{Digest::SHA1.hexdigest(parent.name)}"
+      @class_name="CS#{class_table}_#{prefix}"
+      @class_module_name="JOffice::Redis::Metadata::#{@class_name}::ClassMethods"
+      @instance_module_name="JOffice::Redis::Metadata::#{@class_name}::InstanceMethods"
+      generate
+      #@buffer=["", "", "module JOffice::Redis","module Metadata","# Metadata for class #{parent.name}", "module #{@class_name}"]
+      #@buffer << "module ClassMethods"
+      @buffer = ["class << self"]
+      @buffer << "include JOffice::Redis::MarshalValue"
+      @buffer+=@consts
+      @buffer << ""
+      @buffer+=@static_methods.map{|v| "      #{v}"}
+      @buffer<< @static_alias.join("\n")
+      @buffer << "end"
+      #@buffer << "module InstanceMethods"
+      @buffer << ""
+      @buffer+=@instance_methods.map{|v| "   #{v}"}
+      @buffer << ""
+      #@buffer << "end"
+      #@buffer << "#{parent.name}.send(:include, InstanceMethods)"
+      ####@buffer << "#{parent.name}.send(:extend, JOffice::Redis::CacheModelClassMethods)"
+      #@buffer << "#{parent.name}.send(:extend, ClassMethods)"
+      #@buffer+=["end","end","end"]
+      parent.class_eval @buffer.join("\n")
+      #save_and_include
+    end
+    def save_and_include
+      dir=File.join(File.absolute_path(File.dirname(__FILE__)),'metadata')
+      FileUtils.mkdir_p(dir)
+      path=File.join(dir, "#{@class_name}.rb")
+      f=File.open(path,'w')
+      f.write(@buffer.join("\n"))
+      f.close
+      #require path
+    end
+    def attribute(name, options={})
+      unique=options[:unique]
+      key_name=(options[:key_name] || name)
+      attributes[name.to_sym]=[options[:type] || :object, unique, key_name]
+      unique_indexes[name]=key_name if unique
+    end
+    def attribute_list(name, options={})
+      attribute_lists[name]=options
+    end
+    def hash(name, options={})
+      attributes_hash[name]=options
+    end
+    def index(name, field)
+     (@indexes[name]||=[]) << field
+      @index_by_field[field]=name
+    end
+    def composite_index(name, *fields)
+      options=fields.extract_options!
+      @composite_indexes[name]=[fields.flatten, options]
+    end
+    def set_table_name(name)
+      @class_table=name
+    end
+    private
+    def generate_unbox_value(value_name, type)
+      case type
+        when :boolean then "('1'==#{value_name})"
+        when :integer then "#{value_name}.to_i"
+        when :string then "JOffice::Redis::MarshalValue.unbox_string(#{value_name})"
+      else "JOffice::Redis::MarshalValue.unbox_object(#{value_name})"
+      end
+    end
+    def const(name, value)
+      @consts << "#{name}=#{value}"
+    end
+    def method(name, args=nil, static=false, log=true, block=false)
+      buf=[]
+      buf << ("JOffice::Redis::CacheModel.logger.info('Redis[#{class_table}]'){'#{name}('+[#{args}].flatten.inspect+')'}") if logger && log
+      yield buf
+      args="#{args}, &block" if block
+      buf=buf.map{|v| "    #{v}"}.join("\n")
+      signature=(args ? "#{name}(#{args})" : name)
+      buf=["def #{signature}\n#{buf}","end"]
+      buf << "public :#{name}" if static
+      static ? (@static_methods << buf.join("\n")) : (@instance_methods << buf.join("\n"))
+    end
+    def class_table
+      @class_table||[email protected]
+    end
+    def key_id_set
+      ":'"+((prefix ? "#{prefix}::" : '') +"id").gsub(/ /,'%20')+"'"
+    end
+    def define_db
+      method('db', nil, true, false) do |m|
+        m << "@@db||=JOffice::RedisManager.instance.open_db_em('#{class_table}')"
+      end
+      method('db=', 'value', true, false) do |m|
+        m << "@@db=value"
+      end
+      method('db', nil, false, false) do |m|
+        m << "self.class.db"
+      end
+    end
+    def generate_key
+      const("ALL_MODEL_ATTRIBUTES_KEYS",attributes.keys.inspect)
+      const("PREFIX", ":'#{prefix}'") unless prefix.blank?
+      method('all_attributes',nil, true, false) do |m|
+        m << "#{@class_module_name}::ALL_MODEL_ATTRIBUTES_KEYS"
+      end
+      method('all_attributes', nil, false, false) do |m|
+        m << "#{@class_module_name}::ALL_MODEL_ATTRIBUTES_KEYS"
+      end
+      method('key_id_set',nil, true, false) do |m|
+        m << ":'"+(prefix ? "#{prefix}::" : '') +"id'"
+      end
+      method('prefix',nil, true, false) do |m|
+        m << 'PREFIX'
+      end  unless prefix.blank?
+      method('prefix', nil, false, false) do |m|
+        m << 'PREFIX'
+      end  if prefix && !prefix.empty?
+      method('key','*args', true, false) do |m|
+        m << "args.#{prefix ? 'unshift(prefix).' : ''}join(':').gsub(/ /,'%20').force_encoding('ASCII-8BIT')"
+      end
+      method('keys_cache', nil, false, false) do |m|
+        m << "@keys_cache||={}"
+      end
+      method('key','*args', false, false) do |m|
+        if prefix
+          s='([prefix, id]+args)'
+        else
+          s='args.unshift(id)'
+        end
+        m << s+".join(':').gsub(/ /,'%20').force_encoding('ASCII-8BIT')"
+      end
+      if prefix
+        build_key_by_id_name='"'+prefix+':#{id}:#{name}"'
+      else
+        build_key_by_id_name='"#{id}:#{name}"'
+      end
+      build_key_by_id_name+=".gsub(/ /,'%20').force_encoding('ASCII-8BIT')"
+      method  "key_name", "id, name", true, false do |m|
+        m << build_key_by_id_name
+      end
+      method  "key_name", "name", false do |m|
+        m << "keys_cache[name]||=" + build_key_by_id_name
+      end
+      method  "key2id", "key", true, false do |m|
+        m << (prefix ? "key[#{prefix.length+1}..key.length] if key" : "key")
+      end
+    end
+    def generate_attributes
+      attributes.each do |name, options|
+        unique_key_name=options[2]
+        method  name do |m|
+          m << "@#{name}||="+generate_unbox_value("db.get(key_name(:#{name}))", options[0])
+        end
+        method  "#{name}=","value" do |m|
+          m << "db.set(key_name(:#{name}),JOffice::Redis::MarshalValue.box_#{options[0]}(@#{name}=value))"
+          m << "db.set(self.class.key_name(:#{unique_key_name},value), id)" if options[1]
+          m << "db.set_add(self.class.key_name(:#{@index_by_field[name]}, value), id)" if @index_by_field.has_key?(name)
+        end
+        @static_alias << "alias :unbox_value_#{name} :unbox_#{options[0]}"
+        if options[1]
+          method  "find_by_#{unique_key_name}","value, select=[]", true do |m|
+            m << "id=db.get(key_name(:#{unique_key_name}, value))"
+            if unique_key_name==name
+              m << "id ? new(:id=>id, :#{name}=>value).ensure_attributes(select) : nil"
+            else
+              m << "id ? new(:id=>id).ensure_attributes(select) : nil"
+            end
+          end
+        end
+        if @index_by_field.has_key?(name)
+          index_name=@index_by_field[name]
+          method  "find_all_by_#{index_name}", "value, select=[]", true do |m|
+            m << "ids=db.set_members(key_name(:#{index_name}, value))"
+            m << "ids ? load_by_ids(ids, select) : []"
+          end
+          method  "find_all_id_by_#{name}", "value", true do |m|
+            m << "db.set_members(key_name(:#{index_name}, value))"
+          end
+          method  "count_by_#{name}", "value", true do |m|
+            m << "db.scard(key_name(:#{index_name}, value))"
+          end
+        end
+      end
+    end
+    def generate_hash_attributes
+      attributes_hash.each do |name, options|
+        method  name do |m|
+          m << "@#{name}||=JOffice::Redis::HashTable.new(key_name(:'#{name}'), db)"
+        end
+      end
+    end
+    def generate_save_composite_index
+      method "save_composite_index" do |m|
+        @composite_indexes.each do |index_name, d|
+          fields,options=*d
+          if options[:unique]
+            m << "db.set(self.class.key(:#{index_name}, #{fields.join(',')}), id)"
+          else
+            m << "db.set_add(self.class.key(:#{index_name}, #{fields.join(',')}), id)"
+          end
+        end
+      end
+      @composite_indexes.each do |index_name, d|
+        fields,options=*d
+        fields_map=fields.map{|v| ":#{v}=>#{v}"}.join(',')
+        fields_sym_array=":#{fields.join(',:')}"
+        if options[:unique]
+          method  "find_by_#{fields.join('_and_')}","#{fields.join(',')}, select=[]", true do |m|
+            m << "id=db.get(key(:#{index_name}, #{fields.join(',')}))"
+            m << "select=select.map{|v| v.to_sym}-[#{fields_sym_array}] if select && !select.empty?"
+            m << "id ? new({:id=>id, #{fields_map}}).ensure_attributes(select) : nil"
+          end
+          method  "exists_by_#{fields.join('_and_')}?", fields.join(','), true do |m|
+            m << "db.exists(key(:#{index_name}, #{fields.join(',')}))"
+          end
+        else
+          method  "find_all_by_#{fields.join('_and_')}", "#{fields.join(',')}, select=[]", true, true, true do |m|
+            m << "find_by_batch_set(key(:#{index_name}, #{fields.join(',')}), {:select=>select,:default=>{#{fields_map}}}, &block)"
+          end
+          method  "exists_by_#{fields.join('_and_')}?", fields.join(','), true do |m|
+            m << "db.exists(key(:#{index_name}, #{fields.join(',')}))"
+          end
+          method  "count_by_#{fields.join('_and_')}", fields.join(','), true do |m|
+            m << "db.scard(key(:#{index_name}, #{fields.join(',')}))"
+          end
+        end
+      end
+    end
+    def generate_clone_method
+      method  "clone", "v, id=nil", true do |m|
+        m << "item=new(:id=>(id ? id : v.id))"
+        m << "db.bulk_set do"
+        attributes.each do |name, options|
+          m << "item.#{name}=v.#{name}"
+        end
+        m << ""
+        m << "item.save_custom" if parent.instance_methods.index('save_custom')
+        m << "item.save"
+        m << "db.set_add(#{key_id_set}, item.id)"
+        m << "end"
+        m << "item"
+      end
+    end
+    def generate_exists
+      method 'exists?','id', true do |m|
+        m << "db.sismember(#{key_id_set}, id) if id"
+      end
+      method "exists?" do |m|
+        m << "self.class.exists?(id)"
+      end
+    end
+    def generate_delete_method
+      method  "delete" do |m|
+        m << "return unless exists?"
+        m << "key_to_delete=#{@class_module_name}::ALL_MODEL_ATTRIBUTES_KEYS.map{|name| key_name( name) }"
+        keys_to_ensure=[]
+        [email protected] if @indexes.size>0
+        keys_to_ensure+=@composite_indexes.values.map{|v| v[0]} if @composite_indexes.size>0
+        m << "ensure_attributes(#{keys_to_ensure.flatten.uniq.map{|v| v.to_sym}.inspect})" unless keys_to_ensure.empty?
+        @composite_indexes.each do |index_name, d|
+          fields,options=*d
+          if options[:unique]
+            m << "key_to_delete << self.class.key(:#{index_name}, #{fields.join(',')})"
+          else
+            m  << "db.set_remove_if_empty(self.class.key(:#{index_name}, #{fields.join(',')}), id)"
+          end
+        end
+        if unique_indexes.size>0
+          unique_indexes.each do |name, index|
+            m << "key_to_delete << self.class.key_name(:#{index}, #{name})"
+          end
+        end
+        if attributes_hash.size>0
+          m << "key_to_delete+=(db.keys(key_name('*')) || [])"
+        end
+        m << "key_to_delete+=delete_custom" if parent.instance_methods.index('delete_custom')
+        @indexes.each do |index, fields|
+          fields.each do |field|
+            m  << "db.set_remove_if_empty(self.class.key_name(:#{index}, #{field}), id)"
+          end
+        end
+        m << "db.del(key_to_delete)"
+        m << "db.set_remove(#{key_id_set}, id)"
+      end
+      method  "delete", nil, true do |m|
+        m << "new(:id=>id).delete"
+      end
+    end
+    def generate_save
+      generate_save_composite_index
+      method  "save" do |m|
+        #m << "db.set_add(#{key_id_set}, id)"
+        m << "save_composite_index" if @composite_indexes.size>0
+      end
+    end
+    def generate
+      define_db
+      generate_key
+      generate_exists
+      generate_attributes
+      generate_hash_attributes
+      generate_clone_method
+      generate_delete_method
+      generate_save
+    end
+  end
+end