joffice_redis 0.1.1

data/lib/joffice_redis/hash_table.rb

@@ -0,0 +1,73 @@
+#encoding: utf-8
+=begin
+Copyright 2010 Denis Kokorin <virkdi@mail.ru>
+
+   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

@@ -0,0 +1,65 @@
+#encoding: utf-8
+=begin
+Copyright 2010 Denis Kokorin <virkdi@mail.ru>
+
+   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

@@ -0,0 +1,417 @@
+#encoding: utf-8
+=begin
+Copyright 2010 Denis Kokorin <virkdi@mail.ru>
+
+   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||=@parent.name
+    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=[]
+        keys_to_ensure+=@indexes.values 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