multirow_counter 0.0.1

data/lib/generators/multirow_counter_generator.rb

@@ -0,0 +1,22 @@
+require 'rails/generators/active_record/migration'
+
+class MultirowCounterGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+  extend ActiveRecord::Generators::Migration
+
+  source_root File.join(File.dirname(__FILE__), 'templates')
+  argument :model_name, :type => :string
+  argument :counter_name, :type => :string
+  argument :number_of_counter_rows
+
+  def create_migration
+    migration_template 'multirow_counter_migration.rb', "db/migrate/add_#{counter_name}_counter_to_#{model_name}.rb"
+  end
+
+  def inject_code
+    inject_into_file "app/models/#{model_name}.rb", :after => '/class <%= model_name.classify %>' do
+      "multirow_counter :#{counter_name}, :rows => #{number_of_counter_rows}"
+    end
+  end
+end
+

data/lib/generators/templates/multirow_counter_migration.rb

@@ -0,0 +1,29 @@
+class Add<%= counter_name.classify %>CounterTo<%= model_name.classify %> < ActiveRecord::Migration
+
+  def self.up
+    create_table :<%= [model_name, counter_name].join('_').tableize %> do |t|
+      t.integer :id
+      t.integer :<%= model_name %>_id
+      t.integer :counter_id
+      t.integer :value
+    end
+
+    add_index :<%= [model_name, counter_name].join('_').tableize %>, :<%= model_name %>_id
+
+    # You may want to consider moving this into a background task if it takes too long
+    <%= model_name.classify %>.find_each do |<%= model_name %>|
+      1.upto(<%= number_of_counter_rows %>) do |num|
+        MultirowCounter::<%= model_name.classify %><%= counter_name.classify %>.create! do |row|
+          row.<%= model_name %>_id = <%= model_name %>.id
+          row.counter_id = num
+          row.value = 0
+        end
+      end
+    end
+  end
+
+  def self.down
+    drop_table :<%= [model_name, counter_name].join('_').tableize %>
+  end
+end
+

data/lib/multirow_counter/counter_model_creator.rb

@@ -0,0 +1,9 @@
+class CounterModelCreator < Struct.new(:counter_name, :class_name)
+  def create
+    counter_class = Class.new(ActiveRecord::Base)
+    const_name = [class_name, counter_name.classify].join
+    MultirowCounter.const_set(const_name, counter_class)
+  end
+end
+
+

data/lib/multirow_counter/extension.rb

@@ -0,0 +1,29 @@
+module MultirowCounter
+  module Extension
+    def multirow_counter(counter_name, options)
+      num_rows = options[:rows] || raise(ArgumentError, "You need to specify how many rows will be used eg. :rows => 3")
+      class_name = self.name
+
+      creator = CounterModelCreator.new(counter_name.to_s, class_name)
+      const = creator.create
+
+      # define getter method
+      getter = lambda do
+        counter_relation = const.where(class_name.foreign_key => id)
+        counter_relation.sum(:value)
+      end
+
+      define_method(counter_name, &getter)
+      define_method("multirow_counter_#{counter_name}", &getter)
+
+      # define increment method
+      define_method("increment_#{counter_name}") do
+        counter_relation = const.where(class_name.foreign_key => id)
+        randomly_selected_counter_row = rand(num_rows) + 1
+
+        counter_relation.where(:counter_id => randomly_selected_counter_row).limit(1).update_all("value = value+1")
+      end
+    end
+  end
+end
+

data/lib/multirow_counter/railtie.rb

@@ -0,0 +1,12 @@
+module MultirowCounter
+  class Railtie < Rails::Railtie
+    initializer 'multirow-counter extension' do
+      ActiveRecord::Base.extend MultirowCounter::Extension
+    end
+
+    generators do
+      require "generators/multirow_counter_generator"
+    end
+  end
+end
+

data/lib/multirow_counter.rb

@@ -0,0 +1,4 @@
+require 'multirow_counter/extension'
+require 'multirow_counter/counter_model_creator'
+require 'multirow_counter/railtie' if defined?(Rails)
+

data/test/multirow_counter_test.rb

@@ -0,0 +1,45 @@
+require 'helper'
+
+describe MultirowCounter do
+  before do
+    reset_tables
+  end
+
+  it "should respond to #version" do
+    assert @shop.respond_to?(:version)
+  end
+
+  it "should begin at 0" do
+    assert_equal 0, @shop.version
+  end
+
+  it "should allow incrementing" do
+    @shop.increment_version
+    assert_equal 1, @shop.version
+  end
+
+  it "supports many increments" do
+    10.times { @shop.increment_version }
+    assert_equal 10, @shop.version
+  end
+
+  it "should not send all increments to the same row" do
+    10.times { @shop.increment_version }
+
+    shop_versions = MultirowCounter::ShopVersion.where(:shop_id => @shop.id)
+    refute shop_versions.any? { |v| v.value == 10 }
+  end
+
+  it "requires the number of rows to be specified" do
+    class Foo < ActiveRecord::Base
+      lambda { 
+        multirow_counter :the_count, :random => 'oops'
+      }.must_raise ArgumentError
+    end
+  end
+
+  it "defines a second obscure getter" do
+    @shop.multirow_counter_version.must_equal @shop.version
+  end
+end
+

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: multirow_counter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jesse Storimer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &2158458500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2158458500
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: &2158458060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2158458060
+description: Typically SQL is not a great place to store a counter that is incremented
+  often. For instance if you're counting the number of visits to a page by incrementing
+  a SQL column and that page gets popular then there's a good chance that the SQL
+  counter will become a benchmark. This is because doing an UPDATE on the row in question
+  locks the row during the course of the UPDATE. So for many concurrent UPDATES there
+  will be lots of lock contention. This gem helps with that.
+email:
+- jesse@shopify.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/generators/multirow_counter_generator.rb
+- lib/generators/templates/multirow_counter_migration.rb
+- lib/multirow_counter/counter_model_creator.rb
+- lib/multirow_counter/extension.rb
+- lib/multirow_counter/railtie.rb
+- lib/multirow_counter.rb
+- test/multirow_counter_test.rb
+homepage: http://github.com/Shopify/multirow-counter
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Encapsulates a multi-row counter for SQL.
+test_files:
+- test/multirow_counter_test.rb