lookup_by 0.10.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b7b482a9755de8d24837b3555d53cc416b77ac87
-  data.tar.gz: 087b776e7ad8c89b4fcb90a63769820c6279d81e
+  metadata.gz: c81a1e0b0e5640594ff736ea71404e85a8bd107c
+  data.tar.gz: bd457c39c27f0549c0d5dc136e65e5685cbad2a7
 SHA512:
-  metadata.gz: 2d728f55c1da30eb53de8d33397bb4b6fbe1c1d1b9003d03f11db296d34455c65d5a0f16058f904b298b9050cc5b86ee69d88223cb942c6ff9419dadf34e2501
-  data.tar.gz: 62479abc739d5125a2feffa8589236f4e1f83fd9a391b343bb5f49ac3510dd05293c221cb4b3521362a659804a021ce7a114556d045fc2644a223faa88a7afd9
+  metadata.gz: 3d55c28857d8e2f6556e1090435fadaf392d82f5f2d7b9d27b19acb620d1a520dea2a2009db2c8966dcdf3ab2681f6e5a94cee6a3641de0fa1e4da027bd4c29b
+  data.tar.gz: f3e0bd3c59d65ed5860d3b92220f7a4804b6229ef26b8539b844a4545709c0e9a380986e58412556a0da87a43a20d975456a85432c4e5053062bd01d58f68686

data/.ruby-version

@@ -1 +1 @@
-ruby-2.2.0
+ruby-2.2.1

data/.travis.yml

@@ -1,9 +1,9 @@
 language: ruby
 rvm:
   - 1.9.3-p551
-  - 2.0.0-p598
+  - 2.0.0-p643
   - 2.1.5
-  - 2.2.0
+  - 2.2.1
   - rbx-2.5.2
 services:
   - postgresql

data/lib/lookup_by/cache.rb

@@ -202,16 +202,14 @@ module LookupBy
         return unless object
 
         @mutex.synchronize do
-          @cache[object.id] = object
-          @reverse[object.send(@field)] = object
+          @reverse[object.send(@field)] = @cache[object.id] = object
         end
       end
     else
       def cache_write(object)
         return unless object
 
-        @cache[object.id] = object
-        @reverse[object.send(@field)] = object
+        @reverse[object.send(@field)] = @cache[object.id] = object
       end
     end
 

data/lib/lookup_by/caching/lru.rb

@@ -1,56 +1,111 @@
 module LookupBy
   module Caching
     class LRU
-      attr_reader :lru
+      # In Ruby 1.9+, Hash is ordered.
+      #
+      # http://bugs.ruby-lang.org/issues/8312
+      # In Ruby 2.0, Hash#shift is bugged and horribly slow.
+      #
+      #     require 'benchmark/ips'
+      #     hash, i, N = {}, 0, 20_000_000; while i < N; hash[i] = true; i += 1; end
+      #
+      #     Benchmark.ips do |x|
+      #       x.report("shift") { hash.shift }
+      #       x.report("first") { hash.delete hash.first[0] }
+      #     end
+      #
+      # Ruby       | shift | first
+      # -----------+-------+------
+      # 1.9.3-p484 |  264k |   89k
+      # 1.9.3-p551 |  945k |  370k
+      # 2.0.0-p0   |    0k |   70k
+      # 2.0.0-p643 |    0k |  272k
+      # 2.1.5      | 4947k | 3557k
+      # 2.2.1      | 6801k | 4457k
+      # rbx-2.5.2  |  609k |  409k
 
-      def initialize(maxsize)
-        @maxsize = maxsize
-        @lru     = []
-        @hash    = {}
+      def initialize(max_size)
+        @data = {}
+        self.max_size = max_size
+      end
+
+      def max_size=(size)
+        raise ArgumentError.new(:maxsize) if size < 1
+
+        @max_size = size
+
+        @data.shift while @data.length > @max_size
       end
 
       def [](key)
-        return nil unless @hash.key?(key)
-        touch(key)
-        @hash[key]
+        found = true
+        value = @data.delete(key) { found = false }
+
+        @data[key] = value if found
       end
 
       def []=(key, value)
-        touch(key)
-        @hash[key] = value
-        @hash.delete(@lru.shift) while @hash.size > @maxsize
+        @data.delete(key)
+        @data[key] = value
+        @data.shift if @data.length > @max_size
+      end
+
+      def clear
+        @data.clear
+      end
+
+      def count
+        @data.length
       end
 
       def delete(key)
-        @lru.delete(key)
+        @data.delete(key)
+      end
 
-        @hash.delete(key)
+      def each
+        @data.to_a.each do |pair|
+          yield pair
+        end
       end
 
-      def clear
-        @lru.clear
-        @hash.clear
-        self
+      def fetch(key)
+        found = true
+        value = @data.delete(key) { found = false }
+
+        if found
+          @data[key] = value
+        elsif block_given?
+          value = @data[key] = yield key
+          @data.shift if @data.length > @max_size
+          value
+        else
+          raise KeyError, "key not found: %p" % [key]
+        end
       end
 
-      def values
-        @hash.values
+      def key?(key)
+        @data.key?(key)
       end
 
       def size
-        @hash.size
+        @data.size
+      end
+
+      def to_a
+        @data.to_a
       end
 
       def to_h
-        @hash.dup
+        @data.dup
       end
 
-    private
-      def touch(key)
-        # TODO: LRU deletes are O(N)
-        @lru.delete(key)
-        @lru << key
+      def values
+        @data.values
       end
     end
   end
 end
+
+if RUBY_ENGINE == "ruby" && RUBY_VERSION == "2.0.0"
+  require "lookup_by/caching/lru_legacy"
+end

data/lib/lookup_by/caching/lru_legacy.rb

@@ -0,0 +1,40 @@
+module LookupBy
+  module Caching
+    class LRU
+      def max_size=(size)
+        raise ArgumentError.new(:max_size) if size < 1
+
+        @max_size = size
+
+        if @max_size < @data.length
+          @data.keys[0..@max_size-@data.size].each do |key|
+            @data.delete(key)
+          end
+        end
+      end
+
+      def []=(key, value)
+        @data.delete(key)
+        @data[key] = value
+
+        # See: http://bugs.ruby-lang.org/issues/8312
+        @data.delete(@data.first[0]) if @data.length > @max_size
+      end
+
+      def fetch(key)
+        found = true
+        value = @data.delete(key) { found = false }
+
+        if found
+          @data[key] = value
+        elsif block_given?
+          value = @data[key] = yield key
+          @data.delete(@data.first[0]) if @data.length > @max_size
+          value
+        else
+          raise KeyError, "key not found: %p" % [key]
+        end
+      end
+    end
+  end
+end

data/lib/lookup_by/caching/safe_lru.rb

@@ -7,7 +7,7 @@ module LookupBy
     class SafeLRU < LRU
       include Mutex_m
 
-      def initialize(maxsize = nil)
+      def initialize(max_size)
         super
       end
 
@@ -19,15 +19,27 @@ module LookupBy
         synchronize { super }
       end
 
+      def clear
+        synchronize { super }
+      end
+
+      def count
+        synchronize { super }
+      end
+
       def delete(key)
         synchronize { super }
       end
 
-      def clear
+      def each
         synchronize { super }
       end
 
-      def values
+      def fetch(key)
+        synchronize { super }
+      end
+
+      def key?(key)
         synchronize { super }
       end
 
@@ -35,9 +47,17 @@ module LookupBy
         synchronize { super }
       end
 
+      def to_a
+        synchronize { super }
+      end
+
       def to_h
         synchronize { super }
       end
+
+      def values
+        synchronize { super }
+      end
     end
   end
 end

data/lib/lookup_by/version.rb

@@ -1,3 +1,3 @@
 module LookupBy
-  VERSION = "0.10.0"
+  VERSION = "0.10.1"
 end

data/spec/caching/lru_spec.rb

@@ -41,18 +41,52 @@ describe LookupBy::Caching::LRU do
   end
 
   describe "#clear" do
-    specify { expect(cache.clear.size).to eq 0 }
+    specify { expect(cache.clear).to be_empty }
+  end
+
+  describe "#count" do
+    specify { expect(cache.count).to eq 2 }
+  end
+
+  describe "#delete" do
+    specify { expect(cache.delete(1)).to eq "one" }
+    specify { expect(cache.delete(3)).to be_nil }
+  end
+
+  describe "#fetch" do
+    specify { expect(cache.fetch(1)).to eq "one" }
+    specify { expect(cache.fetch(3) { |key| key }).to eq 3 }
+    specify { expect { cache.fetch(3) }.to raise_error }
+
+    it "writes missing values" do
+      expect(cache.fetch(3) { "missing" }).to eq "missing"
+      expect(cache.fetch(3)).to eq "missing"
+      expect(cache[1]).to be_nil
+    end
+  end
+
+  describe "#key?" do
+    specify { expect(cache.key?(1)).to eq true  }
+    specify { expect(cache.key?(3)).to eq false }
+  end
+
+  describe "#max_size=" do
+    specify { expect { cache.max_size = -1 }.to raise_error }
   end
 
   describe "#size" do
     specify { expect(cache.size).to eq 2 }
   end
 
-  describe "#values" do
-    specify { expect(cache.values).to eq ["one", "two"] }
+  describe "#to_a" do
+    specify { expect(cache.to_a).to eq [[1, "one"], [2, "two"]] }
   end
 
   describe "#to_h" do
     specify { expect(cache.to_h).to eq(1 => "one", 2 => "two") }
   end
+
+  describe "#values" do
+    specify { expect(cache.values).to eq ["one", "two"] }
+  end
 end

data/spec/spec_helper.rb

@@ -82,4 +82,26 @@ RSpec.configure do |config|
   config.after(:each) do
     LookupBy.clear
   end
+
+  if RUBY_ENGINE == 'rbx' && ENV['PROFILE']
+    require 'rubinius/profiler'
+
+    profiler = nil
+
+    config.before(:suite) do
+      profiler = Rubinius::Profiler::Instrumenter.new
+    end
+
+    config.before(:each) do
+      profiler.start
+    end
+
+    config.after(:each) do
+      profiler.stop
+    end
+
+    config.after(:suite) do
+      profiler.show
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lookup_by
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Erik Peterson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-19 00:00:00.000000000 Z
+date: 2015-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -76,6 +76,7 @@ files:
 - lib/lookup_by/association.rb
 - lib/lookup_by/cache.rb
 - lib/lookup_by/caching/lru.rb
+- lib/lookup_by/caching/lru_legacy.rb
 - lib/lookup_by/caching/safe_lru.rb
 - lib/lookup_by/cucumber.rb
 - lib/lookup_by/hooks/cucumber.rb
@@ -152,7 +153,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: A thread-safe lookup table cache for ActiveRecord