counter_cachier 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in counter_cachier.gemspec
+gemspec

data/README.md

@@ -0,0 +1,40 @@
+counter-cachier
+===============
+
+usage
+-------------
+
+counter cachier is a generic counter caching solution (using redis) for stuff where ActiveRecord's counter cache just does not cut it. i.e. when the counter is on a complex association, etc.
+
+usage is pretty simple, simply include CounterCachier in the class you wish to use it on, and define counter cachiers:
+
+```ruby
+class User
+  include CounterCachier
+
+  counter_cachier :approved_posts_count do |user|
+    user.posts.approved.count
+  end
+end
+```
+
+the block's argument is the object you're making the calculations for (i.e. an instance of User), the value returned in the block will be the new counter. From this moment, two new methods are added to User - approved_posts_count and recalc_approved_posts_count.
+
+```ruby
+user = User.first
+user.approved_posts_count #=> 10
+#...user adds an approved post...
+user.recalc_approved_posts_count #=> 11, but it actually recalculates and pushes the number into redis.
+```
+
+installation
+-------------
+
+in your gemfile
+gem "counter_cachier"
+
+in an initializer:
+```ruby
+CounterCachier.redis = Redis.new(redis_configuration)
+```
+you can skip this if you've got the $redis global.

data/counter_cachier.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/counter_cachier/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Tom Caspy"]
+  gem.email         = ["tcaspy@gmail.com"]
+  gem.description   = %q{Counter cache on steroids - requires a bit of configuration, but then simply saves counter data.}
+  gem.summary       = %q{simply set the counter's name and write a block for recalculation of that cache, and you're done}
+  gem.homepage      = "https://github.com/unorthodoxgeek/counter-cachier"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "counter_cachier"
+  gem.require_paths = ["lib"]
+  gem.version       = CounterCachier::VERSION
+  
+  gem.add_development_dependency(%q<rspec>, [">= 0"])
+  gem.add_development_dependency(%q<rake>, ["~> 0.9.2"])
+  gem.add_dependency(%q<redis>, [">= 0"])
+end

data/lib/counter_cachier/cachier.rb

@@ -0,0 +1,20 @@
+module CounterCachier
+  class Cachier
+    attr_accessor :name
+
+    def initialize(name, &block)
+      @name = name
+      @block = block
+    end
+
+    def recalc(object)
+      @block.call(object)
+    end
+
+    def write(object)
+      new_value = recalc(object)
+      CounterCachier.write(object, name, new_value)
+      new_value
+    end
+  end
+end

data/lib/counter_cachier/counter_cachier.rb

@@ -0,0 +1,45 @@
+module CounterCachier
+  class << self
+
+    def redis=(r)
+      @redis = r
+    end
+
+    def redis
+      @redis ||= $redis
+    end
+
+    def key(object, name)
+      "counter_cachier::#{object.class.to_s}::#{object.id}::#{name}"
+    end
+
+    def read(object, cachier)
+      value = redis.get(key(object, cachier.name))
+      if value.nil?
+        value = cachier.write(object)
+      end
+      value
+    end
+
+    def write(object, name, value)
+      redis.set key(object, name), value
+    end
+  end
+
+  def self.included(base)
+    base.extend ClassMethods
+    class << base
+      attr_accessor :cachiers
+    end
+  end
+
+  module ClassMethods
+    def counter_cachier(name, options = {}, &block)
+      self.cachiers ||= {}
+      self.cachiers[name] = Mounter.new(self, name, &block)
+      if options[:async]
+        later "recalc_#{name}", queue: options[:queue] || :long
+      end
+    end
+  end
+end

data/lib/counter_cachier/mounter.rb

@@ -0,0 +1,27 @@
+module CounterCachier
+  class Mounter
+
+    attr_accessor :cachier
+
+    def initialize(klass, name, &block)
+      @klass = klass
+      @name = name
+      self.cachier = CounterCachier::Cachier.new(name, &block)
+      define_methods
+    end
+
+    def define_methods
+      #these local variables are set so they can be used inside the define_method blocks
+      name = @name
+      cachier = @cachier
+
+      @klass.send :define_method, @name do
+        CounterCachier.read(self, name)
+      end
+
+      @klass.send :define_method, "recalc_#{@name}" do
+        cachier.write(self)
+      end
+    end
+  end
+end

data/lib/counter_cachier/version.rb

@@ -0,0 +1,3 @@
+module CounterCachier
+  VERSION = "0.0.1"
+end

data/lib/counter_cachier.rb

@@ -0,0 +1,4 @@
+require "counter_cachier/counter_cachier"
+require "counter_cachier/cachier"
+require "counter_cachier/mounter"
+require "counter_cachier/version"

data/spec/lib/cachier_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe CounterCachier::Cachier do
+  
+  describe :cachier do
+
+    let :cachier do
+      CounterCachier::Cachier.new(:foo){ |bar| 10 * bar}
+    end
+
+    it "should save a block for recalculation" do
+      cachier.recalc(4).should == 40
+    end
+
+    it "should write the counter cache to the store" do
+      CounterCachier.should_receive(:write)
+      cachier.write(4)
+    end
+  end
+
+end

data/spec/lib/counter_cachier_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+Redis ||= Class.new
+
+describe CounterCachier do
+  let(:a){double(id: 1, class: "Foo")}
+  let(:b){double(id: 2, class: "Bar")}
+  let(:cachier){double(name: "foo")}
+
+  before :each do
+    CounterCachier.redis = double
+  end
+  
+  describe :write do
+    it "should write the new counter cache" do
+      CounterCachier.redis.should_receive(:set)
+      CounterCachier.write(a, :b, 4)
+    end
+  end
+
+  describe :read do
+    it "should read the counter cache" do
+      CounterCachier.redis.should_receive(:get).and_return(1)
+      CounterCachier.read(a, cachier)
+    end
+
+    it "should recalc the counter cache if the read yields nil" do
+      CounterCachier.redis.should_receive(:get)
+      cachier.should_receive(:write).and_return(5)
+      CounterCachier.read(a, cachier).should == 5
+    end
+  end
+
+  describe :key do
+    it "should return a string" do
+      CounterCachier.key(a, :a).should be_a String
+    end
+
+    it "should return a valid unique key for each object" do
+      CounterCachier.key(a, :a).should_not == CounterCachier.key(b, :a)
+    end
+  end
+
+end

data/spec/lib/mounter_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+class Dummy
+  include CounterCachier
+  def id
+    4
+  end
+
+  def baz
+    10
+  end
+
+  counter_cachier :foo do |foo|
+    foo.baz
+  end
+end
+
+describe CounterCachier::Mounter do
+  let(:dummy) {Dummy.new}
+  describe "class methods" do
+    it "should have cachiers accessor" do
+      Dummy.should respond_to :cachiers
+    end
+
+    it "should call later if later specified" do
+      Dummy.should_receive(:later).with("recalc_bar", queue: :bar)
+
+      Dummy.counter_cachier :bar, async: true, queue: :bar do
+        10
+      end
+    end
+  end
+
+  describe "instance methods" do
+    it "should respond to foo" do
+      dummy.should respond_to(:foo)
+    end
+
+    it "should respond to recalc_foo" do
+      dummy.should respond_to(:recalc_foo)
+    end
+
+    it "should run the block when calling recalc_foo" do
+      CounterCachier.redis.should_receive :set
+      dummy.recalc_foo.should == 10
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require "counter_cachier"
+
+  RSpec.configure do |config|
+    # config.mock_with :mocha
+    # config.mock_with :flexmock
+    # config.mock_with :rr
+    config.mock_with :rspec
+  end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: counter_cachier
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Tom Caspy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+- !ruby/object:Gem::Dependency
+  name: rake
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+    none: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+    none: false
+- !ruby/object:Gem::Dependency
+  name: redis
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+description: Counter cache on steroids - requires a bit of configuration, but then
+  simply saves counter data.
+email:
+- tcaspy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- counter_cachier.gemspec
+- lib/counter_cachier.rb
+- lib/counter_cachier/cachier.rb
+- lib/counter_cachier/counter_cachier.rb
+- lib/counter_cachier/mounter.rb
+- lib/counter_cachier/version.rb
+- spec/lib/cachier_spec.rb
+- spec/lib/counter_cachier_spec.rb
+- spec/lib/mounter_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/unorthodoxgeek/counter-cachier
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: simply set the counter's name and write a block for recalculation of that
+  cache, and you're done
+test_files:
+- spec/lib/cachier_spec.rb
+- spec/lib/counter_cachier_spec.rb
+- spec/lib/mounter_spec.rb
+- spec/spec_helper.rb