look_up_table 0.1.0.rc8 → 0.1.0.rc9

data/lib/look_up_table/base.rb

@@ -0,0 +1,155 @@
+require 'look_up_table'
+require 'look_up_table/base'
+require 'look_up_table/cache'
+require 'look_up_table/method_missing'
+require 'look_up_table/no_cache'
+
+module LookUpTable
+  module ClassMethods
+    # Defining a LookUpTable
+    # TODO: Usage
+    def look_up_table(lut_key, options = {}, &block)
+      options = {
+        :batch_size     => 10000,
+        :prefix         => self.name,
+        :read_on_init   => false,
+        :use_cache      => true,
+        :sql_mode       => true,
+        :where          => nil
+      }.merge(options)
+
+      self.lut_set_proc(lut_key, block)
+      self.lut_set_options(lut_key, options)
+
+      self.lut(lut_key) if options[:read_on_init]
+    end
+
+    # Call to a LookUpTable.
+    # * Example:
+    #    * Tag.lut                          (Returns all LookUpTables)
+    #    * Tag.lut :name                    (Returns LookUpTable given by :name)
+    #    * Tag.lut(:name, "Berlin")         (Returns Value of LookUpTable named :name with :key "Berlin")
+    #    * Tag.lut({:name => "Berlin", :title => "Berlin"})     TODO: returns hash
+    # TODO: TestCases
+    def lut(lut_key = nil, lut_item_key = nil)
+      @lut ||= {}
+
+      if lut_key.nil?
+        hash = {}
+        self.lut_keys.each { |key| hash[key] = self.lut(key) } # CHECK: use .inject?
+        return hash
+      end
+
+      if (lut_key.respond_to?(:keys))
+        hash = {}
+        lut_key.each { |k,v| hash[k.intern] = self.lut(k,v) }
+        return hash
+      end
+
+      lut = @lut[lut_key.to_sym] ||= lut_read(lut_key) || {}
+      lut_item_key ? lut[lut_item_key] : lut
+    end
+
+    # Reset complete lut if name is omitted, resets given lut otherwise.
+    # HACK: not cool do access and define @lut here
+    def lut_reset(name = nil)
+      @lut ||= {}
+
+      if name
+        @lut[name.to_sym] = nil
+        lut_write_cache_item(name, 0, nil) unless lut_options[:skip_memcached] # CHECK: options call w/o name?
+      else
+        lut_keys.each { |k| lut_reset(k) }
+        @lut = {}
+      end
+    end
+
+    # Reading LUT and writing cache again
+    def lut_reload(name = nil)
+      if name
+        lut_reset(name)
+        lut(name)
+      else
+        lut_keys.each { |k| lut_reload(k) }
+      end
+
+      lut_keys
+    end
+
+    # Init complete LUT with all keys define.
+    # But won't rewrite cache if allready written!
+    def lut_init(name = nil)
+      if name
+        lut(name)
+      else
+        lut_keys.each { |k| lut_init(k) }
+      end
+
+      lut_keys
+    end
+
+    # Returns keys of LookUpTables defined
+    def lut_keys
+      lut_options.keys
+    end
+
+    # Usage
+    # * Klass.lut_options
+    # * Klass.lut_options(:lut_key)
+    # * Klass.lut_options(:lut_key, :option_key)
+    # * Klass.lut_options(:lut_key => :option_key)
+    # * Klass.lut_options(:lut_key => [:option_key, :second_option_key])
+    # TODO: test_cases
+    # CHECK: some sweeter implementation?
+    def lut_options(name = nil)#, option_key = nil)
+      @lut_options ||= {}
+
+#      if name && name.respond_to?(:keys)
+#        if name[:lut_key] && name[:lut_key].respond_to?(:values)
+#          return name[:lut_key].each.inject([]) do |arr, el|
+#            arr << @lut_options[name.intern][el.intern]
+#          end
+#        elsif name[:lut_key]
+#          return @lut_options[name.intern][option_key.intern]
+#        else
+#          return @lut_options[name.intern]
+#        end
+#      elsif name
+#        (option_key) ? @lut_options[name.intern][option_key.intern] : @lut_options[name.intern]
+#      else
+#        return @lut_options
+#      end
+
+      (name) ? @lut_options[name.to_sym] : @lut_options
+    end
+
+    protected
+      def lut_proc(lut_key = nil)
+        @lut_proc ||= {}
+
+        (lut_key) ? @lut_proc[lut_key.to_sym] : @lut_proc
+      end
+
+      # lut_set_proc(lut_name, block) / lut_proc(lut_name)
+      def lut_set_proc(lut_key, block)
+        lut_proc[lut_key.to_sym] = block
+      end
+
+      # lut_set_options(lut_name, options) / lut_options(lut_name)
+      def lut_set_options(lut_key, options)
+        lut_options[lut_key.to_sym] = options
+      end
+
+      # Reads a single lut
+      def lut_read(name)
+        return nil unless options = lut_options(name)# HACK
+
+        if options[:use_cache]
+          lut_read_from_cache(name)
+        else
+          lut_read_without_cache(name)
+        end
+      end
+  end
+end
+

data/lib/look_up_table/cache.rb

@@ -0,0 +1,170 @@
+module LookUpTable
+  module ClassMethods
+    protected
+
+    # Cache entry for given LUT exists?
+    def lut_cache_exists?(name)
+      !lut_read_cache_item(name, 0).nil?
+    end
+
+    # Reads a complete lut from cache
+    # HACK: this still looks ugly somehow
+    def lut_read_from_cache(name)
+      lut_write_to_cache(name) unless lut_cache_exists?(name)
+
+      i   = 0
+      lut = {}
+
+      while item = lut_read_cache_item(name, i)
+        # FIXME: merge will override existing values
+        # lut.merge!(item) if item
+        if item
+          item.each do |k,v|
+            if lut[k]
+              v      = [v]      unless v.respond_to?(:concat)
+              lut[k] = [lut[k]] unless lut[k].respond_to?(:concat)
+              lut[k].concat(v)
+            else
+              lut[k] = v
+            end
+          end
+        end
+
+        i += 1
+      end
+
+      return lut
+    end
+
+    # Write a LookUpTable into Cache
+    def lut_write_to_cache(lut_key)
+      if lut_options(lut_key)[:sql_mode]
+        count = lut_write_to_cache_sql_mode(lut_key)
+      else
+        count = lut_write_to_cache_no_sql_mode(lut_key)
+      end
+
+      # HACK: Writing a \0 to terminate batch_items
+      lut_write_cache_item(lut_key, count, nil)
+    end
+
+    # HACK: somehow long method
+    def lut_write_to_cache_sql_mode(lut_key)
+      batch_count = 0
+
+      self.where(lut_options(lut_key)[:where]).find_in_batches(:batch_size => lut_options(lut_key)[:batch_size]) do |items| #FIXME not DRY here
+        lut   = {}
+        block = lut_proc(lut_key)
+
+        items.each do |item|
+          if block
+            block.call(lut, item)
+          else
+            # HACK: doing a merge w/o replacing, just add elements for childs and may transform elements to array
+            k = item.send(lut_key)
+            v = item.id
+            if lut[k]
+              v      = [v]      unless v.respond_to?(:concat)
+              lut[k] = [lut[k]] unless lut[k].respond_to?(:concat)
+              lut[k].concat(v)
+            else
+              lut[k] = v
+            end
+          end
+        end
+
+        batch_count = self.lut_write_cache_item(lut_key, batch_count, lut)
+        batch_count += 1
+      end
+
+      batch_count
+    end
+
+    # HACK: somehow long method
+    def lut_write_to_cache_no_sql_mode(lut_key)
+      lut         = {}
+      batch_count = 0
+
+      block = lut_proc(lut_key)
+      block.call(lut)
+
+      keys = lut.keys
+
+      while
+        key_block = keys.slice!(0, lut_options(lut_key)[:batch_size])
+        break if key_block.empty?
+
+        lut_block = {}
+        key_block.each{|key| lut_block[key] = lut[key]}
+
+        batch_count = self.lut_write_cache_item(lut_key, batch_count, lut_block)
+        batch_count += 1
+      end
+
+      batch_count
+    end
+
+    # Reads a single item of a LookUpTable from Cache
+    def lut_read_cache_item(lut_key, lut_item_key)
+      prefix = lut_options(lut_key)[:prefix]
+
+      Rails.cache.read("#{prefix}#{lut_key}/#{lut_item_key}")
+    end
+
+    # Write a single Item into LookUpTable-Cache
+    # TODO: refactor
+    def lut_write_cache_item(lut_key, lut_item_count, lut_data)
+      prefix  = lut_options(lut_key)[:prefix]
+      success = Rails.cache.write("#{prefix}#{lut_key}/#{lut_item_count}", lut_data)
+
+      # Do some magic here and just throw a warning
+      # * Divide and conquer on error
+      if !success
+        warn "WARNING - LookUpTable: Cache.write failed, trying to 'divide and conquer'"
+
+        if lut_data.respond_to?(:keys) && lut_data.respond_to?(:values)
+          # Got a hash
+          keys        = lut_data.keys
+          keys_length = keys.length
+
+          if keys_length < 2
+            # Try to slice down values
+            entries = lut_data[keys.first].entries
+
+            first_entries  = { keys.first => entries.slice!(0, entries.length/2) }
+            second_entries = { keys.first => entries }
+
+            lut_item_count = self.lut_write_cache_item(lut_key, lut_item_count, first_entries)
+            lut_item_count = self.lut_write_cache_item(lut_key, lut_item_count + 1, second_entries)
+
+          else
+            first_keys  = keys.slice!(0, keys.length/2)
+            second_keys = keys
+            first_hash  = {}
+            second_hash = {}
+
+            first_keys.each  { |k| first_hash[k]  = lut_data[k] }
+            second_keys.each { |k| second_hash[k] = lut_data[k] }
+
+            lut_item_count = self.lut_write_cache_item(lut_key, lut_item_count, first_hash)
+            lut_item_count = self.lut_write_cache_item(lut_key, lut_item_count + 1, second_hash)
+          end
+        elsif lut_data.respond_to?(:entries)
+          # Got an Array or a Set
+          entries = lut_data.entries
+          first_entries  = entries.slice!(0, entries.length/2)
+          second_entries = entries
+
+          lut_item_count = self.lut_write_cache_item(lut_key, lut_item_count, first_entries)
+          lut_item_count = self.lut_write_cache_item(lut_key, lut_item_count + 1, second_entries)
+        else
+          # Finally we can't help here
+          raise "Cache::write failed - Try lower :batch_size"
+        end
+      end
+
+      return lut_item_count
+    end
+  end
+end
+

data/lib/look_up_table/method_missing.rb

@@ -0,0 +1,22 @@
+module LookUpTable
+  module ClassMethods
+    # Delegating <attribute>_lut(args) method calls
+    # e.g.: Klass.foo_lut => Klass.lut :foo
+    def method_missing(sym, *args, &block)
+      method_name = sym.to_s
+
+      if method_name.end_with?("_lut")
+        lut_name = method_name[0..-5]
+        self.lut(lut_name, args.first)
+      else
+        super(sym, *args, &block)
+      end
+    end
+
+    # CHECK: what's bool?
+    def respond_to?(sym, bool)
+      sym.to_s.end_with?("_lut") || super(sym, bool)
+    end
+  end
+end
+

data/lib/look_up_table/no_cache.rb

@@ -0,0 +1,45 @@
+module LookUpTable
+  module ClassMethods
+    protected
+
+    # Reads a complete from given block or generic version
+    # HACK: some duplicated methods from Class.lut_write_to_cache
+    def lut_read_without_cache(lut_key)
+      if lut_options(lut_key)[:sql_mode]
+        return lut_read_without_cache_sql_mode(lut_key)
+      else
+        return lut_read_without_cache_no_sql_mode(lut_key)
+      end
+    end
+
+    # CHECK: somehow long method
+    def lut_read_without_cache_sql_mode(lut_key)
+      lut   = {}
+      block = lut_proc(lut_key)
+
+      self.where(lut_options(lut_key)[:where]).find_in_batches(:batch_size => lut_options(lut_key)[:batch_size]) do |items| #FIXME not DRY here
+        items.each do |item|
+          if block
+            block.call(lut, item)
+          else
+            lut[item.send(lut_key)] = item.id
+          end
+        end
+      end
+
+      return lut
+    end
+
+    # CHECK: ugly method_name
+    def lut_read_without_cache_no_sql_mode(lut_key)
+      lut   = {}
+
+      block = lut_proc(lut_key)
+      block.call(lut)
+
+      return lut
+    end
+
+  end
+end
+

data/lib/look_up_table/version.rb

@@ -1,3 +1,4 @@
 module LookUpTable
-  VERSION = "0.1.0.rc8"
+  VERSION = "0.1.0.rc9"
 end
+

data/lib/look_up_table.rb

@@ -7,278 +7,17 @@
 # * use symbols freely
 
 # FIXME:
-# * Avoid @@class_variables, issues if "subclassed"
-module LookUpTable
-  extend ActiveSupport::Concern
-
-  # Class methods
-  module ClassMethods
-    # Defining a LookUpTable
-    # TODO: Usage
-    def look_up_table(lut_name, options={}, &block)
-      options = {
-        :batch_size     => 10000,
-        :prefix         => "",
-        :read_on_init   => false,
-        :skip_memcached => false,
-        :sql_mode       => true,
-        :where          => nil
-      }.merge(options)
-
-      self.lut_proc[lut_name.to_sym]    = block
-      self.lut_options[lut_name.to_sym] = options
-
-      self.lut(lut_name) if options[:read_on_init]
-    end
-
-    # Call to a LookUpTable.
-    # * Example: Tag.lut(:name, "Berlin")
-    # * Returns: nil or stored objects
-    def lut(name, search_by=nil)
-      @@lut ||= {}
-      @@lut[name.to_sym] ||= lut_read(name) || {}
-
-      search_by ? @@lut[name.to_sym][search_by] : @@lut[name.to_sym]
-    end
-
-    # Reset complete lut if name is omitted, resets given lut otherwise.
-    # HACK
-    def lut_reset(name=nil)
-      @@lut ||= {}
-
-      if name
-        @@lut[name.to_sym] = nil
-        lut_write_cache_item(name, 0, nil) unless lut_options[:skip_memcached]
-      else
-        lut_keys.each { |k| lut_reset(k) }
-        @@lut = {}
-      end
-    end
-
-    # Reloads allready loaded LUTs.
-    # Will also rewrites cache.
-    def lut_reload(name = nil)
-      if name
-        lut_reset(name)
-        lut(name)
-      else
-        lut_keys.each { |k| lut_reload(k) }
-      end
-
-      return lut_keys
-    end
-
-    # Init complete LUT with all keys define.
-    # But won't rewrite cache if allready written!
-    def lut_init(name = nil)
-      if name
-        lut(name)
-      else
-        lut_keys.each { |k| lut_init(k) }
-      end
-
-      return lut_keys
-    end
-
-
-
-    #private
-      def lut_keys
-        lut_options.keys
-      end
-
-      # lut_set_proc(lut_name, block) / lut_proc(lut_name)
-      def lut_set_proc(name, block)
-        lut_proc[name.to_sym] = block
-      end
-
-      def lut_proc(name = nil)
-        @@lut_proc ||= {}
-        (name) ? @@lut_proc[name.to_sym] : @@lut_proc
-      end
-
-      # lut_set_options(lut_name, options) / lut_options(lut_name)
-      def lut_set_options(name, options)
-        lut_options[name.to_sym] = options
-      end
-
-      def lut_options(name = nil)#, option=nil)
-        @@lut_options ||= {}
-        (name) ? @@lut_options[name.to_sym] : @@lut_options
-      end
-
-      # Reads a single lut
-      # HACK
-      def lut_read(name)
-        return nil unless options = lut_options(name)
-
-        if options[:skip_memcached]
-          return lut_read_without_cache(name)
-        else
-          return lut_read_from_cache(name)
-        end
-      end
-
-
-
-      ################
-      ### NO-CACHE ###
-      ################
-
-      # Reads a complete from given block or generic version
-      # HACK: some duplicated methods from Class.lut_write_to_cache
-      def lut_read_without_cache(name)
-        if lut_options(name)[:sql_mode]
-          return lut_read_without_cache_sql_mode(name)
-        else
-          return lut_read_without_cache_no_sql_mode(name)
-        end
-      end
-
-      # HACK: somehow long method
-      def lut_read_without_cache_sql_mode(name)
-        lut   = {}
-        block = lut_proc(name)
-
-        self.where(lut_options(name)[:where]).find_in_batches(:batch_size => lut_options(name)[:batch_size]) do |items| #FIXME not DRY here
-          items.each do |item|
-            if block
-              block.call(lut, item)
-            else
-              lut[item.send(name)] = item.id
-            end
-          end
-        end
-
-        return lut
-      end
+# * Avoid @class_variables, issues if "subclassed"
 
-      # HACK: ugly method_name
-      def lut_read_without_cache_no_sql_mode(name)
-        lut   = {}
 
-        block = lut_proc(name)
-        block.call(lut)
+require 'look_up_table'
 
-        return lut
-      end
-
-
-
-      #############
-      ### CACHE ###
-      #############
-
-      # Cache entry for given LUT exists?
-      # TODO: just check if given key exists
-      def lut_cache_exists?(name)
-        !lut_read_cache_item(name, 0).nil?
-      end
-
-      # Reads a complete lut from cache
-      # HACK: this still looks ugly somehow
-      def lut_read_from_cache(name)
-        lut_write_to_cache(name) unless lut_cache_exists?(name)
-
-        i   = 0
-        lut = {}
-
-        while item = lut_read_cache_item(name, i)
-          # HACK: merge will override existing values
-          lut.merge!(item) if item
-          i += 1
-        end
-
-        return lut
-      end
-
-      # Reads a single item of a LookUpTable from Cache
-      def lut_read_cache_item(name, item)
-        prefix = lut_options(name)[:prefix]
-        Rails.cache.read("#{prefix}#{name}/#{item}")
-      end
-
-      # Write a LookUpTable into Cache
-      def lut_write_to_cache(name)
-        if lut_options(name)[:sql_mode]
-          count = lut_write_to_cache_sql_mode(name)
-        else
-          count = lut_write_to_cache_no_sql_mode(name)
-        end
-
-        # HACK: Writing a \0 to terminate batch_items
-        lut_write_cache_item(name, count, nil)
-      end
-
-      # HACK: somehow long method
-      def lut_write_to_cache_sql_mode(name)
-        batch_count = 0
-
-        self.where(lut_options(name)[:where]).find_in_batches(:batch_size => lut_options(name)[:batch_size]) do |items| #FIXME not DRY here
-          lut   = {}
-          block = lut_proc(name)
-
-          items.each do |item|
-            if block
-              block.call(lut, item)
-            else
-              lut[item.send(name)] = item.id
-            end
-          end
-
-          self.lut_write_cache_item(name, batch_count, lut)
-          batch_count += 1
-        end
-
-        batch_count
-      end
-
-      # HACK: somehow long method
-      def lut_write_to_cache_no_sql_mode(name)
-        lut         = {}
-        batch_count = 0
-
-        block = lut_proc(name)
-        block.call(lut)
-
-        keys = lut.keys
-
-        while
-          key_block = keys.slice!(0, lut_options(name)[:batch_size])
-          break if key_block.empty?
-
-          lut_block = {}
-          key_block.each{|key| lut_block[key] = lut[key]}
-
-          self.lut_write_cache_item(name, batch_count, lut_block)
-          batch_count += 1
-        end
-
-        batch_count
-      end
-
-      # Write a single Item into LookUpTable-Cache
-      def lut_write_cache_item(name, lut_item, lut_data)
-        prefix = lut_options(name)[:prefix]
-        status = Rails.cache.write("#{prefix}#{name}/#{lut_item}", lut_data)
-        raise "Cache::write failed - Try lower :batch_size" unless status
-      end
-
-
-
-      # Delegating <attribute>_lut(args) method calls
-      # HACK
-      def method_missing(m, *args, &block)
-        method_name = m.to_s
-        if method_name.end_with?("_lut")
-          lut_name = method_name[0..-5]
-          self.lut(lut_name, args.first)
-        else
-          super(m, *args, &block)
-        end
-      end
+module LookUpTable
+  extend ActiveSupport::Autoload
+  extend ActiveSupport::Concern
 
-  end
+  require 'look_up_table/base'
+  #autoload :Base # CHECK
 end
 
 ActiveRecord::Base.send :include, LookUpTable

data/test/dummy/app/models/bar.rb

@@ -0,0 +1,4 @@
+class Bar < Foobar
+  #look_up_table :bar
+end
+

data/test/dummy/app/models/foo.rb

@@ -0,0 +1,4 @@
+class Foo < Foobar
+  #look_up_table :foo
+end
+

data/test/dummy/app/models/foobar.rb

@@ -1,4 +1,13 @@
 class Foobar < ActiveRecord::Base
+
+  look_up_table :id, :batch_size => 500000
   look_up_table :foo
+  look_up_table :bar, :sql_mode => false do |lut|
+    lut[1] = []
+    500000.times { |key| lut[1] << Random.rand }
+    lut[1].sort!
+  end
+  #look_up_table :foobar
+
 end