event-counter 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0bd855f0622ba4699ac98ae5f11d635fff270bbc
-  data.tar.gz: 996454629b26cf7eb0ce21338f5a5c443fd79713
+  metadata.gz: a5e4803060e3164a0eaf04624b6d5002c0789dd4
+  data.tar.gz: 58e249fde274f8d405e6d9d872fbdef6ca799a87
 SHA512:
-  metadata.gz: 16a2277eeb66b50ca1110700ab4fc40497714b5fd928599e4310da1055ff62e38b44a4db6cd004f447bea28169219bb628f1a32c43265bd8e74f404a20a423f3
-  data.tar.gz: c67d8bcab89dcf2bdfd2f99b466e439269af57e13647c7fd13f93594efe4a19e1d49d4845e0d591080b5c31e0b4230e5c1f3e4ae0bdd6d8f20af31df2a5bb882
+  metadata.gz: 9002dad388634f8afd70f9c8f57591e32eb1e8ed0ac859daee6b15609e2699c3cc90ee1103e5c15f2a3aa2430a02df6a00bea150f11f21b34e52022e71266120
+  data.tar.gz: e321c6a69d69f52b1b1b7b53c65fa14865723ed46e037a8ad3e3b4b4ebbf0017577c0d627f1c69d82d403753886dd0a254454ca31c94740196a7789265f6d81d

data/.travis.yml

@@ -9,7 +9,7 @@ gemfile:
   - gemfiles/pg_ar_32.gemfile
   - gemfiles/pg_ar_40.gemfile
 
-script: RUN_ALL=true bundle exec rspec spec
+script: bundle exec rspec spec
 
 services:
   - postgresql

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # EventCounter Changelog
 
+0.3.0 (2014-11-08)
+
+* counter definition method name changed
+
+0.2.0 (2014-11-05)
+
+* Improved timezones support
+
 0.1.1 (2014-10-22)
 
 * Fixed issue with creating time in time zone

data/README.md

@@ -127,7 +127,7 @@ Article.data_for(:views, interval: :day, range: range)
 Add gem to Gemfile
 
 ```ruby
-gem 'event_counter'
+gem 'event-counter'
 ```
 
 Create migration `rails g migration create_event_counters` with the

data/gemfiles/pg_ar_30.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    event-counter (0.1.0)
+    event-counter (0.3.0)
       activerecord (>= 3)
       activesupport (>= 3)
       pg (~> 0)

data/gemfiles/pg_ar_31.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    event-counter (0.1.0)
+    event-counter (0.3.0)
       activerecord (>= 3)
       activesupport (>= 3)
       pg (~> 0)

data/gemfiles/pg_ar_32.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    event-counter (0.1.0)
+    event-counter (0.3.0)
       activerecord (>= 3)
       activesupport (>= 3)
       pg (~> 0)

data/gemfiles/pg_ar_40.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    event-counter (0.1.0)
+    event-counter (0.3.0)
       activerecord (>= 3)
       activesupport (>= 3)
       pg (~> 0)

data/gemfiles/pg_ar_41.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    event-counter (0.1.0)
+    event-counter (0.3.0)
       activerecord (>= 3)
       activesupport (>= 3)
       pg (~> 0)

data/lib/event_counter.rb

@@ -31,20 +31,20 @@ class EventCounter < ActiveRecord::Base
 
     attrs = { created_at: on_time }
 
-    if force && (found = scoped_relatiion.where(attrs).first)
+    if force && (found = scoped_relation.where(attrs).first)
       found.reset_value(val)
     else
       attrs.merge!(value: val)
-      scoped_relatiion.create!(attrs)
+      scoped_relation.create!(attrs)
     end
   end
 
   def self.current_interval
-    scoped_relatiion.proxy_association.owner.event_counters[counter_name]
+    scoped_relation.proxy_association.owner.event_counters[counter_name]
   end
 
   def self.counter_name
-    scoped_relatiion.proxy_association.reflection.name
+    scoped_relation.proxy_association.reflection.name
   end
 
   def self.change(val = 1, vector: :up, on_time: nil, force: nil)
@@ -71,7 +71,7 @@ class EventCounter < ActiveRecord::Base
     end
   end
 
-  def self.scoped_relatiion
+  def self.scoped_relation
     ActiveRecord::VERSION::MAJOR > 3 ? where(nil) : scoped
   end
 

data/lib/event_counter/active_record_extension.rb

@@ -10,7 +10,7 @@ class EventCounter < ActiveRecord::Base
 
     # :nodoc:
     module ClassMethods
-      def event_counter_for(name, interval)
+      def has_counter(name, interval)
         event_counters[name] = interval
 
         clause = { name: name.to_s }
@@ -68,16 +68,16 @@ class EventCounter < ActiveRecord::Base
         day: 1.day
       }.freeze
 
-      def data_for(name, id = nil, interval: nil, range: nil, raw: nil, tz: nil)
+      def data_for(name, id = nil, interval: nil, range: nil, raw: nil)
         interval = normalize_interval!(name, interval)
 
         range = normalize_range!(range, interval) if range
 
-        tz ||= (Time.zone || 'UTC')
-        tz_abbr = tz.now.zone
+        tz = Time.zone.tzinfo.identifier
+        tz_storage = (default_timezone == :utc ? 'UTC' : Time.now.zone)
 
         subq = EventCounter
-          .select(subq_select(interval, tz_abbr))
+          .select(subq_select(interval, tz))
           .where(name: name, countable_type: self)
           .where(id && { countable_id: id })
           .within(range)
@@ -85,16 +85,16 @@ class EventCounter < ActiveRecord::Base
           .order("1")
           .to_sql
 
-        sql = <<-SQL.squish!
+        q = <<-SQL.squish!
           SELECT created_at, value
-          FROM (#{series(interval, range, tz_abbr)}) intervals
+          FROM (#{series(interval, tz, range)}) intervals
           LEFT OUTER JOIN (#{subq}) counters USING (created_at)
           ORDER BY 1
         SQL
 
-        result = connection.execute(sql).to_a
+        result = connection.execute(q).to_a
 
-        raw ? result : normalize_counters_data(result, tz)
+        raw ? result : normalize_counters_data!(result)
       end
 
       def subq_select(interval, tz)
@@ -104,69 +104,107 @@ class EventCounter < ActiveRecord::Base
       def subq_extract(interval, tz)
         case interval
         when Symbol
-          "date_trunc(#{sanitize(interval)}, #{tstamp_tz('created_at', tz)})"
+          dtrunc(interval, 'created_at', tz)
         else
-          time = <<-SQL
-            floor(EXTRACT(EPOCH FROM created_at) /
-            #{sanitize(interval)})::int * #{sanitize(interval)}
-          SQL
-          tstamp_tz("to_timestamp(#{time})", tz)
+          time = floor_tstamp('created_at', interval)
+          if default_timezone == :utc
+            "to_timestamp(#{time})"
+          else
+            at_tz("to_timestamp(#{time})::timestamp", Time.new.zone)
+          end
         end
       end
 
-      def series(interval, range, tz)
-        a =
-          case interval
-          when Symbol
-            series_for_symbol(interval, range, tz)
-          else
-            series_for_integer(interval, range, tz)
-          end
-        EventCounter.within(range).select(<<-SQL).to_sql
-          count(*), generate_series(#{a[0]}, #{a[1] }, #{a[2]}) AS created_at
+      def floor_tstamp(tstamp, interval)
+        <<-SQL
+          floor(EXTRACT(EPOCH FROM #{tstamp}) /
+          #{sanitize(interval)})::int * #{sanitize(interval)}
         SQL
       end
 
-      def series_for_symbol(interval, range, tz)
-        interval_sql = "interval '1 #{interval}'"
+      def series(*args)
+        args.first.is_a?(Symbol) ? series_symbol(*args) : series_integer(*args)
+      end
+
+      def series_symbol(interval, tz, range = nil)
         if range
-          a = [
-            dtrunc(interval, sanitize(range.min).to_s, tz),
-            dtrunc(interval, sanitize(range.max).to_s, tz),
-            interval_sql
-          ]
+          series_symbol_with_range(interval, tz, range)
         else
-          a = [
-            dtrunc(interval, 'min(created_at)', tz),
-            dtrunc(interval, 'max(created_at)', tz),
-            interval_sql
-          ]
+          series_symbol_without_range(interval, tz)
         end
       end
 
-      def series_for_integer(interval, range, tz)
-        interval_sql = %Q(#{sanitize(interval)} * interval '1 seconds')
+      def series_symbol_with_range(interval, tz, range)
+        range_min, range_max = range.min, range.max
+        a = [
+          dtrunc(interval, sanitize(range_min.to_s(:db)), tz),
+          dtrunc(interval, sanitize(range_max.to_s(:db)), tz),
+          interval_symbol(interval)
+        ]
+
+        "SELECT generate_series(#{a[0]}, #{a[1]}, #{a[2]}) AS created_at"
+      end
+
+      def series_symbol_without_range(interval, tz)
+        a = [
+          dtrunc(interval, 'min(created_at)', tz),
+          dtrunc(interval, 'max(created_at)', tz),
+          interval_symbol(interval)
+        ]
+        EventCounter.select(<<-SQL).to_sql
+          generate_series(#{a[0]}, #{a[1]}, #{a[2]}) AS created_at
+        SQL
+      end
+
+      def series_integer(interval, tz, range = nil)
         if range
+          series_integer_with_range(interval, tz, range)
+        else
+          series_integer_without_range(interval, tz)
+        end
+      end
+
+      def series_integer_with_range(interval, tz, range = nil)
+        interval_sql = %Q(#{sanitize(interval)} * interval '1 seconds')
+        range_min, range_max = range.min.to_s(:db), range.max.to_s(:db)
+
+        a = [ sanitize(range_min), sanitize(range_max), interval_sql ]
+        <<-SQL
+          SELECT generate_series(#{a[0]}, #{a[1]}, #{a[2]}) AS created_at
+        SQL
+      end
+
+      def series_integer_without_range(interval, tz)
+        interval_sql = sanitize(interval)
+        if default_timezone == :utc
           a = [
-            tstamp_tz("to_timestamp(#{sanitize(range.min.to_i)})", tz),
-            tstamp_tz("to_timestamp(#{sanitize(range.max.to_i)})", tz),
+            floor_tstamp('min(created_at)', interval),
+            floor_tstamp('max(created_at)', interval),
             interval_sql
           ]
         else
+          z = Time.new.zone
           a = [
-            tstamp_tz('min(created_at)', tz),
-            tstamp_tz('max(created_at)', tz),
+            floor_tstamp(at_tz('min(created_at)', z), interval),
+            floor_tstamp(at_tz('max(created_at)', z), interval),
             interval_sql
           ]
         end
+        EventCounter.select(<<-SQL).to_sql
+          to_timestamp(generate_series(#{a[0]}, #{a[1]}, #{a[2]})) AS created_at
+        SQL
+      end
+
+      def interval_symbol(interval)
+        "interval #{sanitize(interval).insert(1, '1 ')}"
       end
 
-      def dtrunc(interval, value, tz)
-        "date_trunc(#{sanitize(interval)}, #{tstamp_tz(value, tz)})"
+      def dtrunc(interval, str, tz)
+        "date_trunc(#{sanitize(interval)}, #{at_tz("#{str}::timestamptz", tz)})"
       end
 
-      def tstamp_tz(str, tz)
-        "#{str}::timestamptz AT TIME ZONE #{sanitize(tz)}"
+      def at_tz(str, tz)
+        "#{str} AT TIME ZONE #{sanitize(tz)}"
       end
 
       def counter_error!(*args)
@@ -209,9 +247,9 @@ class EventCounter < ActiveRecord::Base
         interval.is_a?(Symbol) ? INTERVALS[interval] : interval
       end
 
-      def normalize_counters_data(data, tz)
-        Time.use_zone(tz) do
-          data.map { |i| [ Time.zone.parse(i['created_at']), i['value'].to_i ] }
+      def normalize_counters_data!(data)
+        data.map do |i|
+          [ Time.zone.parse(i['created_at']), i['value'].to_i ]
         end
       end
 

data/lib/event_counter/version.rb

@@ -1,4 +1,4 @@
 # This module contains VERSION
 module EventCounterVersion
-  VERSION = '0.1.1'
+  VERSION = '0.3.0'
 end

data/spec/lib/event_counter_spec.rb

@@ -75,311 +75,402 @@ end
 describe Ball do
   let(:ball) { Ball.create! }
 
-  it 'creates a new counter while incrementing' do
-    expect {
-      expect(ball.up!(:rotations)).to be_a(EventCounter)
-    }.to change { EventCounter.count }.by(1)
+  shared_examples 'default behavior' do
 
-    on_time = Time.zone.local(2011, 11, 11, 11, 11)
-    expect {
-      expect(ball.up!(:rotations, on_time: on_time))
-        .to be_a(EventCounter)
-    }.to change { EventCounter.count }.by(1)
+    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.zone.local(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
+      on_time = Time.zone.local(2011, 11, 11, 11, 11)
+      expect {
+        expect(ball.up!(:rotations, on_time: on_time))
+          .to be_a(EventCounter)
+      }.to change { EventCounter.count }.by(1)
 
-  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.zone.local(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
 
-    on_time = Time.zone.local(2011, 11, 11, 11, 11)
-    expect {
-      expect(ball.down!(:rotations, on_time: on_time))
-        .to be_a(EventCounter)
-    }.to change { EventCounter.count }.by(1)
+    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.zone.local(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
+      on_time = Time.zone.local(2011, 11, 11, 11, 11)
+      expect {
+        expect(ball.down!(:rotations, on_time: on_time))
+          .to be_a(EventCounter)
+      }.to change { EventCounter.count }.by(1)
 
-  it 'increments existent counter with default value' do
-    counter = ball.rotations.make
+      on_time = Time.zone.local(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
+        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)
+    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
+        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
+    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
+        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
+    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
+        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.zone.local(2012, 12, 12, 12, 12)
-    counter = ball.rotations.make on_time: on_time
+    it 'increments existent counter on time with default value' do
+      on_time = Time.zone.local(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
+        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.zone.local(2012, 12, 12, 12, 12)
-    counter = ball.rotations.make on_time: on_time
+    it 'decrements existent counter on time with default value' do
+      on_time = Time.zone.local(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
+        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.zone.local(2012, 12, 12, 12, 12)
-    counter = ball.rotations.make 2, on_time: on_time
+    it 'increments existent counter on time with specified value' do
+      on_time = Time.zone.local(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
+        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.zone.local(2012, 12, 12, 12, 12)
-    counter = ball.rotations.make 2, on_time: on_time
+    it 'decrements existent counter on time with specified value' do
+      on_time = Time.zone.local(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
+        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
+    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
+        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.zone.local(2012, 12, 12, 12, 12)
-    counter = ball.rotations.make 2, on_time: on_time
+    it 'forces existent counter on time with new value' do
+      on_time = Time.zone.local(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
+        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 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
+    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.zone.local(2014, 1, 1, 1, n)
-      if countable_count == 1
-        ball.rotations.make n, on_time: on_time
-      else
-        countable_count.times do
-          Ball.create!.rotations.make n, on_time: on_time
+    def setup_counters(countable_count = 1)
+      [1, 1, 2, 3, 5, 8, 13, 21, 34].each do |n|
+        on_time = Time.zone.local(2014, 1, 1, 1, n)
+        if countable_count == 1
+          ball.rotations.make n, on_time: on_time
+        else
+          countable_count.times do
+            Ball.create!.rotations.make n, on_time: on_time
+          end
         end
       end
     end
-  end
 
-  context '#data_for' do
+    context '.data_for' do
 
-    before { setup_counters }
+      subject { Ball }
+
+      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' do
+        data = [ [ 0, 60 ], [ 10, 39 ], [ 20, 63 ], [ 30, 102 ] ]
+
+        expect(subject.data_for(:rotations, interval: 10.minutes))
+          .to eql_data(data)
+      end
+
+      it 'with a greater interval within range' do
+        data = [ [ 10, 39 ], [ 20, 63 ] ]
+
+        range_start = Time.zone.local(2014, 1, 1, 1, 15)
+        range_end = Time.zone.local(2014, 1, 1, 1, 29)
+        range = range_start..range_end
+
+        expect(subject.data_for(:rotations, interval: 10.minutes, range: range))
+          .to eql_data(data)
+      end
+
+      it 'with a greater interval as symbol and a simple data' do
+        bmonth = Time.zone.local(2014, 1, 1).beginning_of_month
+        data = [ [ bmonth, 264 ] ]
+
+        expect(subject.data_for(:rotations, interval: :month))
+          .to match_array(data)
+      end
+
+      it 'with a greater interval as symbol and a simple data within range' do
+        bmonth = Time.zone.local(2014, 1, 1).beginning_of_month
+        data = [ [ bmonth, 264 ] ]
+
+        range_start = bmonth
+        range_end = bmonth.end_of_month
+        range = range_start..range_end
+
+        expect(subject.data_for(:rotations, interval: :month, range: range))
+          .to match_array(data)
+      end
+
+
+      it 'with a greater interval as symbol on large data set within range' 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 = (6..12).map { |x| [ Time.zone.local(2013, x), 264 ] }
+        range_start = data[0][0].beginning_of_month
+        range_end = data[-1][0].end_of_month
+        range = range_start..range_end
+
+        expect(subject.data_for(:rotations, interval: :month, range: range))
+          .to match_array(data)
+      end
 
-    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)
+    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
 
-      [:week, :month, :year].each do |interval|
-        expect { ball.data_for(:rotations_by_two_year, interval: interval) }
+      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
-    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 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 ] ]
+      it 'with a greater interval' do
+        data = [ [ 0, 33 ], [ 20, 55 ] ]
 
-      expect(ball.data_for(:rotations, interval: 20.minutes))
-        .to eql_data(data)
-    end
+        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.zone.local 2014, 1, 1, 1, 15
-      range_end =   Time.zone.local 2014, 1, 1, 1, 45
-      range = range_start.in_time_zone..range_end.in_time_zone
+      it 'with a greater interval on random (min/max) time period' do
+        EventCounter.order("created_at").limit(4).to_a.map(&:destroy)
 
-      data = [ [ 10, 13 ], [ 20, 21 ], [ 30, 34 ], [ 40, 0] ]
+        data = [ [ 0, 26 ], [ 20, 55 ] ]
 
-       expect(ball.data_for(:rotations, interval: 10.minutes, range: range))
-        .to eql_data(data)
-    end
+        expect(ball.data_for(:rotations, interval: 20.minutes))
+          .to eql_data(data)
+      end
 
-    it 'with a greater interval as symbol' do
-      beginning_of_week = Time.zone.local(2014).beginning_of_week
+      it 'with a greater interval and a time range' do
+        range_start = Time.zone.local 2014, 1, 1, 1, 15
+        range_end =   Time.zone.local 2014, 1, 1, 1, 45
+        range = range_start.in_time_zone..range_end.in_time_zone
 
-      data = [ [ beginning_of_week, 88 ] ]
+        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.zone.local(2014).beginning_of_week
+
+        data = [ [ beginning_of_week, 88 ] ]
+
+        expect(ball.data_for(:rotations, interval: :week))
+          .to eql(data)
+      end
 
-       expect(ball.data_for(:rotations, interval: :week))
-        .to eql(data)
     end
 
   end
 
-  context '.data_for' do
+  it_has 'default behavior'
 
-    subject { Ball }
+  context "with AR.default_timezone set to :local" do
+    before { ActiveRecord::Base.default_timezone = :local }
+    after  { ActiveRecord::Base.default_timezone = :utc   }
 
-    before { setup_counters(3) }
+    it_has 'default behavior'
+  end
 
-    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
+  context "with different timezone" do
+    before { Time.zone = 'Pacific Time (US & Canada)' }
+    after  { Time.zone = 'Moscow'                     }
 
-    it 'with a greater interval' do
-      data = [ [ 0, 60 ], [ 10, 39 ], [ 20, 63 ], [ 30, 102 ] ]
+    it_has 'default behavior'
+  end
 
-      expect(subject.data_for(:rotations, interval: 10.minutes))
-        .to eql_data(data)
+  context "with AR.default_timezone set to :local and different timezone" do
+    before do
+      ActiveRecord::Base.default_timezone = :local
+      Time.zone = 'Pacific Time (US & Canada)'
+    end
+    after do
+      Time.zone = 'Moscow'
+      ActiveRecord::Base.default_timezone = :utc
     end
 
-    it 'with a greater interval within range' do
-      data = [ [ 10, 39 ], [ 20, 63 ] ]
+    it_has 'default behavior'
+  end
 
-      range_start = Time.zone.local(2014, 1, 1, 1, 15)
-      range_end = Time.zone.local(2014, 1, 1, 1, 29)
-      range = range_start..range_end
+  context 'in timezone with DST' do
 
-      expect(subject.data_for(:rotations, interval: 10.minutes, range: range))
-        .to eql_data(data)
-    end
+    it 'starts PST -> PDT (+1 hour), offset after UTC-7h' do
+      Time.zone = 'UTC'
 
-    it 'with a greater interval as symbol and a simple data' do
-      bmonth = Time.zone.local(2014, 1, 1).beginning_of_month
-      data = [ [ bmonth, 264 ] ]
+      # DST for US/Pacific in UTC
+      dst_before = Time.zone.local(2014, 3, 9, 9, 59)
+      dst_after  = Time.zone.local(2014, 3, 9, 10, 1)
 
-      expect(subject.data_for(:rotations, interval: :month))
-        .to match_array(data)
-    end
+      ball.rotations.make(1, on_time: dst_before)
+      ball.rotations.make(1, on_time: dst_after)
 
-    it 'with a greater interval as symbol and a simple data within range' do
-      bmonth = Time.zone.local(2014, 1, 1).beginning_of_month
-      data = [ [ bmonth, 264 ] ]
+      Time.zone = 'Pacific Time (US & Canada)'
+      data = [
+        [ Time.zone.local(2014, 3, 9, 1), 1 ],
+        [ Time.zone.local(2014, 3, 9, 3), 1 ],
+      ]
 
-      range_start = bmonth
-      range_end = bmonth.end_of_month
-      range = range_start..range_end
+      expect(ball.data_for(:rotations, interval: 1.hour)).to eql(data)
 
-      expect(subject.data_for(:rotations, interval: :month, range: range))
-        .to match_array(data)
+      range = dst_before..dst_after
+      expect(ball.data_for(:rotations, interval: 1.hour, range: range))
+        .to eql(data)
     end
 
+    it 'ends PDT -> PST (-1 hour), offset after UTC-8h' do
+      Time.zone = 'UTC'
 
-    it 'with a greater interval as symbol on large data set within range' 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
+      # DST for US/Pacific in UTC
+      dst_before = Time.zone.local(2014, 11, 2, 8, 59)
+      dst_after  = Time.zone.local(2014, 11, 2, 9, 1)
 
-      data = (6..12).map { |x| [ Time.zone.local(2013, x), 264 ] }
-      range_start = data[0][0].beginning_of_month
-      range_end = data[-1][0].end_of_month
-      range = range_start..range_end
+      ball.rotations.make(1, on_time: dst_before)
+      ball.rotations.make(1, on_time: dst_after)
 
-      expect(subject.data_for(:rotations, interval: :month, range: range))
-        .to match_array(data)
-    end
+      Time.zone = 'Pacific Time (US & Canada)'
+      data = [
+        [ Time.zone.local(2014, 11, 2, 1), 1 ],
+        [ Time.utc(2014, 11, 2, 9).in_time_zone, 1 ],
+      ]
+
+      expect(ball.data_for(:rotations, interval: 1.hour)).to eql(data)
 
+      range = dst_before..dst_after
+      expect(ball.data_for(:rotations, interval: 1.hour, range: range))
+        .to eql(data)
+    end
   end
 end

data/spec/lib/performance_spec.rb

@@ -28,7 +28,7 @@ describe Ball, slow: true do
     ball = Ball.create!
 
     (Time.zone.local(2012).to_i..Time.zone.local(2015).to_i).step(step) do |i|
-      on_time = Time.at(i)
+      on_time = Time.zone.at(i)
       ball.rotations.make on_time: on_time
     end
 
@@ -36,7 +36,6 @@ describe Ball, slow: true do
 
     skip_count = 0
 
-
     export_sql = "COPY event_counters TO STDOUT (DELIMITER '|')"
     connection.copy_data(export_sql) do
       File.open(path, 'w') do |f|

data/spec/spec_helper.rb

@@ -19,9 +19,6 @@ YAML.load(File.open(conf).read).values.each do |config|
   ActiveRecord::Base.establish_connection config
 end
 
-ActiveRecord::Base.default_timezone = :utc
-Time.zone = 'Moscow'
-
 ActiveRecord::Schema.define do
   self.verbose = false
 
@@ -35,18 +32,18 @@ ActiveRecord::Schema.define do
     t.datetime :created_at
   end
 
-  add_index :event_counters, :created_at#, name: 'idx_created_at_desc'
+  add_index :event_counters, :created_at
   add_index :event_counters, [:countable_type, :name, :countable_id],
     name: 'idx_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
+  has_counter :rotations, 5.minutes
+  has_counter :rotations_by_week, :week
+  has_counter :rotations_by_month, :month
+  has_counter :rotations_by_year, :year
+  has_counter :rotations_by_two_year, 2.years
 end
 
 Dir[File.expand_path('../support/*.rb', __FILE__)].each do |file|
@@ -56,13 +53,24 @@ end
 RSpec.configure do |config|
 
   config.before(:suite) do
-    DatabaseCleaner.strategy = :transaction
-    DatabaseCleaner.clean_with(:truncation)
+    unless ENV['DEBUG']
+      DatabaseCleaner.strategy = :transaction
+      DatabaseCleaner.clean_with(:truncation)
+    end
+    ActiveRecord::Base.default_timezone = :utc
+    ActiveRecord::Base.connection.reconnect!
+    Time.zone = 'Moscow'
   end
 
   config.around(:each) do |example|
-    DatabaseCleaner.cleaning { example.run }
+    if ENV['DEBUG']
+      example.run
+    else
+      DatabaseCleaner.cleaning { example.run }
+    end
   end
 
+  config.alias_it_should_behave_like_to :it_has, 'has:'
+
   config.filter_run_excluding slow: true unless ENV['RUN_ALL']
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: event-counter
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Anton Orel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-22 00:00:00.000000000 Z
+date: 2014-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord