api_hammer 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 96ebda010e8ade01533266d0f06a7e13026fd746
-  data.tar.gz: a5e217afbf69ec2d4c0fb2635cce63ba4baf2c9a
+  metadata.gz: 9927a5896d97412a1668d60c7f341649cca1232c
+  data.tar.gz: 0d65a4cf1399613c3f1433f0a456f88ae1cf9008
 SHA512:
-  metadata.gz: 8f7a065899bd65bc13b9dee409796d9778c3104a7bb2addc7a65e33409e3f94de247fa3d4ae2a3dd826d5ee630b9beb1af32a0f96a410c65dd629b616e88716d
-  data.tar.gz: f4c8bd00c8c74a02517594fd55e45ba08f46ebb44ad87104ddc87d13e59c75acbfc48a04dc13a48a048a9add4676c5ce39c7a1383c3a50777e5a02b5d1c238c5
+  metadata.gz: 1f1fdf86e116a112eee8a09420b62d356ce66ac8522e41ef30470862ed7c29491e0cbe7fa02e5fe7b63bb834887d572a68feeeb5fc9ab5eede0db6ddebe3e95c
+  data.tar.gz: 51a41edd33b376e0d2cc9e49ff86fa0d60afa7cb8dbda2d4ebac12b10f64c300002813db33f79d7f914d52a9f9636f87c11bea584aa06fcf081705b81e96ecb6

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+# 0.3.0
+- ActiveRecord::Base.cache_find_by
+
 # 0.2.2
 - RequestLogger, in addition to logging response bodies on error, logs id/uuid fields from request body and 
   response body if there's no error

data/Rakefile.rb

@@ -4,7 +4,8 @@ Rake::TestTask.new do |t|
   t.test_files = FileList['test/**/*_test.rb']
   t.verbose = true
 end
-task 'default' => 'test'
+require 'wwtd/tasks'
+task 'default' => 'wwtd'
 
 require 'yard'
 YARD::Rake::YardocTask.new do |t|

data/lib/api_hammer/active_record_cache_find_by.rb

@@ -0,0 +1,135 @@
+require 'active_record'
+
+module ActiveRecord
+  class Relation
+    if !method_defined?(:first_without_caching)
+      alias_method :first_without_caching, :first
+      def first(*args)
+        one_record_with_caching(args.empty?) { first_without_caching(*args) }
+      end
+    end
+    if !method_defined?(:take_without_caching) && method_defined?(:take)
+      alias_method :take_without_caching, :take
+      def take(*args)
+        one_record_with_caching(args.empty?) { take_without_caching(*args) }
+      end
+    end
+
+    # retrieves one record, hitting the cache if appropriate. the argument may bypass caching 
+    # (the caller could elect to just not call this method if caching is to be avoided, but since this 
+    # method already builds in opting whether or not to hit cache, the code is simpler just passing that in).
+    #
+    # requires a block which returns the record 
+    def one_record_with_caching(can_cache = true)
+      actual_right = proc do |where_value|
+        if where_value.right.is_a?(Arel::Nodes::BindParam)
+          column, value = bind_values.detect { |(column, value)| column.name == where_value.left.name }
+          value
+        else
+          where_value.right
+        end
+      end
+      cache_find_bys = klass.send(:cache_find_bys)
+      can_cache &&= cache_find_bys &&
+        !loaded? && # if it's loaded no need to hit cache 
+        where_values.all? { |wv| wv.is_a?(Arel::Nodes::Equality) } && # no inequality or that sort of thing 
+        cache_find_bys.include?(where_values.map { |wv| wv.left.name }.sort) && # any of the set of where-values to cache match this relation 
+        where_values.map(&actual_right).all? { |r| r.is_a?(String) || r.is_a?(Numeric) } && # check all right side values are simple types, number or string 
+        offset_value.nil? &&
+        joins_values.blank? &&
+        order_values.blank? &&
+        !reverse_order_value &&
+        includes_values.blank? &&
+        preload_values.blank? &&
+        select_values.blank? &&
+        group_values.blank? &&
+        from_value.nil? &&
+        lock_value.nil?
+
+      if can_cache
+        cache_key = klass.send(:cache_key_for, where_values.map { |wv| [wv.left.name, actual_right.call(wv)] })
+        klass.finder_cache.fetch(cache_key) do
+          yield
+        end
+      else
+        yield
+      end
+    end
+  end
+
+  class Base
+    class << self
+      def finder_cache=(val)
+        define_singleton_method(:finder_cache) { val }
+      end
+
+      # the cache. should be an instance of some sort of ActiveSupport::Cache::Store. 
+      # by default uses Rails.cache if that exists, or creates a ActiveSupport::Cache::MemoryStore to use. 
+      # set this per-model or on ActiveRecord::Base, as needed; it is inherited. 
+      def finder_cache
+        # dummy; this gets set below 
+      end
+
+      # causes requests to retrieve a record by the given attributes (all of them) to be cached. 
+      # this is for single records only. it is unsafe to use with a set of attributes whose values 
+      # (in conjunction) may be associated with multiple records. 
+      #
+      # see .finder_cache and .find_cache= for where it is cached. 
+      #
+      # #flush_find_cache is defined on the instance. it is called on save to clear an updated record from 
+      # the cache. it may also be called explicitly to clear a record from the cache. 
+      #
+      # beware of multiple application servers with different caches - a record cached in multiple will not 
+      # be invalidated in all when it is saved in one.
+      def cache_find_by(*attribute_names)
+        unless cache_find_bys
+          # initial setup
+          self.cache_find_bys = Set.new
+          after_update :flush_find_cache
+          before_destroy :flush_find_cache
+        end
+
+        find_by = attribute_names.map do |name|
+          raise(ArgumentError) unless name.is_a?(Symbol) || name.is_a?(String)
+          name.to_s.dup.freeze
+        end.sort.freeze
+
+        self.cache_find_bys = (cache_find_bys | [find_by]).freeze
+      end
+
+      private
+      def cache_find_bys=(val)
+        define_singleton_method(:cache_find_bys) { val }
+        singleton_class.send(:private, :cache_find_bys)
+      end
+
+      def cache_find_bys
+        nil
+      end
+
+      def cache_key_for(find_attributes)
+        attrs = find_attributes.map { |k,v| [k.to_s, v.to_s] }.sort_by(&:first).inject([], &:+)
+        cache_key_prefix = ['cache_find_by', table_name]
+        @parser ||= URI.const_defined?(:Parser) ? URI::Parser.new : URI
+        cache_key = (cache_key_prefix + attrs).map do |part|
+          @parser.escape(part, /[^a-z0-9\-\.\_\~]/i)
+        end.join('/')
+      end
+    end
+
+    # the above dummy method has no content because we want to evaluate this now, not in the method, to 
+    # avoid instantiating duplicate MemoryStores. 
+    self.finder_cache = (Object.const_defined?(:Rails) && ::Rails.cache) || ::ActiveSupport::Cache::MemoryStore.new
+
+    # clears this record from the cache used by cache_find_by
+    def flush_find_cache
+      self.class.send(:cache_find_bys).each do |attribute_names|
+        find_attributes = attribute_names.map { |attr_name| [attr_name, attribute_was(attr_name)] }
+        self.class.instance_exec(find_attributes) do |find_attributes|
+          finder_cache.delete(cache_key_for(find_attributes))
+        end
+      end
+      nil
+    end
+  end
+end

data/lib/api_hammer/version.rb

@@ -1,3 +1,3 @@
 module ApiHammer
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/test/active_record_cache_find_by_test.rb

@@ -0,0 +1,201 @@
+proc { |p| $:.unshift(p) unless $:.any? { |lp| File.expand_path(lp) == p } }.call(File.expand_path('.', File.dirname(__FILE__)))
+require 'helper'
+
+require 'active_support/cache'
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(
+  :adapter => "sqlite3",
+  :database  => ":memory:"
+)
+
+module Rails
+  class << self
+    def cache
+      @cache ||= ActiveSupport::Cache::MemoryStore.new
+    end
+  end
+end
+
+require 'api_hammer/active_record_cache_find_by'
+
+ActiveRecord::Schema.define do
+  create_table :albums do |table|
+    table.column :title, :string
+    table.column :performer, :string
+    table.column :tracks, :integer
+  end
+end
+
+class Album < ActiveRecord::Base
+  cache_find_by(:id)
+  cache_find_by(:performer)
+  cache_find_by(:title, :performer)
+  cache_find_by(:tracks)
+end
+
+class VinylAlbum < Album
+  self.finder_cache = ActiveSupport::Cache::MemoryStore.new
+end
+
+describe 'ActiveRecord::Base.cache_find_by' do
+  def assert_caches(key, cache = Rails.cache)
+    assert !cache.read(key), "cache already contains a key #{key}: #{cache.read(key)}"
+    yield
+  ensure
+    assert cache.read(key), "key #{key} was not cached"
+  end
+
+  def assert_not_caches(key, cache = Rails.cache)
+    assert !cache.read(key), "cache already contains a key #{key}: #{cache.read(key)}"
+    yield
+  ensure
+    assert !cache.read(key), "key was incorrectly cached - #{key}: #{cache.read(key)}"
+  end
+
+  after do
+    Album.all.each(&:destroy)
+  end
+
+  it('caches #find by primary key') do
+    id = Album.create!.id
+    assert_caches("cache_find_by/albums/id/#{id}") { assert Album.find(id) }
+  end
+
+  it('caches #find_by_id') do
+    id = Album.create!.id
+    assert_caches("cache_find_by/albums/id/#{id}") { assert Album.find_by_id(id) }
+  end
+
+  it('caches #where.first with primary key') do
+    id = Album.create!.id
+    assert_caches("cache_find_by/albums/id/#{id}") { assert Album.where(:id => id).first }
+  end
+
+  it('caches find_by_x with one attribute') do
+    Album.create!(:performer => 'x')
+    assert_caches("cache_find_by/albums/performer/x") { assert Album.find_by_performer('x') }
+  end
+
+  it('caches find_by_x! with one attribute') do
+    Album.create!(:performer => 'x')
+    assert_caches("cache_find_by/albums/performer/x") { assert Album.find_by_performer!('x') }
+  end
+
+  it('caches where.first with one attribute') do
+    Album.create!(:performer => 'x')
+    assert_caches("cache_find_by/albums/performer/x") { assert Album.where(:performer => 'x').first }
+  end
+
+  it('caches where.first! with one attribute') do
+    Album.create!(:performer => 'x')
+    assert_caches("cache_find_by/albums/performer/x") { assert Album.where(:performer => 'x').first! }
+  end
+
+  it('caches #where.first with integer attribute') do
+    id = Album.create!(:tracks => 3).id
+    assert_caches("cache_find_by/albums/tracks/3") { assert Album.where(:tracks => 3).first }
+  end
+
+  it('does not cache #where.first with inequality of integer attribute') do
+    id = Album.create!(:tracks => 3).id
+    assert_not_caches("cache_find_by/albums/tracks/3") { assert Album.where(Album.arel_table['tracks'].gteq(3)).first }
+  end
+
+  if ActiveRecord::Relation.method_defined?(:take)
+    it('caches where.take with one attribute') do
+      Album.create!(:performer => 'x')
+      assert_caches("cache_find_by/albums/performer/x") { assert Album.where(:performer => 'x').take }
+    end
+  end
+
+  it('does not cache where.last with one attribute') do
+    Album.create!(:performer => 'x')
+    assert_not_caches("cache_find_by/albums/performer/x") { assert Album.where(:performer => 'x').last }
+  end
+
+  it('does not cache find with array') do
+    ids = [Album.create!.id, Album.create!.id]
+    assert_not_caches("cache_find_by/albums/id/#{ids.first}") { assert Album.find(ids) }
+  end
+
+  it('does not cache find_by_x with array') do
+    ids = [Album.create!.id, Album.create!.id]
+    assert_not_caches("cache_find_by/albums/id/#{ids.first}") { assert Album.find_by_id(ids) }
+  end
+
+  it('does not cache where.first with array') do
+    ids = [Album.create!.id, Album.create!.id]
+    assert_not_caches("cache_find_by/albums/id/#{ids.first}") { assert Album.where(:id => ids).first }
+  end
+
+  it('does not cache find_by_x with one attribute') do
+    Album.create!(:title => 'x')
+    assert_not_caches("cache_find_by/albums/title/x") { assert Album.find_by_title('x') }
+  end
+
+  it('does not cache where.first with one attribute') do
+    Album.create!(:title => 'x')
+    assert_not_caches("cache_find_by/albums/title/x") { assert Album.where(:title => 'x').first }
+  end
+
+  it('caches find_by_x with two attributes') do
+    Album.create!(:title => 'x', :performer => 'y')
+    assert_caches("cache_find_by/albums/performer/y/title/x") { assert Album.find_by_title_and_performer('x', 'y') }
+  end
+
+  it('caches where.first with two attributes') do
+    Album.create!(:title => 'x', :performer => 'y')
+    assert_caches("cache_find_by/albums/performer/y/title/x") { assert Album.where(:title => 'x', :performer => 'y').first }
+  end
+
+  it('flushes cache on save') do
+    album = Album.create!(:title => 'x', :performer => 'y')
+    assert_caches(key1 = "cache_find_by/albums/performer/y/title/x") { assert Album.find_by_title_and_performer('x', 'y') }
+    assert_caches(key2 = "cache_find_by/albums/performer/y") { assert Album.find_by_performer('y') }
+    album.update_attributes!(:performer => 'z')
+    assert !Rails.cache.read(key1), Rails.cache.instance_eval { @data }.inspect
+    assert !Rails.cache.read(key2), Rails.cache.instance_eval { @data }.inspect
+  end
+
+  it('flushes cache on destroy') do
+    album = Album.create!(:title => 'x', :performer => 'y')
+    assert_caches(key1 = "cache_find_by/albums/performer/y/title/x") { assert Album.find_by_title_and_performer('x', 'y') }
+    assert_caches(key2 = "cache_find_by/albums/performer/y") { assert Album.find_by_performer('y') }
+    album.destroy
+    assert !Rails.cache.read(key1), Rails.cache.instance_eval { @data }.inspect
+    assert !Rails.cache.read(key2), Rails.cache.instance_eval { @data }.inspect
+  end
+
+  it 'inherits cache_find_bys' do
+    assert VinylAlbum.send(:cache_find_bys).any? { |f| f == ['id'] }
+  end
+
+  it 'uses a different cache when specified' do
+    assert Album.finder_cache != VinylAlbum.finder_cache
+
+    id = Album.create!.id
+    key = "cache_find_by/albums/id/#{id}"
+    assert_caches(key) do
+      assert_not_caches(key, VinylAlbum.finder_cache) do
+        assert Album.find(id)
+      end
+    end
+
+    id = VinylAlbum.create!.id
+    key = "cache_find_by/albums/id/#{id}"
+    assert_caches(key, VinylAlbum.finder_cache) do
+      assert_not_caches(key) do
+        assert VinylAlbum.find(id)
+      end
+    end
+  end
+
+  it 'does not get confused by values with slashes' do
+    Album.create!(:title => 'z', :performer => 'y/title/x')
+    Album.create!(:title => 'x', :performer => 'y')
+
+    Album.where(:performer => 'y', :title => 'x').first
+    assert_equal 'z', Album.where(:performer => 'y/title/x').first.title
+  end
+end

data/test/halt_test.rb

@@ -36,10 +36,8 @@ describe 'ApiHammer::Rails#halt' do
     it 'returns a record if it exists' do
       record = Object.new
       model = Class.new do
-        (class << self; self; end).class_eval do
-          define_method(:where) { |attrs| [record] }
-          define_method(:table_name) { 'records' }
-        end
+        define_singleton_method(:where) { |attrs| [record] }
+        define_singleton_method(:table_name) { 'records' }
       end
       assert_equal record, FakeController.new.find_or_halt(model, {:id => 'anid'})
     end

data/test/helper.rb

@@ -1,6 +1,10 @@
 proc { |p| $:.unshift(p) unless $:.any? { |lp| File.expand_path(lp) == p } }.call(File.expand_path('../lib', File.dirname(__FILE__)))
 
+require 'bundler'
+Bundler.setup
+
 require 'simplecov'
+require 'byebug'
 
 # NO EXPECTATIONS 
 ENV["MT_NO_EXPECTATIONS"] = ''

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: api_hammer
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Ethan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-04 00:00:00.000000000 Z
+date: 2014-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -164,6 +164,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: actually a set of small API-related tools. very much unlike a hammer
   at all, which is one large tool.
 email:
@@ -181,6 +223,7 @@ files:
 - Rakefile.rb
 - bin/hc
 - lib/api_hammer.rb
+- lib/api_hammer/active_record_cache_find_by.rb
 - lib/api_hammer/check_required_params.rb
 - lib/api_hammer/faraday/outputter.rb
 - lib/api_hammer/halt.rb
@@ -196,6 +239,7 @@ files:
 - lib/api_hammer/unmunged_request_params.rb
 - lib/api_hammer/version.rb
 - lib/api_hammer/weblink.rb
+- test/active_record_cache_find_by_test.rb
 - test/check_required_params_test.rb
 - test/halt_test.rb
 - test/helper.rb
@@ -229,6 +273,7 @@ signing_key:
 specification_version: 4
 summary: an API tool
 test_files:
+- test/active_record_cache_find_by_test.rb
 - test/check_required_params_test.rb
 - test/halt_test.rb
 - test/helper.rb