look_up_table 0.0.3 → 0.1.0.rc0

data/lib/look_up_table/version.rb

@@ -1,3 +1,3 @@
 module LookUpTable
-  VERSION = "0.0.3"
+  VERSION = "0.1.0.rc0"
 end

data/lib/look_up_table.rb

@@ -1,5 +1,7 @@
 # TODO
 # * add: lut_reset(:name)
+# * move Methods to different modules
+# * add private/protected
 module LookUpTable
   extend ActiveSupport::Concern
 
@@ -7,127 +9,233 @@ module LookUpTable
   module ClassMethods
     # Defining a LookUpTable
     # TODO: Usage
-    def look_up_table(lut_name, options={})
+    def look_up_table(lut_name, options={}, &block)
       options = {
         :batch_size     => 10000,
-        :read_on_init   => true,
-        :skip_memcached => false, #TODO
-        :sql_mode       => true,
-        :write_on_init  => true
+        :read_on_init   => false,
+        :skip_memcached => false,
+        :sql_mode       => true
       }.merge(options)
 
-      if block_given?
-        lut_write_to_cache(options[:batch_size], lut_name, options[:sql_mode], &Proc.new) if options[:write_on_init]
-      else
-        lut_write_to_cache(options[:batch_size], lut_name, options[:sql_mode]) if options[:write_on_init]
-      end
+      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
 
-    # Write a LookUpTable into Cache
-    # TODO refactor
-    def lut_write_to_cache(batch_size, lut_name, sql_mode)
-      if sql_mode
-        if block_given?
-          lut_write_to_cache_sql_mode(batch_size, lut_name, &Proc.new)
-        else
-          lut_write_to_cache_sql_mode(batch_size, lut_name)
-        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)
+      if name
+        @@lut[name.to_sym] = nil
+        lut_write_cache_item(name, 0, nil) unless lut_options[:skip_memcached]
       else
-        if block_given?
-          lut_write_to_cache_no_sql_mode(batch_size, lut_name, &Proc.new)
+        @@lut.keys.each { |k| lut_reset(k) }
+        @@lut = {}
+      end
+    end
+
+
+
+    #private
+
+      # 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
-          lut_write_to_cache_no_sql_mode(batch_size, lut_name)
+          return lut_read_from_cache(name)
         end
       end
-    end
 
 
-    def lut_write_to_cache_sql_mode(batch_size, lut_name)
-      batch_count = 0
 
-      self.find_in_batches(:batch_size => batch_size) do |items|
-        lut = {}
-        items.each do |item|
-          if block_given?
-            yield(lut, item)
-          else
-            lut[item.send(lut_name)] = item.id
+      ################
+      ### 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.find_in_batches(:batch_size => lut_options(name)[:batch_size]) do |items|
+          items.each do |item|
+            if block
+              block.call(lut, item)
+            else
+              lut[item.send(name)] = item.id
+            end
           end
         end
 
-        self.lut_write_cache_item(lut_name, batch_count, lut)
-        batch_count += 1
+        return lut
       end
-    end
 
+      # HACK: ugly method_name
+      def lut_read_without_cache_no_sql_mode(name)
+        lut   = {}
 
-    def lut_write_to_cache_no_sql_mode(batch_size, lut_name)
-      lut = {}
-      batch_count = 0
+        block = lut_proc(name)
+        block.call(lut)
+
+        return lut
+      end
 
-      yield(lut)
-      keys = lut.keys
 
-      while
-        key_block = keys.slice!(0,batch_size)
-        break if key_block.empty?
 
-        lut_block = {}
-        key_block.each{|key| lut_block[key] = lut[key]}
+      #############
+      ### CACHE ###
+      #############
 
-        self.lut_write_cache_item(lut_name, batch_count, lut_block)
-        batch_count += 1
+      # 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
-    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)
 
-    # Write a single Item into LookUpTable-Cache
-    def lut_write_cache_item(lut_name, lut_item, lut_data)
-      status = Rails.cache.write("#{lut_name}/#{lut_item}", lut_data)
-      raise "Cache::write returned false" unless status
-    end
+        i   = 0
+        lut = {}
 
-    # Reads a single LookUpTable from Cache
-    def lut_read_from_cache(lut_name)
-      i   = 0
-      lut = {}
+        while item = lut_read_cache_item(name, i)
+          lut.merge!(item) if item
+          i += 1
+        end
 
-      while res = lut_read_cache_item(lut_name, i)
-        lut.merge!(res) if res
-        i += 1
+        return lut
       end
 
-      return lut
-    end
+      # Reads a single item of a LookUpTable from Cache
+      def lut_read_cache_item(name, item)
+        Rails.cache.read("#{name}/#{item}")
+      end
 
-    # Reads a single item of a LookUpTable from Cache
-    def lut_read_cache_item(lut_name, lut_item)
-      Rails.cache.read("#{lut_name}/#{lut_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
 
-    # Call to a LookUpTable, example Usage:
-    # * Tag.lut(:name, "Berlin")
-    # Returns nil or stored objects
-    def lut(lut_name, search_by=nil)
-      @@look_up_tables ||= {}
-      @@look_up_tables[lut_name.to_sym] ||= lut_read_from_cache(lut_name) || {}
+        # HACK: Writing a \0 to terminate batch_items
+        lut_write_cache_item(name, count, nil)
+      end
 
-      return @@look_up_tables[lut_name.to_sym][search_by] if search_by
-      return @@look_up_tables[lut_name.to_sym]
-    end
+      # HACK: somehow long method
+      def lut_write_to_cache_sql_mode(name)
+        batch_count = 0
 
-    # Delegating <attribute>_lut(args) method calls
-    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
-        raise "MethodNotFound: #{m}"
+        self.find_in_batches(:batch_size => lut_options(name)[:batch_size]) do |items|
+          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,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)
+        status = Rails.cache.write("#{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
-    end
 
   end
 end

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

@@ -0,0 +1,4 @@
+class Foobar < ActiveRecord::Base
+  look_up_table :foo
+end
+

data/test/dummy/db/migrate/20111024130333_create_foobars.rb

@@ -0,0 +1,10 @@
+class CreateFoobars < ActiveRecord::Migration
+  def change
+    create_table :foobars do |t|
+      t.string :foo
+      t.integer :bar
+
+      t.timestamps
+    end
+  end
+end

data/test/dummy/db/schema.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your
+# database schema. If you need to create the application database on another
+# system, you should be using db:schema:load, not running all the migrations
+# from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended to check this file into your version control system.
+
+ActiveRecord::Schema.define(:version => 20111024130333) do
+
+  create_table "foobars", :force => true do |t|
+    t.string   "foo"
+    t.integer  "bar"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+end

data/test/dummy/log/development.log

@@ -0,0 +1,11 @@
+   (0.1ms)  select sqlite_version(*)
+   (135.8ms)  CREATE TABLE "schema_migrations" ("version" varchar(255) NOT NULL) 
+   (0.1ms)  PRAGMA index_list("schema_migrations")
+   (88.2ms)  CREATE UNIQUE INDEX "unique_schema_migrations" ON "schema_migrations" ("version")
+   (0.1ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+Migrating to CreateFoobars (20111024130333)
+   (1.1ms)  CREATE TABLE "foobars" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "foo" varchar(255), "bar" integer, "created_at" datetime, "updated_at" datetime) 
+   (0.7ms)  INSERT INTO "schema_migrations" ("version") VALUES ('20111024130333')
+   (0.5ms)  select sqlite_version(*)
+   (0.1ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+   (0.0ms)  PRAGMA index_list("foobars")

data/test/dummy/log/test.log

@@ -0,0 +1,11 @@
+   (0.1ms)  select sqlite_version(*)
+   (115.3ms)  CREATE TABLE "schema_migrations" ("version" varchar(255) NOT NULL) 
+   (0.1ms)  PRAGMA index_list("schema_migrations")
+   (99.0ms)  CREATE UNIQUE INDEX "unique_schema_migrations" ON "schema_migrations" ("version")
+   (0.1ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+Migrating to CreateFoobars (20111024130333)
+   (1.1ms)  CREATE TABLE "foobars" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "foo" varchar(255), "bar" integer, "created_at" datetime, "updated_at" datetime) 
+   (0.6ms)  INSERT INTO "schema_migrations" ("version") VALUES ('20111024130333')
+   (0.3ms)  select sqlite_version(*)
+   (0.1ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+   (0.1ms)  PRAGMA index_list("foobars")

data/test/dummy/test/fixtures/foobars.yml

@@ -0,0 +1,9 @@
+# Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/Fixtures.html
+
+one:
+  foo: MyString
+  bar: 1
+
+two:
+  foo: MyString
+  bar: 1

data/test/dummy/test/unit/foobar_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class FoobarTest < ActiveSupport::TestCase
+  # test "the truth" do
+  #   assert true
+  # end
+end

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: look_up_table
 version: !ruby/object:Gem::Version
-  version: 0.0.3
-  prerelease: 
+  version: 0.1.0.rc0
+  prerelease: 6
 platform: ruby
 authors:
 - Patrick Helm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-14 00:00:00.000000000Z
+date: 2011-10-24 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &78698380 !ruby/object:Gem::Requirement
+  requirement: &85611210 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 3.1.1
   type: :runtime
   prerelease: false
-  version_requirements: *78698380
+  version_requirements: *85611210
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &78698090 !ruby/object:Gem::Requirement
+  requirement: &85610990 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *78698090
+  version_requirements: *85610990
 description: A simple LookUpTable to cache large (!) and static(!) data
 email:
 - ph@werbeboten.de
@@ -49,9 +49,18 @@ files:
 - README.rdoc
 - test/test_helper.rb
 - test/look_up_table_test.rb
+- test/dummy/db/migrate/20111024130333_create_foobars.rb
+- test/dummy/db/schema.rb
+- test/dummy/db/development.sqlite3
+- test/dummy/db/test.sqlite3
 - test/dummy/config.ru
+- test/dummy/test/fixtures/foobars.yml
+- test/dummy/test/unit/foobar_test.rb
 - test/dummy/Rakefile
+- test/dummy/log/development.log
+- test/dummy/log/test.log
 - test/dummy/app/views/layouts/application.html.erb
+- test/dummy/app/models/foobar.rb
 - test/dummy/app/assets/javascripts/application.js
 - test/dummy/app/assets/stylesheets/application.css
 - test/dummy/app/helpers/application_helper.rb
@@ -75,6 +84,9 @@ files:
 - test/dummy/public/422.html
 - test/dummy/public/favicon.ico
 - test/dummy/public/500.html
+- test/dummy/tmp/cache/213/7D0/foo%2F1
+- test/dummy/tmp/cache/203/1B0/bar%2F0
+- test/dummy/tmp/cache/212/7C0/foo%2F0
 - test/dummy/script/rails
 homepage: http://www.deckel-gesucht.de
 licenses: []
@@ -90,16 +102,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -202588273
+      hash: 67753825
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: -202588273
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.10
@@ -109,9 +118,18 @@ summary: A simple LookUpTable to cache large (!) and static(!) data
 test_files:
 - test/test_helper.rb
 - test/look_up_table_test.rb
+- test/dummy/db/migrate/20111024130333_create_foobars.rb
+- test/dummy/db/schema.rb
+- test/dummy/db/development.sqlite3
+- test/dummy/db/test.sqlite3
 - test/dummy/config.ru
+- test/dummy/test/fixtures/foobars.yml
+- test/dummy/test/unit/foobar_test.rb
 - test/dummy/Rakefile
+- test/dummy/log/development.log
+- test/dummy/log/test.log
 - test/dummy/app/views/layouts/application.html.erb
+- test/dummy/app/models/foobar.rb
 - test/dummy/app/assets/javascripts/application.js
 - test/dummy/app/assets/stylesheets/application.css
 - test/dummy/app/helpers/application_helper.rb
@@ -135,4 +153,7 @@ test_files:
 - test/dummy/public/422.html
 - test/dummy/public/favicon.ico
 - test/dummy/public/500.html
+- test/dummy/tmp/cache/213/7D0/foo%2F1
+- test/dummy/tmp/cache/203/1B0/bar%2F0
+- test/dummy/tmp/cache/212/7C0/foo%2F0
 - test/dummy/script/rails