event-counter 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5c824074d24fd8d6d102c55c7cd81c4026e3cdd0
+  data.tar.gz: 906bf98133f1f082d6a3f1c1d4831c64f7974ea3
+SHA512:
+  metadata.gz: 8db9c66d38029ccf99b8fa828f5936a1dc8ea84412822d7fc1037b4a2d4979988f429e4b2a96379d23e821b4ad08e792409f617b7ac1eb28f71f429341a608fc
+  data.tar.gz: a4085a8f4901cd3854b50ff56791c17bcd345d4269845e4ab5523a3bc35c65ced9bd88e6702ac2c0e2c77f8882edc73afdc5a244fa5f8a2bb927866b0f4c1678

data/.gitignore

@@ -0,0 +1,17 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/config/database.yml
+/coverage/
+/doc/
+/log
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+*.gem
+mkmf.log

data/.rubocop.yml

@@ -0,0 +1,3 @@
+Style/Blocks:
+  Exclude:
+    - 'spec/**/*'

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Anton Orel
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,120 @@
+EventCounter
+===============
+
+EventCounter is a database based event counter with throttling per time intervals.
+
+Usage
+-----
+
+Let's define counters in model
+
+```ruby
+class Article < ActiveRecord::Base
+  has_counter :views, interval: 5.minutes
+
+  # :year, :month, :week and :day symbols are supported
+  has_counter :views_by_week, interval: :week
+end
+```
+
+Let's count...
+
+```ruby
+article = Article.create!
+
+article.up!(:views)
+# creates counter (if it doesn't exist) with value 1 and on Time.now() rounded to 5 minutes, e.x.:
+#=> #<EventCounter id: 1, name: "views", value: 1, countable_id: 1, countable_type: "Article", created_at: "2014-10-16 23:20:00">
+
+# at once
+article.up!(:views, 3)
+#=> #<EventCounter id: 1, name: "views", value: 4, countable_id: 1, countable_type: "Article", created_at: "2014-10-16 23:20:00">
+# it will update counter (if the other exists in that interval) with value 3 and on Time.now() rounded to 5 minutes
+
+# later
+article.up!(:views, 5)
+#=> #<EventCounter id: 2, name: "views", value: 5, countable_id: 1, countable_type: "Article", created_at: "2014-10-16 23:25:00">
+article.down!(:views, 2)
+#=> #<EventCounter id: 2, name: "views", value: 3, countable_id: 1, countable_type: "Article", created_at: "2014-10-16 23:25:00">
+
+# anytime or in a background job
+article.up!(:views, 7, on_time: 10.minutes.ago)
+#=> #<EventCounter id: 3, name: "views", value: 7, countable_id: 1, countable_type: "Article", created_at: "2014-10-16 23:15:00">
+
+# we have not got? let's fix it
+article.up!(:views, 9, on_time: 10.minutes.ago, force: true)
+#=> #<EventCounter id: 3, name: "views", value: 9, countable_id: 1, countable_type: "Article", created_at: "2014-10-16 23:15:00">
+```
+
+Let's get some statistics for our charts...
+
+```ruby
+article.data_for(:views)
+#=> [[2014-10-16 23:15:00 +0400, 9], [2014-10-16 23:20:00 +0400, 4], [2014-10-16 23:25:00 +0400, 3]]
+
+article.data_for(:views, interval: 10.minutes)
+#=> [[2014-10-16 23:10:00 +0400, 9], [2014-10-16 23:20:00 +0400, 7]]
+
+range = Time.mktime(2014, 10, 16, 23, 0)..Time.mktime(2014, 10, 16, 23, 10)
+article.data_for(:views, interval: 10.minutes, range: range)
+#=> [[2014-10-16 23:00:00 +0400, 0], [2014-10-16 23:10:00 +0400, 9]]
+
+article.data_for(:views, interval: :day)
+#=> [[2014-10-16 00:00:00 +0400, 16]]
+
+article.data_for(:views, interval: :day, raw: true)
+#=> [{"created_at" => "2014-10-16 00:00:00+04", "value" => "16"}]
+# raw result will make difference in performance on a big data
+
+# class wide
+range = Time.mktime(2014, 10, 15)..Time.mktime(2014, 10, 16)
+Article.data_for(:views, interval: :day, range: range)
+#=> [[2014-10-15 00:00:00 +0400, 0], [2014-10-16 00:00:00 +0400, 16]]
+```
+
+Limitations
+-----------
+
+  - It works *ONLY* with *PostgreSQL* at the moment.
+  - ActiveRecord 3+
+  - It's polymorphic association.
+  - Use it in production with caution because it's early release.
+
+
+Installation
+--------------
+
+Add gem to Gemfile
+
+```ruby
+gem 'event_counter'
+```
+
+Create migration `rails g migration create_event_counters` with the
+following code:
+
+```ruby
+class CreateEventCounters < ActiveRecord::Migration
+
+  def change
+    create_table :event_counters, force: true do |t|
+      t.string :name, null: false
+      t.integer :value, default: 0, null: false
+      t.references :countable, polymorphic: true, null: false
+
+      t.datetime :created_at
+    end
+
+    add_index :event_counters, :countable_type
+    add_index :event_counters,
+      [:countable_type, :name, :countable_id], name: 'complex_index'
+
+  end
+
+end
+```
+
+License
+----
+
+MIT

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/config/database.ci.yml

@@ -0,0 +1,5 @@
+postgresql:
+  adapter: postgresql
+  database: event_counter_test
+  username: postgres
+  min_messages: WARNING

data/event-counter.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'event_counter/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'event-counter'
+  spec.version       = EventCounterVersion::VERSION
+  spec.authors       = ['Anton Orel']
+  spec.email         = ['eagle.anton@gmail.com']
+  spec.summary       = 'Event counter with throttling per time interval'
+  spec.description   = 'Database based event counter with throttling per time intervals'
+  spec.homepage      = 'https://github.com/skyeagle/event-counter'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activerecord', '~> 3'
+  spec.add_dependency 'pg', '~> 0'
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'database_cleaner', '~> 0'
+  spec.add_development_dependency 'rspec', '~> 3'
+  spec.add_development_dependency 'fabrication', '~> 0'
+  spec.add_development_dependency 'rake', '~> 10.0'
+end

data/lib/event-counter.rb

@@ -0,0 +1 @@
+require 'event_counter'

data/lib/event_counter/active_record_extension.rb

@@ -0,0 +1,224 @@
+class EventCounter < ActiveRecord::Base
+  # This module adds functionality to ActiveRecord
+  module ActiveRecordExtension
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :event_counters
+      self.event_counters = {}
+    end
+
+    # :nodoc:
+    module ClassMethods
+      def event_counter_for(name, interval)
+        event_counters[name] = interval
+
+        clause = { name: name.to_s }
+
+        if ActiveRecord::VERSION::MAJOR > 3
+          has_many name,
+            -> { where(clause) }, as: :countable, class_name: 'EventCounter'
+        else
+          has_many name,
+            conditions: clause, as: :countable, class_name: 'EventCounter'
+        end
+        include CountableInstanceMethods
+        extend  CountableClassMethods
+      end
+    end
+
+    # This module defines instance methods for a countable model
+    module CountableInstanceMethods
+
+      def up!(*args)
+        opts = args.extract_options!
+        opts.merge!(vector: :up)
+        rotate_counter(*args, opts)
+      end
+
+      def down!(*args)
+        opts = args.extract_options!
+        opts.merge!(vector: :down)
+        rotate_counter(*args, opts)
+      end
+
+      def data_for(name, interval: nil, range: nil, raw: false)
+        self.class.data_for(name, id, interval: interval, range: range, raw: raw)
+      end
+
+      private
+
+      def rotate_counter(*args)
+        opts = args.extract_options!
+        name, val = args
+        unless respond_to?(name)
+          self.class.counter_error!(:not_found, name: name)
+        end
+        send(name).change(val, opts)
+      end
+    end
+
+    # This module defines class methods for a countable model
+    module CountableClassMethods
+
+      INTERVALS = {
+        year: 1.year,
+        month: 1.month,
+        week: 1.week,
+        day: 1.day
+      }.freeze
+
+      def data_for(counter_name, id = nil, interval: nil, range: nil, raw: false)
+        interval = normalize_interval!(counter_name, interval)
+
+        sql = <<SQL.squish!
+#{cte_definition(counter_name, interval, id)}
+SELECT
+  created_at,
+  COALESCE(sum(value) OVER (PARTITION BY counters.created_at) , 0) AS value
+FROM (#{series_definition(interval, range)}) intervals
+LEFT JOIN CTE counters USING (created_at)
+ORDER BY 1
+SQL
+
+        result = connection.execute(sql).to_a
+
+        raw ? result : normalize_counters_data(result)
+      end
+
+      def cte_definition(counter_name, interval, id = nil)
+<<SQL
+WITH CTE AS (
+  SELECT #{cte_extract(interval)} as created_at, sum(value) AS value
+  FROM event_counters
+  WHERE
+    countable_type = #{sanitize(name)} AND
+    #{ "countable_id = #{sanitize(id)} AND" if id.present? }
+    name = #{sanitize(counter_name)}
+  GROUP BY 1
+)
+SQL
+      end
+
+      def cte_extract(interval)
+        case interval
+        when Symbol
+          "date_trunc(#{sanitize(interval)}, created_at)"
+        else
+          tstamp(<<SQL)
+floor(EXTRACT(EPOCH FROM created_at::timestamp with time zone) /
+#{sanitize(interval)})::int * #{sanitize(interval)}
+SQL
+        end
+      end
+
+      def series_definition(interval, range)
+        range_min, range_max = min_and_max_of_range(interval, range)
+
+        args =
+          case interval
+          when Symbol
+            interval_sql = "interval '1 #{interval}'"
+            if range
+              [
+                "date_trunc(#{sanitize(interval)}, #{tstamp(range.min.to_i)} )",
+                "date_trunc(#{sanitize(interval)}, #{tstamp(range.max.to_i)} )",
+                interval_sql
+              ]
+            else
+              [
+                "date_trunc(#{sanitize(interval)}, min(created_at))",
+                "date_trunc(#{sanitize(interval)}, max(created_at))",
+                interval_sql
+              ]
+            end
+          else
+            interval_sql = %Q(#{sanitize(interval)} * interval '1 seconds')
+            if range
+              [
+                tstamp(sanitize(range_min)),
+                tstamp(sanitize(range_max)),
+                interval_sql
+              ]
+            else
+              [ 'min(created_at)', 'max(created_at)', interval_sql ]
+            end
+          end
+        <<SQL
+SELECT
+  count(*), generate_series(#{args[0]}, #{args[1] }, #{args[2]}) AS created_at
+FROM CTE
+SQL
+      end
+
+      def tstamp(val)
+        "to_timestamp(#{val})"
+      end
+
+      def counter_error!(*args)
+        fail EventCounter::CounterError, args
+      end
+
+      def normalize_interval!(counter_name, interval)
+        default_interval = default_interval_for(counter_name)
+
+        h = {
+          default_interval: default_interval,
+          interval: interval,
+          model: self.class.name
+        }
+
+        return default_interval.to_i unless interval
+
+        counter_error!(:not_found, name: name) unless default_interval
+        counter_error!(:less, h) if less_then_default?(default_interval, interval)
+        unless multiple_of_default?(default_interval, interval)
+          counter_error!(:multiple, h)
+        end
+
+        interval.respond_to?(:to_i) ? interval.to_i : interval
+      end
+
+      def less_then_default?(*args)
+        default, provided = args.map do |arg|
+          interval_as_integer(arg)
+        end
+        provided < default
+      end
+
+      def multiple_of_default?(default_interval, provided)
+        return true if provided.is_a?(Symbol)
+        provided.modulo(default_interval).zero?
+      end
+
+      def interval_as_integer(interval)
+        interval.is_a?(Symbol) ? INTERVALS[interval] : interval
+      end
+
+      def normalize_counters_data(raw_data)
+        raw_data.map  do |i|
+          [ Time.parse(i['created_at']), i['value'].to_i ]
+        end
+      end
+
+      def default_interval_for(counter_name)
+        event_counters[counter_name.to_sym]
+      end
+
+      def min_and_max_of_range(interval, range)
+        return unless range
+
+        case interval
+        when Symbol
+          [
+            range.min.send(:"beginning_of_#{interval}").to_i,
+            range.max.send(:"end_of_#{interval}").to_i
+          ]
+        else
+          [ range.min.floor(interval).to_i, range.max.floor(interval).to_i ]
+        end
+      end
+    end
+  end
+
+end

data/lib/event_counter/version.rb

@@ -0,0 +1,4 @@
+# This module contains VERSION
+module EventCounterVersion
+  VERSION = '0.0.1'
+end

data/lib/event_counter.rb

@@ -0,0 +1,148 @@
+require 'event_counter/version'
+
+# This class defines model that stores all counters.
+class EventCounter < ActiveRecord::Base
+  include EventCounterVersion
+
+  belongs_to :countable, polymorphic: true
+
+  def increase_by(val)
+    self.class.where(id: id).update_all(['value = value + ?', val])
+    increment(:value, val)
+    self
+  end
+
+  def decrease_by(decrement)
+    self.class.where(id: id).update_all(['value = value - ?', decrement])
+    decrement(:value, decrement)
+    self
+  end
+
+  def reset_value(val = 0)
+    self.class.where(id: id).update_all(['value = ?', val])
+    self.value = val
+    self
+  end
+
+  def self.make(val = 1, on_time: nil, force: false)
+    on_time = normalize_on_time(on_time)
+
+    attrs = { created_at: on_time }
+
+    if force && (found = scoped_relatiion.where(attrs).first)
+      found.reset_value(val)
+    else
+      attrs.merge!(value: val)
+      scoped_relatiion.create!(attrs)
+    end
+  end
+
+  def self.current_interval
+    scoped_relatiion.proxy_association.owner.event_counters[counter_name]
+  end
+
+  def self.counter_name
+    scoped_relatiion.proxy_association.reflection.name
+  end
+
+  def self.change(val = 1, vector: :up, on_time: nil, force: nil)
+    counter_error!(:direction) unless [:up, :down].include?(vector)
+
+    val ||= 1
+
+    on_time = normalize_on_time(on_time)
+
+    counter = where(created_at: on_time).first
+
+    return counter.update!(vector, val, force) if counter
+
+    val = -val if vector == :down
+    make(val, on_time: on_time, force: force)
+  end
+
+  def update!(vector, val = 1, force = false)
+    if force
+      val = -val if vector == :down
+      reset_value(val)
+    else
+      vector == :up ? increase_by(val) : decrease_by(val)
+    end
+  end
+
+  def self.scoped_relatiion
+    ActiveRecord::VERSION::MAJOR > 3 ? where(nil) : scoped
+  end
+
+  def self.up!(*args)
+    change(:up, *args)
+  end
+
+  def self.down!(*args)
+    change(:down, *args)
+  end
+
+  def self.counter_error!(*args)
+    fail CounterError, args
+  end
+
+  def self.normalize_on_time(on_time)
+    on_time ||= Time.now
+    on_time =
+      case current_interval
+      when Symbol
+        on_time.send(:"beginning_of_#{current_interval}")
+      else
+        on_time.floor(current_interval)
+      end
+    on_time
+  end
+
+  # Default error class
+  class CounterError < StandardError
+    MESSAGES = {
+      not_found: 'Unable to find counter (%{name}).',
+      direction: 'Wrong direction for counter.' \
+                 'Possible values are :up and :down as symbols.',
+      less: 'Specified interval (%{interval}) could not be less then ' \
+            'a defined (%{default_interval}) in a countable model (%{model}).',
+      multiple: 'Specified interval (%{interval}) should be a multiple of ' \
+                'a defined (%{default_interval}) in a countable model (%{model}).'
+    }
+
+    attr_accessor :extra
+
+    def initialize(*args)
+      @msg, self.extra = args.flatten!
+      super(@msg)
+    end
+
+    def to_s
+      @msg.is_a?(Symbol) ? MESSAGES[@msg] % extra : super
+    end
+  end
+end
+
+require 'event_counter/active_record_extension'
+
+ActiveRecord::Base.send(:include, EventCounter::ActiveRecordExtension)
+
+# :nodoc:
+class Time
+  def floor(seconds = 60)
+    Time.at((to_f / seconds).floor * seconds)
+  end
+end
+
+class String
+
+  unless method_defined?(:squish!)
+    # Stolen from Rails
+    def squish!
+      gsub!(/\A[[:space:]]+/, '')
+      gsub!(/[[:space:]]+\z/, '')
+      gsub!(/[[:space:]]+/, ' ')
+      self
+    end
+  end
+
+end

data/spec/lib/event_counter_spec.rb

@@ -0,0 +1,346 @@
+require 'spec_helper'
+
+describe EventCounter do
+  let(:ball) { Fabricate(:ball) }
+
+  it 'has version' do
+    expect(EventCounter::VERSION).to match(/\d+\.\d+\.\d+/)
+  end
+
+  it '#make' do
+    expect {
+      counter = ball.rotations.make(3)
+      expect(counter).to be_a(EventCounter)
+
+      expected = {
+        countable_id: ball.id,
+        countable_type: ball.class.name,
+        created_at: Time.now.floor(300),
+        name: 'rotations',
+        value: 3
+      }.with_indifferent_access
+
+      counter.attributes.except('id').keys.each do |attr|
+        expect(counter[attr]).to be_eql(expected[attr])
+      end
+    }.to change { EventCounter.count }.by(1)
+  end
+
+  it '#make on time' do
+    on_time = Time.mktime(2012, 12, 12, 12, 12)
+    expect {
+      counter = ball.rotations.make(
+        3, on_time: on_time)
+      expect(counter).to be_a(EventCounter)
+
+      expected = {
+        countable_id: ball.id,
+        countable_type: ball.class.name,
+        created_at: on_time.change(min: 10),
+        name: 'rotations',
+        value: 3
+      }.with_indifferent_access
+
+      counter.attributes.except('id').keys.each do |attr|
+        expect(counter[attr]).to be_eql(expected[attr])
+      end
+    }.to change { EventCounter.count }.by(1)
+  end
+
+  it '#make on time with interval as symbol' do
+    on_time = Time.mktime(2012, 12, 12, 12, 12)
+    [:week, :month, :year].each do |interval|
+      expect {
+        counter = ball.send(:"rotations_by_#{interval}").make(
+          3, on_time: on_time)
+        expect(counter).to be_a(EventCounter)
+
+        expected = {
+          countable_id: ball.id,
+          countable_type: ball.class.name,
+          created_at: on_time.send(:"beginning_of_#{interval}"),
+          name: "rotations_by_#{interval}",
+          value: 3
+        }.with_indifferent_access
+
+        counter.attributes.except('id').keys.each do |attr|
+          expect(counter[attr]).to be_eql(expected[attr])
+        end
+      }.to change { EventCounter.count }.by(1)
+    end
+  end
+
+end
+
+describe Ball do
+  let(:ball) { Fabricate(:ball) }
+
+  it 'creates a new counter while incrementing' do
+    expect {
+      expect(ball.up!(:rotations)).to be_a(EventCounter)
+    }.to change { EventCounter.count }.by(1)
+
+    on_time = Time.mktime(2011, 11, 11, 11, 11)
+    expect {
+      expect(ball.up!(:rotations, on_time: on_time))
+        .to be_a(EventCounter)
+    }.to change { EventCounter.count }.by(1)
+
+    on_time = Time.mktime(2012, 12, 12, 12, 12)
+    expect {
+      expect(ball.up!(:rotations, 5, on_time: on_time))
+        .to be_a(EventCounter)
+    }.to change { EventCounter.count }.by(1)
+  end
+
+  it 'creates a new counter while decrementing' do
+    expect {
+      expect(ball.down!(:rotations)).to be_a(EventCounter)
+    }.to change { EventCounter.count }.by(1)
+
+    on_time = Time.mktime(2011, 11, 11, 11, 11)
+    expect {
+      expect(ball.down!(:rotations, on_time: on_time))
+        .to be_a(EventCounter)
+    }.to change { EventCounter.count }.by(1)
+
+    on_time = Time.mktime(2012, 12, 12, 12, 12)
+    expect {
+      expect(ball.down!(:rotations, 5, on_time: on_time))
+        .to be_a(EventCounter)
+    }.to change { EventCounter.count }.by(1)
+  end
+
+  it 'increments existent counter with default value' do
+    counter = ball.rotations.make
+
+    expect {
+      expect {
+        expect(ball.up!(:rotations)).to be_a(EventCounter)
+      }.to change { counter.reload.value }.from(1).to(2)
+    }.to_not change { EventCounter.count }
+  end
+
+  it 'decrements existent counter with default value' do
+    counter = ball.rotations.make(- 1)
+
+    expect {
+      expect {
+        expect(ball.down!(:rotations)).to be_a(EventCounter)
+      }.to change { counter.reload.value }.from(-1).to(-2)
+    }.to_not change { EventCounter.count }
+  end
+
+  it 'increments existent counter by a specified value' do
+    counter = ball.rotations.make
+
+    expect {
+      expect {
+        expect(ball.up!(:rotations, 3)).to be_a(EventCounter)
+      }.to change { counter.reload.value }.from(1).to(4)
+    }.to_not change { EventCounter.count }
+  end
+
+  it 'decrements existent counter by a specified value' do
+    counter = ball.rotations.make 3
+
+    expect {
+      expect {
+        expect(ball.down!(:rotations, 5)).to be_a(EventCounter)
+      }.to change { counter.reload.value }.from(3).to(-2)
+    }.to_not change { EventCounter.count }
+  end
+
+  it 'increments existent counter on time with default value' do
+    on_time = Time.mktime(2012, 12, 12, 12, 12)
+    counter = ball.rotations.make on_time: on_time
+
+    expect {
+      expect {
+        expect(ball.up!(:rotations, on_time: on_time.change(min: 14)))
+      }.to change { counter.reload.value }.from(1).to(2)
+    }.to_not change { EventCounter.count }
+  end
+
+  it 'decrements existent counter on time with default value' do
+    on_time = Time.mktime(2012, 12, 12, 12, 12)
+    counter = ball.rotations.make on_time: on_time
+
+    expect {
+      expect {
+        expect(ball.down!(:rotations, on_time: on_time.change(min: 14)))
+      }.to change { counter.reload.value }.from(1).to(0)
+    }.to_not change { EventCounter.count }
+  end
+
+  it 'increments existent counter on time with specified value' do
+    on_time = Time.mktime(2012, 12, 12, 12, 12)
+    counter = ball.rotations.make 2, on_time: on_time
+
+    expect {
+      expect {
+        expect(ball.up!(:rotations, 3, on_time: on_time.change(min: 14)))
+      }.to change { counter.reload.value }.from(2).to(5)
+    }.to_not change { EventCounter.count }
+  end
+
+  it 'decrements existent counter on time with specified value' do
+    on_time = Time.mktime(2012, 12, 12, 12, 12)
+    counter = ball.rotations.make 2, on_time: on_time
+
+    expect {
+      expect {
+        expect(ball.down!(:rotations, 3, on_time: on_time.change(min: 14)))
+      }.to change { counter.reload.value }.from(2).to(-1)
+    }.to_not change { EventCounter.count }
+  end
+
+  it 'forces existent counter with new value' do
+    counter = ball.rotations.make
+
+    expect {
+      expect {
+        expect(ball.rotations.make(5, force: true))
+          .to be_a(EventCounter)
+      }.to change { counter.reload.value }.from(1).to(5)
+    }.to_not change { EventCounter.count }
+  end
+
+  it 'forces existent counter on time with new value' do
+    on_time = Time.mktime(2012, 12, 12, 12, 12)
+    counter = ball.rotations.make 2, on_time: on_time
+
+    expect {
+      expect {
+        expect(ball.rotations.make(5, force: true, on_time: on_time))
+          .to be_a(EventCounter)
+      }.to change { counter.reload.value }.from(2).to(5)
+    }.to_not change { EventCounter.count }
+  end
+
+  it 'raises error on wrong direction foc counter' do
+    expect { ball.send(:rotate_counter, *[:rotations, vector: :wrong_direction]) }
+      .to raise_error(EventCounter::CounterError, /wrong direction/i)
+  end
+
+  it 'raises error on unable to find counter' do
+    expect { ball.up!(:unknown) }
+      .to raise_error(EventCounter::CounterError, /unable to find/i)
+  end
+
+  def setup_counters(countable_count = 1)
+    [1, 1, 2, 3, 5, 8, 13, 21, 34].each do |n|
+      on_time = Time.mktime(2012, 12, 12, 12, n)
+      if countable_count == 1
+        ball.rotations.make n, on_time: on_time
+      else
+        countable_count.times do
+          Fabricate(:ball).rotations.make n, on_time: on_time
+        end
+      end
+    end
+  end
+
+  context '#data_for' do
+
+    before { setup_counters }
+
+    it 'with default interval' do
+      data = [
+        # [ minute, value ]
+        [ 0, 7   ],
+        [ 5, 13  ],
+        [ 10, 13 ],
+        [ 15, 0  ],
+        [ 20, 21 ],
+        [ 25, 0  ],
+        [ 30, 34 ]
+      ]
+      expect(ball.data_for(:rotations)).to eql_data(data)
+    end
+
+    it 'with a less interval' do
+      expect { ball.data_for(:rotations, interval: 3.minutes) }
+        .to raise_error(EventCounter::CounterError, /could not be less/i)
+
+      [:week, :month, :year].each do |interval|
+        expect { ball.data_for(:rotations_by_two_year, interval: interval) }
+          .to raise_error(EventCounter::CounterError, /could not be less/i)
+      end
+    end
+
+    it 'with a interval which is not a multiple of original interval' do
+      expect { ball.data_for(:rotations, interval: 7.minutes) }
+        .to raise_error(EventCounter::CounterError, /multiple of/i)
+    end
+
+    it 'with a greater interval' do
+      data = [ [ 0, 33 ], [ 20, 55 ] ]
+
+      expect(ball.data_for(:rotations, interval: 20.minutes))
+        .to eql_data(data)
+    end
+
+    it 'with a greater interval and a time range' do
+      range_start = Time.mktime 2012, 12, 12, 12, 15
+      range_end =   Time.mktime 2012, 12, 12, 12, 45
+      range = range_start..range_end
+
+      data = [ [ 10, 13 ], [ 20, 21 ], [ 30, 34 ], [ 40, 0] ]
+
+       expect(ball.data_for(:rotations, interval: 10.minutes, range: range))
+        .to eql_data(data)
+    end
+
+    it 'with a greater interval as symbol' do
+      beginning_of_week = Time.mktime(2012, 12, 12).beginning_of_week
+
+      data = [ [ beginning_of_week, 88 ] ]
+
+       expect(ball.data_for(:rotations, interval: :week))
+        .to eql(data)
+    end
+
+  end
+
+  context '.data_for' do
+
+    before { setup_counters(3) }
+
+    it 'with a default interval' do
+      data = [
+        # [ minute, value ]
+        [ 0, 21   ],
+        [ 5, 39  ],
+        [ 10, 39 ],
+        [ 15, 0  ],
+        [ 20, 63 ],
+        [ 25, 0  ],
+        [ 30, 102 ]
+      ]
+      expect(subject.data_for(:rotations)).to eql_data(data)
+    end
+
+    it 'with a greater interval as symbol and a simple data' do
+      beginning_of_month = Time.mktime(2012, 12, 12).beginning_of_month
+      data = [ [ beginning_of_month, 264 ] ]
+      expect(subject.data_for(:rotations, interval: :month)).to eql(data)
+    end
+
+    it 'with a greater interval as symbol and a large data' do
+      EventCounter.all.each do |counter|
+        11.times do |x|
+          created_at = counter.created_at - (x + 1).months
+          EventCounter.create!(counter.attributes.except('id')) do |c|
+            c.created_at = created_at
+          end
+        end
+      end
+
+      data = (1..12).map { |x| [ Time.mktime(2012, x), 264 ] }
+
+      expect(subject.data_for(:rotations, interval: :month)).to eql(data)
+    end
+
+  end
+end

data/spec/lib/performance_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Ball, performance: true do
+
+  let(:range_start) { (Time.mktime 2011, 12).beginning_of_month }
+  let(:range_end)   { (Time.mktime 2012, 11).end_of_month }
+  let(:range)       { range_start..range_end }
+
+  before(:all) do
+    @logger = ActiveRecord::Base.logger
+    ActiveRecord::Base.logger = nil
+  end
+
+  after(:all) do
+    ActiveRecord::Base.logger = @logger
+  end
+
+  def setup_data(countable = 10, step = 1.day)
+    (1..countable).map do |x|
+      ball = Fabricate(:ball)
+
+      (range_start.to_i..range_end.to_i).step(step) do |i|
+        on_time = Time.at(i)
+        ball.rotations.make on_time: on_time
+      end
+    end
+  end
+
+  context '#data_for' do
+
+    before { setup_data }
+
+    it 'performance is adequate' do
+      data = [
+        {"created_at"=>"2011-12-01 00:00:00+04", "value"=>"310"},
+        {"created_at"=>"2012-01-01 00:00:00+04", "value"=>"310"},
+        {"created_at"=>"2012-02-01 00:00:00+04", "value"=>"290"},
+        {"created_at"=>"2012-03-01 00:00:00+04", "value"=>"310"},
+        {"created_at"=>"2012-04-01 00:00:00+04", "value"=>"300"},
+        {"created_at"=>"2012-05-01 00:00:00+04", "value"=>"310"},
+        {"created_at"=>"2012-06-01 00:00:00+04", "value"=>"300"},
+        {"created_at"=>"2012-07-01 00:00:00+04", "value"=>"310"},
+        {"created_at"=>"2012-08-01 00:00:00+04", "value"=>"310"},
+        {"created_at"=>"2012-09-01 00:00:00+04", "value"=>"300"},
+        {"created_at"=>"2012-10-01 00:00:00+04", "value"=>"310"},
+        {"created_at"=>"2012-11-01 00:00:00+04", "value"=>"300"}
+      ]
+
+      expect {
+        expect(Ball.data_for(:rotations, interval: :month, range: range, raw: true))
+          .to eql(data)
+      }.to take_less_than(0.1).seconds
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,71 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'active_record'
+require 'database_cleaner'
+require 'fabrication'
+require 'logger'
+require 'event_counter'
+
+logfile_path = File.expand_path('../../log/test.log', __FILE__)
+ActiveRecord::Base.logger = Logger.new(logfile_path)
+
+conf_local = File.expand_path('../../config/database.yml', __FILE__)
+conf_ci = File.expand_path('../../config/database.ci.yml', __FILE__)
+
+# Assume Travis CI database config if no custom one exists
+conf = File.exist?(conf_local) ? conf_local : conf_ci
+
+YAML.load(File.open(conf).read).values.each do |config|
+  ActiveRecord::Base.establish_connection config
+end
+
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :cubes, force: true
+
+  create_table :balls, force: true
+
+  create_table :event_counters, force: true do |t|
+    t.string :name, null: false
+    t.integer :value, default: 0, null: false
+    t.references :countable, polymorphic: true, null: false
+
+    t.datetime :created_at
+  end
+
+  add_index :event_counters, :countable_type
+  add_index :event_counters, [:countable_type, :name, :countable_id, :created_at],
+    name: 'composite'
+end
+
+# :nodoc:
+class Ball < ActiveRecord::Base
+  event_counter_for :rotations, 5.minutes
+  event_counter_for :rotations_by_week, :week
+  event_counter_for :rotations_by_month, :month
+  event_counter_for :rotations_by_year, :year
+  event_counter_for :rotations_by_two_year, 2.years
+end
+
+Dir[File.expand_path('../support/*.rb', __FILE__)].each do |file|
+  require file
+end
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+
+  config.filter_run_excluding performance: true
+end

data/spec/support/fabrications.rb

@@ -0,0 +1,2 @@
+Fabricator(:ball) do
+end

data/spec/support/matchers.rb

@@ -0,0 +1,31 @@
+RSpec::Matchers.define :be_eql do |expected|
+  match do |actual|
+    if expected.is_a?(Time)
+      expect(expected.strftime('%d-%m-%Y %H:%M:%S'))
+        .to eq(actual.strftime('%d-%m-%Y %H:%M:%S'))
+    else
+      expect(expected).to eql(actual)
+    end
+  end
+
+  diffable
+end
+
+RSpec::Matchers.define :eql_data do |expected|
+  match do |actual|
+    expected.map! { |a, b| [ Time.mktime(2012, 12, 12, 12, a), b ] }
+    expect(actual).to eql(expected)
+  end
+end
+
+require 'benchmark'
+
+RSpec::Matchers.define :take_less_than do |expected|
+  chain :seconds do; end
+  match do |block|
+    elapsed = Benchmark.realtime { block.call }
+    elapsed <= expected
+  end
+
+  supports_block_expectations
+end

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: event-counter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Anton Orel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: pg
+  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'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: fabrication
+  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: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Database based event counter with throttling per time intervals
+email:
+- eagle.anton@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- config/database.ci.yml
+- event-counter.gemspec
+- lib/event-counter.rb
+- lib/event_counter.rb
+- lib/event_counter/active_record_extension.rb
+- lib/event_counter/version.rb
+- spec/lib/event_counter_spec.rb
+- spec/lib/performance_spec.rb
+- spec/spec_helper.rb
+- spec/support/fabrications.rb
+- spec/support/matchers.rb
+homepage: https://github.com/skyeagle/event-counter
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: Event counter with throttling per time interval
+test_files:
+- spec/lib/event_counter_spec.rb
+- spec/lib/performance_spec.rb
+- spec/spec_helper.rb
+- spec/support/fabrications.rb
+- spec/support/matchers.rb
+has_rdoc: