api_hammer 0.13.3 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0ec8f15a064560aa1f4f50123bbcf2a334130488
-  data.tar.gz: c29ed9ef11362ef5a872d617d656b3a56c879198
+  metadata.gz: 909efcbfb3f192ecb429eaf23a7dce4a1d07dd68
+  data.tar.gz: 9526647e571cdce3a3f39911dbaa116897d8277b
 SHA512:
-  metadata.gz: c681350085a2cbcfbfc208f988ce91700e98b5350a1bd13d26ca06008a256e5a159c40b88b2f236944097549c334908b05af1ae30ce907d4421187f76d84bf2e
-  data.tar.gz: 92ae18c0f12d10abb11829e129fcd648142910b0ccbcbcaeeaf06ec072785c4bcfea46841002e3bef16149859652a32b40273d7d52ef87b14f3fa1391abce6da
+  metadata.gz: d965bcb0458ef5c542e1ab0ebc2b0cfc4955ca98d1231def62582cc458aad1450bc897e31d1bd1803696f438bd5b2e81ac0769cfa10b18d998c6150912132be8
+  data.tar.gz: 95ba356edbba139809480c576e632e0cf464dbc9b854d11fcd37dce1b82375d338020a320bf801c0f31fdb2149cce6ed42e900b04c1dc4c8a74b781543e60b61

data/.travis.yml

@@ -1,7 +1,4 @@
-# we don't actually use travis, just wwtd 
-
-gemfile:
-  - Gemfile_ar_3
-  - Gemfile_ar_40
-  - Gemfile_ar_41
+rvm:
+  - 2.0.0-p353
+  - 2.2.4
 script: rake test

data/CHANGELOG.md

@@ -1,8 +1,18 @@
+# v0.14.0
+- some rails 5 support
+  - check_required_params to support ActionController::Parameters #44
+  - handle not loading deprecated log_tailer when not found #33
+  - use ruby String#bytesize instead of Rack::Util #34
+- fix same bug as v0.13.3 with logging non-ascii bodies on faraday logger #35
+- remove ActiveRecord cache_find_by
+- option :log_bodies for request loggers
+- fix warnings when run with -w
+
 # v0.13.3
-- fix bug when logging non-ascii bodies with filtration enabled
+- fix bug when logging non-ascii bodies with filtration enabled #31
 
 # v0.13.2
-- fix with_indifferent_access usage when we don't depend on activesupport
+- fix with_indifferent_access usage when we don't depend on activesupport #29
 
 # v0.13.1
 - ApiHammer::Sinatra class method use_with_lint

data/api_hammer.gemspec

@@ -27,6 +27,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'json'
   spec.add_dependency 'addressable'
   spec.add_dependency 'coderay'
+  spec.add_dependency 'i18n'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rack-test'
   spec.add_development_dependency 'minitest'
@@ -34,6 +35,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'yard'
   spec.add_development_dependency 'simplecov'
   spec.add_development_dependency 'activesupport'
-  spec.add_development_dependency 'activerecord'
   spec.add_development_dependency 'sqlite3'
 end

data/lib/api_hammer/content_type_attrs.rb

@@ -2,7 +2,7 @@ module ApiHammer
   # parses attributes out of content type header
   class ContentTypeAttrs
     def initialize(content_type)
-      @media_type = content_type.split(/\s*[;]\s*/, 2).first if content_type
+      @media_type = (content_type.split(/\s*[;]\s*/, 2).first if content_type)
       @media_type.strip! if @media_type
       @content_type = content_type
       @parsed = false
@@ -12,7 +12,7 @@ module ApiHammer
         uri_parser = URI.const_defined?(:Parser) ? URI::Parser.new : URI
         scanner = StringScanner.new(content_type)
         scanner.scan(/.*;\s*/) || throw(:unparseable)
-        while match = scanner.scan(/(\w+)=("?)([^"]*)("?)\s*(,?)\s*/)
+        while scanner.scan(/(\w+)=("?)([^"]*)("?)\s*(,?)\s*/)
           key = scanner[1]
           quote1 = scanner[2]
           value = scanner[3]

data/lib/api_hammer/faraday/request_logger.rb

@@ -2,6 +2,7 @@ require 'faraday'
 require 'term/ansicolor'
 require 'json'
 require 'strscan'
+require 'api_hammer/request_logger'
 
 module ApiHammer
   module Faraday
@@ -15,8 +16,10 @@ module ApiHammer
     #
     # options:
     # - :filter_keys defines keys whose values will be filtered out of the logging 
+    # - :log_bodies - true, false, :on_error
     class RequestLogger < ::Faraday::Middleware
       include Term::ANSIColor
+      include ApiHammer::RequestLoggerHelper
 
       def initialize(app, logger, options={})
         @app = app
@@ -34,30 +37,24 @@ module ApiHammer
 
         @app.call(request_env).on_complete do |response_env|
           now = Time.now
+          status = response_env.status
 
-          status_color = case response_env.status.to_i
-          when 200..299
-            :intense_green
-          when 400..499
-            :intense_yellow
-          when 500..599
-            :intense_red
-          else
-            :white
-          end
-          status_s = bold(send(status_color, response_env.status.to_s))
-
-          bodies = [
-            ['request', request_body, request_env.request_headers],
-            ['response', response_env.body, response_env.response_headers]
-          ].map do |(role, body, headers)|
-            {role => Body.new(body, headers['Content-Type']).jsonifiable}
-          end.inject({}, &:update)
-
-          if @options[:filter_keys]
-            bodies = bodies.map do |(role, body)|
-              {role => body.filtered(@options.slice(:filter_keys))}
+          if log_bodies(status)
+            bodies = [
+              ['request', request_body, request_env.request_headers],
+              ['response', response_env.body, response_env.response_headers]
+            ].map do |(role, body_s, headers)|
+              body = Body.new(body_s, headers['Content-Type'])
+              if body.content_type_attrs.text?
+                if @options[:filter_keys]
+                  body = body.filtered(:filter_keys => @options[:filter_keys])
+                end
+                log_body = body.jsonifiable.body
+              end
+              {role => log_body}
             end.inject({}, &:update)
+          else
+            bodies = {}
           end
 
           data = {
@@ -66,24 +63,24 @@ module ApiHammer
               'method' => request_env[:method],
               'uri' => request_env[:url].normalize.to_s,
               'headers' => request_env.request_headers,
-              'body' => (bodies['request'].body if bodies['request'].content_type_attrs.text?),
+              'body' => bodies['request'],
             }.reject{|k,v| v.nil? },
             'response' => {
-              'status' => response_env.status.to_s,
+              'status' => status.to_s,
               'headers' => response_env.response_headers,
-              'body' => (bodies['response'].body if bodies['response'].content_type_attrs.text?),
+              'body' => bodies['response'],
             }.reject{|k,v| v.nil? },
             'processing' => {
               'began_at' => began_at.utc.to_f,
               'duration' => now - began_at,
-              'activesupport_tagged_logging_tags' => @log_tags,
+              'activesupport_tagged_logging_tags' => log_tags,
             }.reject{|k,v| v.nil? },
           }
 
           json_data = JSON.generate(data)
           dolog = proc do
             now_s = now.strftime('%Y-%m-%d %H:%M:%S %Z')
-            @logger.info "#{bold(intense_magenta('>'))} #{status_s} : #{bold(intense_magenta(request_env[:method].to_s.upcase))} #{intense_magenta(request_env[:url].normalize.to_s)} @ #{intense_magenta(now_s)}"
+            @logger.info "#{bold(intense_magenta('>'))} #{status_s(status)} : #{bold(intense_magenta(request_env[:method].to_s.upcase))} #{intense_magenta(request_env[:url].normalize.to_s)} @ #{intense_magenta(now_s)}"
             @logger.info json_data
           end
 

data/lib/api_hammer/filtration/form_encoded.rb

@@ -17,7 +17,7 @@ module ApiHammer
           end
           if ss.scan(/[^&;]+/)
             kv = ss[0]
-            key, value = kv.split('=', 2)
+            key, _ = kv.split('=', 2)
             parsed_key = CGI::unescape(key)
             if [*@options[:filter_keys]].any? { |fk| parsed_key =~ /(\A|[\[\]])#{Regexp.escape(fk)}(\z|[\[\]])/ }
               filtered << [key, '[FILTERED]'].join('=')

data/lib/api_hammer/rails/check_required_params.rb

@@ -35,9 +35,9 @@ module ApiHammer::Rails
       when Array
         check.each { |subcheck| check_required_params_helper(subcheck, subparams, errors, parents) }
       when Hash
-        if subparams.is_a?(Hash)
-          check.each do |key, subcheck|
-            check_required_params_helper(subcheck, subparams[key], errors, parents + [key])
+        if subparams.is_a?(Hash) || (Object.const_defined?('ActionController') && subparams.is_a?(::ActionController::Parameters))
+          check.each do |key_, subcheck|
+            check_required_params_helper(subcheck, subparams[key_], errors, parents + [key_])
           end
         else
           add_error.call(I18n.t(:"errors.required_params.must_be_hash", :default => "%{key} must be a Hash", :key => key))

data/lib/api_hammer/rails_request_logging.rb

@@ -1,15 +1,23 @@
 require 'api_hammer'
 require 'active_support/log_subscriber'
 
-require 'rails/rack/log_tailer'
-# fix up this class to tail the log when the body is closed rather than when its own #call is done. 
-module Rails
-  module Rack
-    class LogTailer
-      def call(env)
-        status, headers, body = @app.call(env)
-        body_proxy = ::Rack::BodyProxy.new(body) { tail! }
-        [status, headers, body_proxy]
+begin
+  require 'rails/rack/log_tailer'
+  log_tailer_exists = true
+rescue LoadError
+  log_tailer_exists = false
+end
+
+if log_tailer_exists
+  # fix up this class to tail the log when the body is closed rather than when its own #call is done. 
+  module Rails
+    module Rack
+      class LogTailer
+        def call(env)
+          status, headers, body = @app.call(env)
+          body_proxy = ::Rack::BodyProxy.new(body) { tail! }
+          [status, headers, body_proxy]
+        end
       end
     end
   end

data/lib/api_hammer/request_logger.rb

@@ -4,6 +4,32 @@ require 'json'
 require 'addressable/uri'
 
 module ApiHammer
+  module RequestLoggerHelper
+    def log_bodies(status)
+      if @options[:log_bodies] == :on_error
+        (400..599).include?(status.to_i)
+      elsif @options.key?(:log_bodies)
+        @options[:log_bodies]
+      else
+        true
+      end
+    end
+
+    def status_s(status)
+      status_color = case status.to_i
+      when 200..299
+        :intense_green
+      when 400..499
+        :intense_yellow
+      when 500..599
+        :intense_red
+      else
+        :white
+      end
+      bold(send(status_color, status.to_s))
+    end
+  end
+
   # Rack middleware for logging. much like Rack::CommonLogger but with a log message that isn't an unreadable 
   # mess of dashes and unlabeled numbers. 
   #
@@ -14,12 +40,14 @@ module ApiHammer
   #   pretty, but informative.
   class RequestLogger < Rack::CommonLogger
     include Term::ANSIColor
+    include RequestLoggerHelper
 
     LARGE_BODY_SIZE = 4096
 
     # options
     # - :logger
-    # - :filter_keys
+    # - :filter_keys - array of keys to filter from logged bodies
+    # - :log_bodies - true, false, :on_error
     def initialize(app, logger, options={})
       @options = options
       super(app, logger)
@@ -59,25 +87,13 @@ module ApiHammer
       request = Rack::Request.new(env)
       response = Rack::Response.new('', status, response_headers)
 
-      status_color = case status.to_i
-      when 200..299
-        :intense_green
-      when 400..499
-        :intense_yellow
-      when 500..599
-        :intense_red
-      else
-        :white
-      end
-      status_s = bold(send(status_color, status.to_s))
-
       request_headers = env.map do |(key, value)|
         http_match = key.match(/\AHTTP_/)
         if http_match
           name = http_match.post_match.downcase
           {name => value}
         else
-          name = %w(content_type content_length).detect { |name| name.downcase == key.downcase }
+          name = %w(content_type content_length).detect { |sname| sname.downcase == key.downcase }
           if name
             {name => value}
           end
@@ -101,7 +117,7 @@ module ApiHammer
         'response' => {
           'status' => status.to_s,
           'headers' => response_headers,
-          'length' => response_headers['Content-Length'] || response_body.to_enum.map(&::Rack::Utils.method(:bytesize)).inject(0, &:+),
+          'length' => response_headers['Content-Length'] || response_body.to_enum.map(&:bytesize).inject(0, &:+),
         }.reject { |k,v| v.nil? },
         'processing' => {
           'began_at' => began_at.utc.to_f,
@@ -111,27 +127,29 @@ module ApiHammer
       }
       response_body_string = response_body.to_enum.to_a.join('')
       body_info = [['request', request_body, request.content_type], ['response', response_body_string, response.content_type]]
-      body_info.map do |(role, body, content_type)|
-        parsed_body = ApiHammer::Body.new(body, content_type)
-        content_type_attrs = ApiHammer::ContentTypeAttrs.new(content_type)
-        if content_type_attrs.text?
-          if (400..599).include?(status.to_i) || body.size < LARGE_BODY_SIZE
-            # log bodies if they are not large, or if there was an error (either client or server) 
-            data[role]['body'] = parsed_body.filtered(@options.reject { |k,v| ![:filter_keys].include?(k) }).jsonifiable.body
-          else
-            # otherwise, log id and uuid fields 
-            body_object = parsed_body.object
-            sep = /(?:\b|\W|_)/
-            hash_ids = proc do |hash|
-              hash.reject { |key, value| !(key =~ /#{sep}([ug]u)?id#{sep}/ && value.is_a?(String)) }
-            end
-            if body_object.is_a?(Hash)
-              body_ids = hash_ids.call(body_object)
-            elsif body_object.is_a?(Array) && body_object.all? { |e| e.is_a?(Hash) }
-              body_ids = body_object.map(&hash_ids)
-            end
+      if log_bodies(status)
+        body_info.map do |(role, body, content_type)|
+          parsed_body = ApiHammer::Body.new(body, content_type)
+          content_type_attrs = ApiHammer::ContentTypeAttrs.new(content_type)
+          if content_type_attrs.text?
+            if (400..599).include?(status.to_i) || body.size < LARGE_BODY_SIZE
+              # log bodies if they are not large, or if there was an error (either client or server) 
+              data[role]['body'] = parsed_body.filtered(@options.reject { |k,v| ![:filter_keys].include?(k) }).jsonifiable.body
+            else
+              # otherwise, log id and uuid fields 
+              body_object = parsed_body.object
+              sep = /(?:\b|\W|_)/
+              hash_ids = proc do |hash|
+                hash.reject { |key, value| !(key =~ /#{sep}([ug]u)?id#{sep}/ && value.is_a?(String)) }
+              end
+              if body_object.is_a?(Hash)
+                body_ids = hash_ids.call(body_object)
+              elsif body_object.is_a?(Array) && body_object.all? { |e| e.is_a?(Hash) }
+                body_ids = body_object.map(&hash_ids)
+              end
 
-            data[role]['body_ids'] = body_ids if body_ids && body_ids.any?
+              data[role]['body_ids'] = body_ids if body_ids && body_ids.any?
+            end
           end
         end
       end
@@ -139,7 +157,7 @@ module ApiHammer
       json_data = JSON.dump(data)
       dolog = proc do
         now_s = now.strftime('%Y-%m-%d %H:%M:%S %Z')
-        @logger.info "#{bold(intense_cyan('<'))} #{status_s} : #{bold(intense_cyan(request.request_method))} #{intense_cyan(request_uri.normalize)} @ #{intense_cyan(now_s)}"
+        @logger.info "#{bold(intense_cyan('<'))} #{status_s(status)} : #{bold(intense_cyan(request.request_method))} #{intense_cyan(request_uri.normalize)} @ #{intense_cyan(now_s)}"
         @logger.info json_data
       end
       # do the logging with tags that applied to the request if appropriate 

data/lib/api_hammer/trailing_newline.rb

@@ -30,7 +30,7 @@ module ApiHammer
       if env['REQUEST_METHOD'].downcase != 'head' && ApiHammer::ContentTypeAttrs.new(content_type).text?
         body = TNLBodyProxy.new(body){}
         if headers["Content-Length"]
-          headers["Content-Length"] = body.map(&Rack::Utils.method(:bytesize)).inject(0, &:+).to_s
+          headers["Content-Length"] = body.map(&:bytesize).inject(0, &:+).to_s
         end
       end
       [status, headers, body]

data/lib/api_hammer/version.rb

@@ -1,3 +1,3 @@
 module ApiHammer
-  VERSION = "0.13.3"
+  VERSION = "0.14.0"
 end

data/lib/api_hammer.rb

@@ -2,6 +2,12 @@ proc { |p| $:.unshift(p) unless $:.any? { |lp| File.expand_path(lp) == p } }.cal
 
 require 'api_hammer/version'
 
+require 'i18n'
+# this weirdness is because enforce_available_locales complains when you try to use the default locale 
+# with no translations stored. usually the application will have stored translations in the locale, but, 
+# not always, so we put a dummy key in.
+I18n.backend.store_translations(I18n.locale, {__api_hammer__: ''})
+
 module ApiHammer
   autoload :Rails, 'api_hammer/rails'
   autoload :Sinatra, 'api_hammer/sinatra'

data/test/check_required_params_test.rb

@@ -40,6 +40,12 @@ describe 'ApiHammer::Rails#check_required_params' do
       assert_equal({'error_message' => 'person must be a Hash', 'errors' => {'person' => ['person must be a Hash']}}, err.body)
     end
 
+    it 'is has the wrong type for person with hash check' do
+      c = controller_with_params(:person => [])
+      err = assert_raises(ApiHammer::Rails::Halt) { c.check_required_params(:person => {:id => Fixnum}) }
+      assert_equal({'error_message' => 'person must be a Hash', 'errors' => {'person' => ['person must be a Hash']}}, err.body)
+    end
+
     it 'is missing person#name' do
       c = controller_with_params(:id => '99', :person => {:height => '3'}, :lucky_numbers => ['2'])
       err = assert_raises(ApiHammer::Rails::Halt) { c.check_required_params(checks) }

data/test/faraday_request_logger_test.rb

@@ -126,6 +126,20 @@ describe ApiHammer::RequestLogger do
     end
   end
 
+  describe 'log_bodies' do
+    it 'does not log bodies when log_bodies is false' do
+      app = proc do |env|
+        [200, {'Content-Type' => 'text/plain'}, ['data go here']]
+      end
+      conn = Faraday.new do |f|
+        f.request :api_hammer_request_logger, logger, :log_bodies => false
+        f.use Faraday::Adapter::Rack, app
+      end
+      conn.get '/'
+      assert(!logio.string.include?('data go here'))
+    end
+  end
+
   describe 'filtering' do
     describe 'json response' do
       it 'filters' do

data/test/halt_test.rb

@@ -42,7 +42,6 @@ describe 'ApiHammer::Rails#halt' do
       assert_equal record, FakeController.new.find_or_halt(model, {:id => 'anid'})
     end
     it 'it halts with 404 if not' do
-      record = Object.new
       model = Class.new do
         (class << self; self; end).class_eval do
           define_method(:where) { |attrs| [] }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: api_hammer
 version: !ruby/object:Gem::Version
-  version: 0.13.3
+  version: 0.14.0
 platform: ruby
 authors:
 - Ethan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-05 00:00:00.000000000 Z
+date: 2016-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -95,13 +95,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: i18n
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -109,7 +109,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rack-test
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -123,7 +123,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rack-test
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -137,7 +137,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest-reporters
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -151,7 +151,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: minitest-reporters
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -165,7 +165,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -179,7 +179,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -193,7 +193,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: activerecord
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -234,16 +234,12 @@ files:
 - .yardopts
 - CHANGELOG.md
 - Gemfile
-- Gemfile_ar_3
-- Gemfile_ar_40
-- Gemfile_ar_41
 - LICENSE.txt
 - README.md
 - Rakefile.rb
 - api_hammer.gemspec
 - bin/hc
 - lib/api_hammer.rb
-- lib/api_hammer/active_record_cache_find_by.rb
 - lib/api_hammer/body.rb
 - lib/api_hammer/content_type_attrs.rb
 - lib/api_hammer/faraday/outputter.rb
@@ -275,7 +271,6 @@ files:
 - lib/logstash/filters/request_bodies_parsed.rb
 - lib/logstash/filters/ruby_logger.rb
 - lib/logstash/filters/sidekiq.rb
-- test/active_record_cache_find_by_test.rb
 - test/check_required_params_test.rb
 - test/faraday_request_logger_test.rb
 - test/halt_test.rb
@@ -310,7 +305,6 @@ 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/faraday_request_logger_test.rb
 - test/halt_test.rb

data/Gemfile_ar_3

@@ -1,8 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec
-
-gem 'byebug'
-gem 'wwtd'
-
-gem 'activerecord', '~> 3.0'

data/Gemfile_ar_40

@@ -1,8 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec
-
-gem 'byebug'
-gem 'wwtd'
-
-gem 'activerecord', '~> 4.0.0'

data/Gemfile_ar_41

@@ -1,8 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec
-
-gem 'byebug'
-gem 'wwtd'
-
-gem 'activerecord', '~> 4.1.0'

data/lib/api_hammer/active_record_cache_find_by.rb

@@ -1,134 +0,0 @@
-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.to_s == where_value.left.name.to_s }
-          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.to_s }.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
-        # if this looks weird, it kind of is. on the first invocation of #finder_cache, we call finder_cache= 
-        # which overwrites the finder_cache method, and this then calls the newly defined method. 
-        self.finder_cache = (Object.const_defined?(:Rails) && ::Rails.cache) || ::ActiveSupport::Cache::MemoryStore.new
-        self.finder_cache
-      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
-
-    # 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/test/active_record_cache_find_by_test.rb

@@ -1,226 +0,0 @@
-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
-    table.column :catalog_xid, :integer
-  end
-  create_table :catalogs do |table|
-  end
-end
-
-class Album < ActiveRecord::Base
-  belongs_to :catalog, :foreign_key => :catalog_xid
-  cache_find_by(:id)
-  cache_find_by(:performer)
-  cache_find_by(:title, :performer)
-  cache_find_by(:tracks)
-  cache_find_by(:catalog_xid, :title)
-end
-
-class Catalog < ActiveRecord::Base
-  has_many :albums, :foreign_key => :catalog_xid
-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)
-    Catalog.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('caches with two attributes on an association with a where') do
-    c = Catalog.create!
-    Album.create!(:title => 'x', :performer => 'y', :catalog_xid => c.id)
-    c = Catalog.first
-    assert_caches("cache_find_by/albums/catalog_xid/#{c.id}/title/x") { assert c.albums.where(:title => 'x').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
-
-  it 'works with a symbol on the left' do
-    # this makes an association with :catalog_xid as the left side of a where_value. these are usually 
-    # strings. this just makes sure it doesn't error out. 
-    c = Catalog.create!
-    c = Catalog.first
-    c.albums.where(:title => 'y').first
-  end
-end