pinky 0.1.4-java → 0.2.5-java

data/Rakefile

@@ -15,7 +15,10 @@ require 'jeweler'
 Jeweler::Tasks.new do |gem|
   # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
   gem.name = "pinky"
+
+  # FIXME: jf (12.12.12) removing due to bug in Bundler
   gem.platform = 'java'
+
   gem.homepage = "http://github.com/trunkclub/pinky"
   gem.license = "MIT"
   gem.summary = %Q{in memory API caching made easy}

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.2.5

data/lib/pinky/associations.rb

@@ -5,11 +5,9 @@ module Pinky
       find_by          = opts[:lookup_by] || "#{klass_name}_id"
       association_name = opts[:as] || klass_name
       define_method association_name do
-        begin
-          klass.find send(find_by)
-        rescue NotFoundException
-          raise unless opts[:allow_nil]
-        end
+        lookup_value = send(find_by)
+        association_model = lookup_value.nil? ? nil : klass.find(:id => lookup_value) rescue nil
+        raise NotFoundException.new if association_model.nil? && !opts[:allow_nil]
       end
     end
   end

data/lib/pinky/cache.rb

@@ -0,0 +1,50 @@
+module Pinky
+  class Cache
+    extend Forwardable
+
+    attr_reader :name
+    def_delegators :cache, :size, :count, :empty?
+
+    class << self
+      def name_for(*methods)
+        "cache_by_#{methods.flatten.sort.join("_and_")}"
+      end
+    end
+
+    def initialize(*item_methods)
+      @item_methods = item_methods.flatten.sort
+      @name = self.class.name_for(@item_methods)
+    end
+
+    def queryable_for?(query_hash)
+      query_hash.keys.sort == @item_methods
+    end
+
+    def update_with(item, action = :create)
+      key = key_for item
+      if action == :destroy
+        cache.delete key
+      else
+        cache[key] = item
+      end
+    end
+
+    def query(query_hash = {})
+      key = query_hash.sort.map { |k,v| v }.join '.'
+      cache[key]
+    end
+
+    def clear_cache
+      @cache = nil
+    end
+
+    private
+    def key_for(item)
+      @item_methods.map { |method| item.send method }.join '.'
+    end
+
+    def cache
+      @cache ||= {}
+    end
+  end
+end

data/lib/pinky/has_caches.rb

@@ -0,0 +1,33 @@
+module Pinky
+  module HasCaches
+    def cachable_by(*methods)
+      create_cache_for methods
+    end
+
+    def update_caches_with(item_hash, action = :create)
+      item = new item_hash
+      pinky_caches.each { |cache| cache.update_with item, action }
+      item
+    end
+
+    def clear_caches
+      pinky_caches.each(&:clear_cache)
+    end
+
+    private
+    def create_cache_for(method_names)
+      cache = Cache.new method_names
+      pinky_caches_by_name[cache.name] = cache
+    end
+
+    def pinky_caches_by_name
+      @pinky_caches_by_name ||= {}
+    end
+
+    def pinky_caches
+      pinky_caches_by_name.values
+    end
+
+  end
+
+end

data/lib/pinky/model.rb

@@ -1,7 +1,8 @@
 module Pinky
   module Model
     def self.included base
-      base.extend ModelFetchMethods unless base.is_a? ModelFetchMethods
+      base.extend HasCaches unless base.is_a?(HasCaches)
+      base.extend ModelFetchMethods unless base.is_a?(ModelFetchMethods)
       base.extend ClassMethods
     end
 

data/lib/pinky/model_fetch_methods.rb

@@ -1,36 +1,57 @@
 module Pinky
   module ModelFetchMethods
-    def self.extended base
-      base.send :include, ModelNaturalKeyMethods unless base.include? ModelNaturalKeyMethods
-      base.extend CachableModel unless base.is_a? CachableModel
+    def self.extended(base)
+      base.extend HasCaches unless base.is_a? HasCaches
     end
 
-    def find natural_key
-      cache[natural_key.to_s]
+    def find(query_hash = {})
+      query_hash = { :id => query_hash } unless query_hash.is_a?(Hash)
+      cache_name = Cache.name_for(*query_hash.keys)
+      raise NotFoundException.new unless cache = pinky_caches_by_name[cache_name]
+      found_object = cache.query(query_hash)
+      return found_object unless found_object.nil?
+      item_hash = lookup_item_hash query_hash
+      update_caches_with item_hash
     end
 
-    def fetch_url url, fetch_opts = {}
-      @fetch_url    = url
-      @fetch_opts   = fetch_opts
-      @response_key = @fetch_opts.delete :response_key
+    private
+    def lookup_item_hash(query)
+      response = HTTParty.get pinky_request_url(query),
+        :query   => pinky_request_query_params(query),
+        :headers => pinky_request_headers(query)
+      raise Exception.new 'Error fetching from results' unless response.success?
+      response_hash = hash_from_pinky_response(response) rescue nil
+      if response_hash.is_a?(Array)
+        raise TooManyFoundException.new "More than one model was returned" if response_hash.size > 1
+        response_hash = response_hash.first
+      end
+      raise NotFoundException.new "No model found for query #{query.inspect}" if response_hash.nil?
+      response_hash
     end
 
-    private
-    def from_wire natural_key
-      url = _fetch_url_for natural_key
-      response = HTTParty.get url, @fetch_opts
-      response = JSON.parse(response.body)
-      raise Exception.new "Error fetching from #{url}#{$/}#{response['errors'].join ','}" unless response['success']
-      response = response['response']
-      response = response.fetch @response_key if @response_key
-      raise NotFoundException.new "No model found for natural_key #{natural_key}" if response.empty?
-      raise TooManyFoundException.new "More than one model was returned" if response.size > 1
-      response.first
-    end
-
-    def _fetch_url_for natural_key
-      raise Exception.new "You must specify a fetch_url for #{self.name}" unless @fetch_url
-      @fetch_url.dup.sub /:natural_key/, natural_key.to_s
+    def hash_from_pinky_response(response)
+      response
+    end
+
+    def pinky_request_hostname(query)
+      raise Exception.new 'Please provide a hostname via: pinky_request_hostname'
+    end
+
+    def pinky_request_path(query)
+      "/#{name.to_s.downcase}"
+    end
+
+    def pinky_request_headers
+      {}
+    end
+
+    def pinky_request_query_params(query)
+      #query.map { |k,v| "#{k}=#{v}" }.join('&')
+      query
+    end
+
+    def pinky_request_url(query)
+      "#{pinky_request_hostname(query)}#{pinky_request_path(query)}"
     end
   end
 end

data/pinky.gemspec

@@ -5,12 +5,12 @@
 
 Gem::Specification.new do |s|
   s.name = "pinky"
-  s.version = "0.1.4"
+  s.version = "0.2.5"
   s.platform = "java"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Joel Friedman"]
-  s.date = "2012-12-10"
+  s.date = "2012-12-12"
   s.description = "Cache your api objects in member easier, with associations."
   s.email = "asher.friedman@gmail.com"
   s.extra_rdoc_files = [
@@ -28,18 +28,18 @@ Gem::Specification.new do |s|
     "VERSION",
     "lib/pinky.rb",
     "lib/pinky/associations.rb",
-    "lib/pinky/cachable_model.rb",
+    "lib/pinky/cache.rb",
     "lib/pinky/energizer_bunny/connection.rb",
     "lib/pinky/energizer_bunny/subscription.rb",
     "lib/pinky/exceptions.rb",
+    "lib/pinky/has_caches.rb",
     "lib/pinky/model.rb",
     "lib/pinky/model_fetch_methods.rb",
-    "lib/pinky/model_natural_key_methods.rb",
     "pinky.gemspec",
     "spec/pinky/associations_spec.rb",
-    "spec/pinky/cachable_model_spec.rb",
+    "spec/pinky/cache_spec.rb",
+    "spec/pinky/has_caches_spec.rb",
     "spec/pinky/model_fetch_methods_spec.rb",
-    "spec/pinky/model_natural_key_methods_spec.rb",
     "spec/pinky/model_spec.rb",
     "spec/spec_helper.rb"
   ]

data/spec/pinky/associations_spec.rb

@@ -21,7 +21,7 @@ module Pinky
 
     it 'looks up employee by employee_id' do
       member = member_klass.new 123
-      Employee.should_receive(:find).with(123)
+      Employee.should_receive(:find).with(:id => 123)
       FooBar.should_not_receive(:find)
 
       member.employee
@@ -29,7 +29,7 @@ module Pinky
 
     it 'looks up FooBar by employee_id' do
       member = member_klass.new 999
-      FooBar.should_receive(:find).with(999)
+      FooBar.should_receive(:find).with(:id => 999)
       Employee.should_not_receive(:find)
 
       member.foobar

data/spec/pinky/cache_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path '../../spec_helper', __FILE__
+require 'date'
+
+module Pinky
+  describe Cache do
+    let(:cache) { Cache.new :id, :name }
+
+    context 'Cache#name_for' do
+      it { Cache.name_for(:id).should == 'cache_by_id' }
+      it { Cache.name_for(:id, :name).should == 'cache_by_id_and_name' }
+      it { Cache.name_for(:name, :id).should == 'cache_by_id_and_name' }
+      it { cache.name.should == 'cache_by_id_and_name' }
+    end
+
+    context 'as a cache' do
+      it 'should be able to add and read an item' do
+        item = mock(:id => 123, :name => 'joel')
+        cache.empty?.should be_true
+        cache.update_with(item, :create)
+        cache.empty?.should be_false
+      end
+
+      it 'should update cache' do
+        item = mock(:id => 123, :name => 'joel', :foo => 'first')
+        cache.update_with(item, :create)
+        item = mock(:id => 123, :name => 'joel', :foo => 'second')
+        cache.update_with(item, :update)
+
+        cache.size.should == 1
+        cache.query(:id => 123, :name => 'joel').foo.should == 'second'
+      end
+
+      it 'should remove from cache' do
+        item = mock(:id => 123, :name => 'joel', :foo => 'first')
+        cache.update_with(item, :create)
+        cache.update_with(item, :destroy)
+        cache.empty?.should be_true
+      end
+    end
+
+    context 'queryable' do
+      let (:cache_hit_query) { { :name => 'guy', :id => 123 } }
+      let (:cache_miss_query) { { :id => 123 } }
+
+      it 'should respond as being queryable' do
+        cache.queryable_for?(cache_hit_query).should be_true
+      end
+
+      it 'should respond as not being queryable' do
+        cache.queryable_for?(cache_miss_query).should be_false
+      end
+    end
+  end
+end

data/spec/pinky/has_caches_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path '../../spec_helper', __FILE__
+
+module Pinky
+  describe HasCaches do
+    context 'with cachable_by declared' do
+      klass = Class.new do
+        extend Pinky::HasCaches
+        cachable_by :token
+        cachable_by :id, :foo
+
+        attr_reader :id, :foo, :bar, :token
+        def initialize id, foo, bar, token
+          @id, @foo, @bar, @token = id, foo, bar, token
+        end
+      end
+
+      it 'will create a Cache for each cachable_by' do
+        caches = klass.send(:pinky_caches)
+        caches.size.should == 2
+      end
+    end
+  end
+end

data/spec/pinky/model_fetch_methods_spec.rb

@@ -1,51 +1,55 @@
 require File.expand_path '../../spec_helper', __FILE__
-require 'date'
 
 module Pinky
   describe ModelFetchMethods do
-    member_klass = Class.new do
-      extend Pinky::ModelFetchMethods
-      natural_key :id
-      fetch_url 'http://fake.com/member?id=:natural_key', :response_key => 'members',
-        :headers => { 'Accept' => 'version=1' },
-        :query   => { 'token'  => '123' }
-
-      def initialize hash; @hash = hash end
-      def id; @hash['id'] end
-    end
-
-    before do
-      @response =  {
-        :success => true,
-        :response => {
-          :members => [
-            {:id => 4255, :token => 'fakeToken123', :first_name => 'Joel', :last_name => 'Friedman', :email => 'joel@example' }
-          ]
-        },
-        :errors => nil
-      }.to_json
-    end
-
-    context '#find' do
-      before do
-        url = 'http://fake.com/member?id=4255'
-        HTTParty.should_receive(:get).with(url,
-                                           :headers => { 'Accept' => 'version=1' },
-                                           :query   => { 'token'  => '123' }
-                                          ).once.and_return(stub(:body => @response))
+    context 'caches' do
+      member_klass = Class.new do
+        extend Pinky::ModelFetchMethods
+        cachable_by :id
+
+        def initialize hash; @hash = hash end
+        def id; @hash[:id] end
+
+        class << self
+          def pinky_request_hostname(query)
+            'http://fake.com'
+          end
+
+          def pinky_request_path(query)
+            '/member'
+          end
+
+          def pinky_request_headers(query)
+            { 'Accept' => 'version=1' }
+          end
+        end
       end
 
-      after { member_klass.clear_cache }
-
-      it 'not raise an exception' do
-        expect { member_klass.find 4255 }.to_not raise_error
+      let(:response)  {
+        {:id => 4255, :token => 'fakeToken123', :first_name => 'Joel', :last_name => 'Friedman', :email => 'joel@example' }.tap { |r| r.stub(:success? => true) }
+      }
+
+      context '#find' do
+        before do
+          url = 'http://fake.com/member'
+          HTTParty.should_receive(:get).with(url,
+                                             :headers => { 'Accept' => 'version=1' },
+                                             :query   => { :id      => 4255 }
+                                            ).once.and_return(response)
+        end
+
+        after { member_klass.clear_caches }
+
+        it 'not raise an exception' do
+          expect { member_klass.find :id => 4255 }.to_not raise_error
+        end
+
+        it 'caches the object' do
+          member_klass.find :id => 4255
+          member_klass.find :id => 4255
+        end
       end
 
-      it 'caches the object' do
-        member_klass.find 4255
-        member_klass.find 4255
-      end
     end
-
   end
 end

data/spec/pinky/model_spec.rb

@@ -4,8 +4,6 @@ module Pinky
   describe Model do
     member_klass = Class.new do
       include Pinky::Model
-      natural_key :id
-
       def full_name
         "#{first_name} #{last_name}"
       end

metadata

@@ -2,14 +2,14 @@
 name: pinky
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.1.4
+  version: 0.2.5
 platform: java
 authors:
 - Joel Friedman
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-12-10 00:00:00.000000000 Z
+date: 2012-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -167,18 +167,18 @@ files:
 - VERSION
 - lib/pinky.rb
 - lib/pinky/associations.rb
-- lib/pinky/cachable_model.rb
+- lib/pinky/cache.rb
 - lib/pinky/energizer_bunny/connection.rb
 - lib/pinky/energizer_bunny/subscription.rb
 - lib/pinky/exceptions.rb
+- lib/pinky/has_caches.rb
 - lib/pinky/model.rb
 - lib/pinky/model_fetch_methods.rb
-- lib/pinky/model_natural_key_methods.rb
 - pinky.gemspec
 - spec/pinky/associations_spec.rb
-- spec/pinky/cachable_model_spec.rb
+- spec/pinky/cache_spec.rb
+- spec/pinky/has_caches_spec.rb
 - spec/pinky/model_fetch_methods_spec.rb
-- spec/pinky/model_natural_key_methods_spec.rb
 - spec/pinky/model_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/trunkclub/pinky

data/lib/pinky/cachable_model.rb

@@ -1,23 +0,0 @@
-module Pinky
-  module CachableModel
-    def self.extended base
-      base.send :include, ModelNaturalKeyMethods unless base.include? ModelNaturalKeyMethods
-    end
-
-    def update_cache_with item_hash, action
-      item = new item_hash
-      cache.delete item.natural_key
-      cache[item.natural_key] = item unless action.to_sym == :destroy
-      item
-    end
-
-    def clear_cache
-      @cache = nil
-    end
-
-    private
-    def cache
-      @cache ||= Hash.new { |cache_hash, nat_key| update_cache_with from_wire(nat_key), :create }
-    end
-  end
-end

data/lib/pinky/model_natural_key_methods.rb

@@ -1,34 +0,0 @@
-module Pinky
-  module ModelNaturalKeyMethods
-    def self.included base
-      base.extend ClassMethods
-    end
-
-    def natural_key
-      natural_key_methods.map { |method_name| send method_name }.join natural_key_separator
-    end
-
-    private
-    def natural_key_methods
-      self.class.natural_key or raise Exception.new('You must specify a natural_key, ex: natural_key :first_name, :last_name')
-    end
-
-    def natural_key_separator
-      self.class.natural_key_separator
-    end
-
-    module ClassMethods
-      def natural_key *methods
-        return @natural_key if methods.nil? || methods.empty?
-        @natural_key = methods
-      end
-
-      def natural_key_separator sep = nil
-        return @natural_key_separator || '.' if sep.nil?
-        @natural_key_separator = sep
-      end
-
-    end
-
-  end
-end

data/spec/pinky/cachable_model_spec.rb

@@ -1,52 +0,0 @@
-require File.expand_path '../../spec_helper', __FILE__
-require 'date'
-
-module Pinky
-  describe CachableModel do
-    member_klass = Class.new do
-      extend Pinky::CachableModel
-      natural_key :id
-
-      def self.cache_hash; cache end
-
-      def initialize hash; @hash = hash end
-      def id; @hash[:id] end
-      def last_name; @hash[:last_name] end
-    end
-
-    before do
-      @hash = {
-        :id         => 4255,
-        :token      => 'fakeToken123',
-        :first_name => 'Joel',
-        :last_name  => 'Friedman',
-        :email      => 'joel@example'
-      }
-    end
-
-    after { member_klass.clear_cache }
-
-    context 'udpate_cache' do
-      it 'adds a new item to cache if action is :create' do
-        member_klass.update_cache_with @hash, :create
-        member_klass.cache_hash.key? 4255
-      end
-
-      it 'updates the entry if action is :update' do
-        member_klass.cache_hash['4255'] = member_klass.new(@hash)
-        member_klass.update_cache_with @hash.merge(:last_name => 'Foster'), :update
-
-        member_klass.cache_hash.keys.should == ['4255']
-        member_klass.cache_hash['4255'].last_name.should == 'Foster'
-      end
-
-      it 'removes the entry if action is :destroy' do
-        member_klass.cache_hash['4255'] = member_klass.new(@hash)
-        member_klass.update_cache_with @hash, :destroy
-
-        member_klass.cache_hash.empty?.should be_true
-      end
-    end
-
-  end
-end

data/spec/pinky/model_natural_key_methods_spec.rb

@@ -1,46 +0,0 @@
-require File.expand_path '../../spec_helper', __FILE__
-
-module Pinky
-  describe ModelNaturalKeyMethods do
-
-    context 'with natural_key declared' do
-      klass = Class.new do
-        include Pinky::ModelNaturalKeyMethods
-        natural_key :id, :foo
-        
-        attr_reader :id, :foo, :bar
-        def initialize id, foo, bar
-          @id, @foo, @bar = id, foo, bar
-        end
-      end
-
-
-      it 'should create a natural key' do
-        instance = klass.new(123, 'hey', 'world')
-        instance.natural_key.should == '123.hey'
-      end
-
-      it 'can change the key separator' do
-        klass.natural_key_separator '---'
-        instance = klass.new(123, 'hey', 'world')
-        instance.natural_key.should == '123---hey'
-      end
-    end
-
-    context 'without natural_key declared' do
-      klass = Class.new do
-        include Pinky::ModelNaturalKeyMethods
-
-        attr_reader :id
-        def initialize
-          @id = 123
-        end
-      end
-
-      it 'should raise an error' do
-        instance = klass.new
-        expect { instance.natural_key }.to raise_error(Exception)
-      end
-    end
-  end
-end