battle_ship 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6c1a6e6b2bbce4d90f39d7a4d50b9064eb2c25a8
-  data.tar.gz: 201bfa26abb91dbfcd900ba21483ef289ab86a70
+  metadata.gz: 122cf236b5148bbed85ef814efd2eb4552908255
+  data.tar.gz: 6bf5d9c28887a6e988f704d7eb24cefb79218759
 SHA512:
-  metadata.gz: eb495f4cfce3a23eed57d2a06836a3c100a6548b00c066f1fcf7d578fa581dff4d882d90cef1dc02cec4d334f24bed05e5cd175b17403556f209e615f65b0290
-  data.tar.gz: bf4cd384fbb12a719bd81fcbf44865424e5e458528dca3a04c54e61ec3d3cd34e99b370426a1e64b3c8df98840b39b9b71eda28ab9e0277b7710c0a1d1bbe8ed
+  metadata.gz: b701f36e44d2596fefc64eb6eb1708e97332acf88884d2a35f8f459c8ec32021b3b293da842446b2dc508e450acb31b6a90f5c54288a24f632ec4359ef9cdbc0
+  data.tar.gz: ffb5758795a6451dd628195284c720f87561dc31b92e90b0df08da1cb16f2b043b50d3282a0d11282f5440523599369677255e81f8542745afcbec062adc2244

data/README.md

@@ -8,18 +8,15 @@ curious what your success is with your caching strategies. Perhaps you cache
 some user objects, sessions, etc. How do you know whether it's working? What if
 it's mostly misses?
 
-BattleShip provides an api that wraps Rails.cache methods. It takes a namespace
-by which it will aggregate data on your cache hits and misses.
+BattleShip updates ActiveSupport::Cache::Store (and all its subclasses, so
+you're covered if you use RedisStore or MemcachedStore) to increment a counter
+for each cache hit and miss
 
 #### Warnings, Caveats, etc.
-Battleship is a gem that expects there to be a class called __Rails__ with a .cache
-method. This .cache method must implement the following:
-  - fetch
-  - read
-  - write
-  - increment
+BattleShip works by updating ActiveSupport::Cache::Store, so requires this class
+to exist.
 
-This cache must also be able to complete _atomic increment_ operations with the #increment method
+This cache must also be able to complete _atomic increment_ operations with the #increment method.
 
 This is early development days for BattleShip. Please feel free to open an issue
 here with either questions or suggestions. And, of course, contributions are
@@ -41,24 +38,20 @@ Or install it yourself as:
 
 ## Usage
 
-Instead of calling Rails.cache, call BattleShip. Instead of passing a key, pass
-in both a namespace (e.g., sessions or users) and a unique id (e.g. auth_token
-or user.id).
-
-After adding to your Gemfile, use BattleShip where you would previously have
-used Rails.cache.
-* Caching User objects? Call ```BattleShip.write("user", user.id, user)``` for a
-  given user object
-* This will store the user object just as if you had called ```Rails.cache.write("user_#{user.id}", user)```
-* The benefit comes when you call read: ```BattleShip.read("user", 1)```
-* If you have a value cached, BattleShip will increment the key at "user_hit" by
-  1 (hence the need for atomic increment operations)
-* If there is no value found, BattleShip will increment the key at "user_miss"
-
-At any time, you can access the current number of hits and misses by calling
-BattleShip.hits(:namespace) and BattleShip.misses(:namespace), where :namespace
-is any given namespace you have used (e.g. 'user', as above). This can be passed
-as a symbol or string.
+Just keep on using Rails.cache methods like you do today. BattleShip makes
+certain assumptions that you should be aware of:
+* When there's a cache hit, it will increment the value of the returned object's
+  class name plus the string "\_hits" (e.g. a User object's hits will be stored
+in the cache at key ```"User_hits"```)
+* When there's a cache miss, BattleShip doesn't know exactly the class you were
+  expecting, so it assumes that you either: (1) Passed in a namespace key in
+the options hash, or (2) Named your key such that the first underscore occurs
+after the name of the class (e.g. "User_123").
+* Access the hits by calling ```#hits``` on your particular cache implementation (e.g.
+  ```Rails.cache.hits```) and passing in the namespace, e.g. User (either the string
+or the classname).
+* Same deal with misses, but call ```#misses``` instead
+
 
 ## Contributing
 
@@ -70,5 +63,7 @@ as a symbol or string.
 
 ## To Do
 
-1. Add config method with any necessary config
-2. Create specs specifically using redis-store and memcache-store, document here
+1. Add performance measurements
+2. Add rails example app
+3. Add config option for turning on/off
+4. Add config option for setting time-frame of hits/misses

data/battle_ship.gemspec

@@ -8,9 +8,9 @@ Gem::Specification.new do |spec|
   spec.version       = BattleShip::VERSION
   spec.authors       = ["DavidRagone"]
   spec.email         = ["dmragone@gmail.com"]
-  spec.description   = %q{Wrapper class for Rails.cache related methods to track cache hits & misses}
+  spec.description   = %q{Adds counters to cache when successful read operation completes in order to track Rails.cache hits & misses}
   spec.summary       = %q{Wrapper for Rails.cache methods}
-  spec.homepage      = "http://www.dmragone.com"
+  spec.homepage      = "https://github.com/DavidRagone/BattleShip"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
@@ -21,4 +21,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
+  spec.add_development_dependency "activesupport"
+
+  spec.add_runtime_dependency "activesupport"
 end

data/lib/active_support/cache/store.rb

@@ -0,0 +1,9 @@
+module ActiveSupport
+  module Cache
+    class Store
+      def self.inherited(subclass)
+        subclass.class_eval("prepend BattleShip")
+      end
+    end
+  end
+end

data/lib/battle_ship/version.rb

@@ -1,3 +1,3 @@
 module BattleShip
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/battle_ship.rb

@@ -1,6 +1,32 @@
 module BattleShip
+  def hits(key)
+    read(key.to_s.camelize << '_hits', skip_increment: true)
+  end
+
+  def misses(key)
+    read(key.to_s.camelize << '_misses', skip_increment: true)
+  end
+
+  def read_entry(key, options) # :nodoc:
+    entry = super(key, options)
+    return entry if options[:skip_increment]
+    if entry
+      increment("#{entry.value.class}_hits")
+    else
+      increment("#{namespace(key, options)}_misses")
+    end
+    entry
+  end
+
+  private
+  def namespace(key, options)
+    (options[:namespace] || key_up_to_first_underscore(key)).camelize
+  end
+
+  def key_up_to_first_underscore(key)
+    key[0..(key.index('_') -1)]
+  end
 end
 
 require "battle_ship/version"
-require "battle_ship/core"
-require "battle_ship/pass_through"
+require "active_support/cache/store"

data/spec/lib/active_support_cache_subclass_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+class User
+  def initialize(options)
+    @name = options[:name]
+    @age  = options[:age]
+  end
+end
+
+class ActiveSupport::Cache::Something < ActiveSupport::Cache::Store
+  protected
+  def read_entry(key, options)
+    @value
+  end
+
+  def write_entry(key, entry, options)
+    @value = entry
+  end
+end
+
+describe ActiveSupport::Cache::Something do
+  let(:cache) { ActiveSupport::Cache::Something.new }
+  let(:user) { User.new(name: 'Bob', age: 'old') }
+
+  context ".read" do
+    it "increments the related counter on hits" do
+      cache.should_receive(:increment).with("User_hits")
+      cache.write("user_1", user)
+      cache.read("user_1").should eq user
+    end
+
+    it "increments the related counter on misses" do
+      cache.should_receive(:increment).with("User_misses")
+      cache.read("user_1").should eq nil
+    end
+  end
+end
+

data/spec/lib/battle_ship_spec.rb

@@ -1,280 +1,47 @@
 require 'spec_helper'
 
-class Rails
-  def self.cache
-    Cache
-  end
-end
-class Cache
-  def self.read(k)
-  end
-  def self.increment(k,a=1,o=nil)
-  end
-  def self.fetch(k,o=nil)
-    if block_given?
-      yield
-    end
-  end
-end
-
+# For tests of #read_entry, see spec/lib/active_support_cache_subclass_spec.rb
 describe BattleShip do
-  describe ".read" do
-    shared_examples_for :read do
-      it "retrieves value from Rails.cache.read" do
-        Cache.should_receive(:read).with("namespace_#{uniqueid}")
-        BattleShip.read(:namespace, uniqueid)
-      end
+  let(:dummy) { Class.new { prepend(BattleShip) }.new }
 
-      it "returns value from Rails.cache.read" do
-        Cache.stub(:read) { 'a value' }
-        BattleShip.read(:foo, :bar).should eq 'a value'
-      end
-
-      it "increments namespace hit counter when value is non-nil" do
-        Cache.stub(:read) { 'a value' }
-        Cache.should_receive(:increment).with('foo_hit', 1, nil)
-        BattleShip.read(:foo, :bar)
-      end
-
-      it "increments namespace miss counter when value is nil" do
-        Cache.stub(:read) { nil }
-        Cache.should_receive(:increment).with('foo_miss', 1, nil)
-        BattleShip.read(:foo, :bar)
-      end
-    end
-
-    context 'when uniqueid is a symbol' do
-      let(:uniqueid) { :foo }
-      it_behaves_like :read
-    end
-
-    context 'when uniqueid is a string' do
-      let(:uniqueid) { 'foo' }
-      it_behaves_like :read
-    end
-
-    context 'when uniqueid is a number' do
-      let(:uniqueid) { 4 }
-      it_behaves_like :read
+  describe "#hits" do
+    it "reads, skipping increment" do
+      dummy.should_receive(:read).with("Foo_hits", { skip_increment: true })
+      dummy.hits("Foo")
     end
   end
 
-  describe ".write" do
-    shared_examples_for :write do
-      it "writes value to Rails.cache.write using given key" do
-        Cache.should_receive(:write).with("namespace_#{uniqueid}", value, nil)
-        BattleShip.write(:namespace, uniqueid, value)
-      end
-    end
-
-    context 'when uniqueid is a symbol' do
-      let(:uniqueid) { :foo }
-      let(:value) { :bar }
-      it_behaves_like :write
-    end
-
-    context 'when uniqueid is a string' do
-      let(:uniqueid) { 'foo' }
-      let(:value) { 'bar' }
-      it_behaves_like :write
-    end
-
-    context 'when uniqueid is a number' do
-      let(:uniqueid) { 4 }
-      let(:value) { 5 }
-      it_behaves_like :write
+  describe "#misses" do
+    it "reads, skipping increment" do
+      dummy.should_receive(:read).with("Foo_misses", { skip_increment: true })
+      dummy.misses("Foo")
     end
   end
 
-  describe ".fetch" do
-    shared_examples_for :fetch do
-      it "retrieves value from Rails.cache.fetch" do
-        Cache.should_receive(:fetch)
-        subject
-      end
-
-      it "returns value from Rails.cache.fetch" do
-        Cache.stub(:fetch) { 'a value' }
-        subject.should eq 'a value'
-      end
-
-      it "increments namespace hit counter when value is non-nil" do
-        Cache.stub(:fetch) { 'a value' }
-        Cache.stub(:read) { 'a value' }
-        Cache.should_receive(:increment).with('foo_hit', 1, nil)
-        subject
-      end
-
-      it "increments namespace miss counter when value is nil" do
-        Cache.stub(:fetch) { nil }
-        Cache.should_receive(:increment).with('foo_miss', 1, nil)
-        subject
+  describe "private methods" do
+    describe "#namespace" do
+      subject { dummy.send(:namespace, key, options) }
+      context "when options includes namespace" do
+        let(:key) { 'Key' }
+        let(:options) { { namespace: 'NameSpace' } }
+        it "returns the option's namespace" do
+          subject.should eq 'NameSpace'
+        end
       end
-    end
-    context "when block given" do
-      subject { described_class.fetch(:foo, :bar) { 'a different value' } }
-      it_behaves_like :fetch
 
-      context "when value absent" do
-        it "should set the value" do
-          subject
-          subject.should eq 'a different value'
+      context "when options does not include namespace" do
+        let(:key) { 'Key_Thing_123' }
+        let(:options) { { } }
+        it "returns the string preceding the first underscore" do
+          subject.should eq 'Key'
         end
       end
     end
 
-    context "when block absent" do
-      subject { described_class.fetch(:foo, :bar) }
-      it_behaves_like :fetch
-    end
-  end
-
-  describe ".cleanup" do
-    let(:options) { { } }
-    it "passes to underlying" do
-      Cache.should_receive(:cleanup).with(options)
-      BattleShip.cleanup(options)
-    end
-
-    it "does not require options" do
-      Cache.should_receive(:cleanup).with(nil)
-      BattleShip.cleanup
-    end
-  end
-
-  describe ".clear" do
-    let(:options) { { } }
-    it "passes to underlying" do
-      Cache.should_receive(:clear).with(options)
-      BattleShip.clear(options)
-    end
-
-    it "does not require options" do
-      Cache.should_receive(:clear).with(nil)
-      BattleShip.clear
-    end
-  end
-
-  describe ".decrement" do
-    let(:options) { { } }
-    let(:namespace) { 'name' }
-    let(:uid) { '1' }
-    let(:amount) { 2 }
-    it "passes to underlying" do
-      Cache.should_receive(:decrement).with('name_1', amount, options)
-      BattleShip.decrement(namespace, uid, amount, options)
-    end
-
-    it "defaults amount to 1" do
-      Cache.should_receive(:decrement).with('name_1', 3, options)
-      BattleShip.decrement(namespace, uid, 3, options)
-    end
-
-    it "does not require options" do
-      Cache.should_receive(:decrement).with('name_1', 1, nil)
-      BattleShip.decrement(namespace, uid)
-    end
-  end
-
-  describe ".delete" do
-    let(:namespace) { 'name' }
-    let(:uid) { 1 }
-    let(:options) { { } }
-    it "passes to underlying" do
-      Cache.should_receive(:delete).with('name_1', options)
-      BattleShip.delete(namespace, uid, options)
-    end
-
-    it "does not require options" do
-      Cache.should_receive(:delete).with('name_1', nil)
-      BattleShip.delete(namespace, uid)
-    end
-  end
-
-  describe ".delete_matched" do
-    let(:matcher) { 'something*' }
-    let(:options) { { } }
-    it "passes to underlying" do
-      Cache.should_receive(:delete_matched).with(matcher, options)
-      BattleShip.delete_matched(matcher, options)
-    end
-
-    it "does not require options" do
-      Cache.should_receive(:delete_matched).with(matcher, nil)
-      BattleShip.delete_matched(matcher)
-    end
-  end
-
-  describe ".exist?" do
-    let(:namespace) { 'name' }
-    let(:uid) { 1 }
-    let(:options) { { } }
-    it "passes to underlying" do
-      Cache.should_receive(:exist?).with('name_1', options)
-      BattleShip.exist?(namespace, uid, options)
-    end
-
-    it "does not require options" do
-      Cache.should_receive(:exist?).with('name_1', nil)
-      BattleShip.exist?(namespace, uid)
-    end
-  end
-
-  describe ".increment" do
-    let(:options) { { } }
-    let(:namespace) { 'name' }
-    let(:uid) { '1' }
-    let(:amount) { 2 }
-    it "passes to underlying" do
-      Cache.should_receive(:increment).with('name_1', amount, options)
-      BattleShip.increment(namespace, uid, amount, options)
-    end
-
-    it "defaults amount to 1" do
-      Cache.should_receive(:increment).with('name_1', 3, options)
-      BattleShip.increment(namespace, uid, 3, options)
-    end
-
-    it "does not require options" do
-      Cache.should_receive(:increment).with('name_1', 1, nil)
-      BattleShip.increment(namespace, uid)
-    end
-  end
-
-  describe ".hits" do
-    it "returns the hits" do
-      Cache.should_receive(:read).with("foo_hit") { 4 }
-      BattleShip.hits(:foo).should eq 4
-    end
-  end
-
-  describe ".misses" do
-    it "returns the hits" do
-      Cache.should_receive(:read).with("foo_miss") { 4 }
-      BattleShip.misses(:foo).should eq 4
-    end
-  end
-
-  describe ".mute" do
-    it "passes to underlying" do
-      Cache.should_receive(:mute)
-      BattleShip.mute
-    end
-  end
-
-  describe ".read_multi" do
-    # *names - options is last
-    let(:names) { ['1', '2', '3'] }
-    it "passes to underlying" do
-      Cache.should_receive(:read_multi).with(names)
-      BattleShip.read_multi(names)
-    end
-  end
-
-  describe ".silence!" do
-    it "passes to underlying" do
-      Cache.should_receive(:silence!)
-      BattleShip.silence!
+    describe "#key_up_to_first_underscore" do
+      it "returns the string up to the first underscore" do
+        dummy.send(:key_up_to_first_underscore, 'someclass_thing').should eq 'someclass'
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,4 @@
+require 'active_support'
 require 'battle_ship'
 
 RSpec.configure do |config|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: battle_ship
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - DavidRagone
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-24 00:00:00.000000000 Z
+date: 2013-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,7 +52,36 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Wrapper class for Rails.cache related methods to track cache hits & misses
+- !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: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Adds counters to cache when successful read operation completes in order
+  to track Rails.cache hits & misses
 email:
 - dmragone@gmail.com
 executables: []
@@ -65,13 +94,13 @@ files:
 - README.md
 - Rakefile
 - battle_ship.gemspec
+- lib/active_support/cache/store.rb
 - lib/battle_ship.rb
-- lib/battle_ship/core.rb
-- lib/battle_ship/pass_through.rb
 - lib/battle_ship/version.rb
+- spec/lib/active_support_cache_subclass_spec.rb
 - spec/lib/battle_ship_spec.rb
 - spec/spec_helper.rb
-homepage: http://www.dmragone.com
+homepage: https://github.com/DavidRagone/BattleShip
 licenses:
 - MIT
 metadata: {}
@@ -96,5 +125,6 @@ signing_key:
 specification_version: 4
 summary: Wrapper for Rails.cache methods
 test_files:
+- spec/lib/active_support_cache_subclass_spec.rb
 - spec/lib/battle_ship_spec.rb
 - spec/spec_helper.rb

data/lib/battle_ship/core.rb

@@ -1,62 +0,0 @@
-module BattleShip
-  class << self
-    def read(namespace, uid)
-      value = cache.read(namespaced(namespace, uid))
-      increment_hit_or_miss(namespace, value)
-      value
-    end
-
-    def write(namespace, uid, value, options = nil)
-      cache.write(namespaced(namespace, uid), value, options)
-    end
-
-    def fetch(namespace, uid, options = nil)
-      # http://mudge.name/2011/01/26/passing-blocks-in-ruby-without-block.html
-      namespaced = namespaced(namespace, uid)
-      increment_hit_or_miss(namespace, cache.read(namespaced))
-      if block_given?
-        cache.fetch(namespaced, options, &Proc.new)
-      else
-        cache.fetch(namespaced, options)
-      end
-    end
-
-    def decrement(namespace, uid, amount = 1, options = nil)
-      cache.decrement(namespaced(namespace, uid), amount, options)
-    end
-
-    def delete(namespace, uid, options = nil)
-      cache.delete(namespaced(namespace, uid), options)
-    end
-
-    def exist?(namespace, uid, options = nil)
-      cache.exist?(namespaced(namespace, uid), options)
-    end
-
-    def increment(namespace, uid, amount = 1, options = nil)
-      cache.increment(namespaced(namespace, uid), amount, options)
-    end
-
-    def hits(namespace)
-      cache.read("#{namespace}_hit")
-    end
-
-    def misses(namespace)
-      cache.read("#{namespace}_miss")
-    end
-
-    private
-    def increment_hit_or_miss(namespace, value, amount = 1, options = nil)
-      hit_or_miss = value.nil? ? '_miss' : '_hit'
-      cache.increment(namespace.to_s << hit_or_miss, amount, options)
-    end
-
-    def namespaced(namespace, uid)
-      namespace.to_s << '_' << uid.to_s
-    end
-
-    def cache
-      Rails.cache
-    end
-  end
-end

data/lib/battle_ship/pass_through.rb

@@ -1,27 +0,0 @@
-module BattleShip
-  class << self
-    def cleanup(options = nil)
-      cache.cleanup(options)
-    end
-
-    def clear(options = nil)
-      cache.clear(options)
-    end
-
-    def delete_matched(matcher, options = nil)
-      cache.delete_matched(matcher, options)
-    end
-
-    def mute
-      cache.mute
-    end
-
-    def read_multi(*names)
-      cache.read_multi(*names)
-    end
-
-    def silence!
-      cache.silence!
-    end
-  end
-end