von 0.1.0 → 0.2.0

data/lib/von/counters/commands.rb

@@ -0,0 +1,41 @@
+module Von
+  module Counters
+    module Commands
+      def hget(*args)
+        Von.connection.hget(*args)
+      end
+      
+      def hgetall(*args)
+        Von.connection.hgetall(*args)
+      end
+      
+      def hincrby(*args)
+        Von.connection.hincrby(*args)
+      end      
+      
+      def hset(*args)
+        Von.connection.hset(*args)
+      end
+      
+      def lrange(*args)
+        Von.connection.lrange(*args)
+      end
+      
+      def rpush(*args)
+        Von.connection.rpush(*args)
+      end
+      
+      def llen(*args)
+        Von.connection.llen(*args)
+      end
+      
+      def lpop(*args)
+        Von.connection.lpop(*args)
+      end
+      
+      def hdel(*args)
+        Von.connection.hdel(*args)
+      end
+    end
+  end
+end

data/lib/von/counters/current.rb

@@ -0,0 +1,43 @@
+module Von
+  module Counters
+    class Current
+      include Von::Counters::Commands
+
+      # Initialize a new Counter
+      #
+      # field - counter field name
+      def initialize(field, periods = nil)
+        @field   = field.to_sym
+        @periods = periods || []
+      end
+
+      # Returns the Redis hash key used for storing counts for this Counter
+      def hash_key
+        "#{Von.config.namespace}:counters:currents:#{@field}"
+      end
+
+      def current_timestamp(time_unit)
+        hget("#{hash_key}:#{time_unit}", 'timestamp')
+      end
+
+      def increment
+        return if @periods.empty?
+
+        @periods.each do |period|
+          if period.timestamp != current_timestamp(period.time_unit)
+            hset("#{hash_key}:#{period.time_unit}", 'total', 1)
+            hset("#{hash_key}:#{period.time_unit}", 'timestamp', period.timestamp)
+          else
+            hincrby("#{hash_key}:#{period.time_unit}", 'total', 1)
+          end
+        end
+      end
+
+      def count(time_unit)
+        count = hget("#{hash_key}:#{time_unit}", 'total')
+        count.nil? ? 0 : count.to_i
+      end
+
+    end
+  end
+end

data/lib/von/counters/period.rb

@@ -0,0 +1,62 @@
+module Von
+  module Counters
+    class Period
+      include Von::Counters::Commands
+
+      def initialize(field, periods = nil)
+        @field   = field.to_sym
+        @periods = periods || []
+      end
+
+      # Returns the Redis hash key used for storing counts for this Period
+      def hash_key(time_unit)
+        "#{Von.config.namespace}:counters:#{@field}:#{time_unit}"
+      end
+
+      # Returns the Redis list key used for storing current "active" counters
+      def list_key(time_unit)
+        "#{Von.config.namespace}:lists:#{@field}:#{time_unit}"
+      end
+
+      def increment
+        return if @periods.empty?
+
+        @periods.each do |period|
+          _hash_key = hash_key(period.time_unit)
+          _list_key = list_key(period.time_unit)
+
+          hincrby(_hash_key, period.timestamp, 1)
+
+          unless lrange(_list_key, 0, -1).include?(period.timestamp)
+            rpush(_list_key, period.timestamp)
+          end
+
+          if llen(_list_key) > period.length
+            expired_counter = lpop(_list_key)
+            hdel(_hash_key, expired_counter)
+          end
+        end
+      end
+
+      # Count the fields for the given time period for this Counter.
+      #
+      # Returns an Array of Hashes representing the count
+      def count(time_unit)
+        return if @periods.empty?
+
+        counts     = []
+        this_period = nil
+        _period     = @periods.select { |p| p.time_unit == time_unit }.first
+
+        _period.length.times do |i|
+          this_period = _period.prev(i)
+          counts.unshift(this_period)
+        end
+
+        keys = hgetall(hash_key(time_unit))
+        counts.map { |date| { :timestamp => date, :count => keys.fetch(date, 0).to_i }}
+      end
+
+    end
+  end
+end

data/lib/von/counters/total.rb

@@ -0,0 +1,49 @@
+module Von
+  module Counters
+    class Total
+      include Von::Counters::Commands
+      attr_reader :field
+
+      # Initialize a new Counter
+      #
+      # field - counter field name
+      def initialize(field)
+        @field = field.to_sym
+      end
+
+      # Returns the Redis hash key used for storing counts for this Counter
+      def hash_key
+        "#{Von.config.namespace}:counters:#{@field}"
+      end
+
+      # Increment the total count for this Counter
+      # If the key has time periods specified, increment those.
+      #
+      # Returns the Integer total for the key
+      def increment
+        hincrby(hash_key, 'total', 1).to_i
+      end
+
+      # Count the "total" field for this Counter.
+      #
+      # Returns an Integer count
+      def count
+        count = hget(hash_key, 'total')
+        count.nil? ? 0 : count.to_i
+      end
+
+      # Lookup the count for this Counter in Redis.
+      # If a Period argument is given we lookup the count for
+      # all of the possible units (not expired), zeroing ones that
+      # aren't set in Redis already.
+      #
+      # period - A Period to lookup
+      #
+      # Returns an Integer representing the count or an Array of counts.
+      def self.count(field)
+        Counter.new(field).count
+      end
+
+    end
+  end
+end

data/lib/von/period.rb

@@ -1,58 +1,79 @@
 module Von
   class Period
-    AVAILABLE_PERIODS = [ :hourly, :daily, :weekly, :monthly, :yearly ]
+    PERIOD_MAPPING = {
+      :minutely => :minute,
+      :hourly   => :hour,
+      :daily    => :day,
+      :weekly   => :week,
+      :monthly  => :month,
+      :yearly   => :year
+    }
+    AVAILABLE_PERIODS    = PERIOD_MAPPING.keys
+    AVAILABLE_TIME_UNITS = PERIOD_MAPPING.values
 
-    attr_reader :counter_key
+    attr_reader :name
     attr_reader :length
     attr_reader :format
 
     # Initialize a Period object
     #
-    # counter - the field name for the counter
     # period - the time period one of AVAILABLE_PERIODS
     # length - length of period
-    def initialize(counter_key, period, length)
-      @counter_key = counter_key
-      @period      = period
-      @length      = length
-      @format      = Von.config.send(:"#{@period}_format")
+    def initialize(period, length = nil)
+      name = period.to_sym
+      if AVAILABLE_PERIODS.include?(name)
+        @name = name
+      elsif AVAILABLE_TIME_UNITS.include?(name)
+        @name = PERIOD_MAPPING.invert[name]
+      else
+        raise ArgumentError, "`#{period}' is not a valid period"
+      end
+      @length = length
+      @format = Von.config.send(:"#{@name}_format")
     end
 
     # Returns a Symbol representing the time unit
     # for the current period.
     def time_unit
-      @time_unit ||= case @period
-      when :hourly
-        :hour
-      when :daily
-        :day
-      when :weekly
-        :week
-      when :monthly
-        :month
-      when :yearly
-        :year
-      end
+      @time_unit ||= PERIOD_MAPPING[@name]
     end
 
     # Returns True or False if the period is hourly
     def hours?
-      @period == :hourly
+      @name == :hourly
+    end
+
+    # Returns True or False if the period is minutely
+    def minutes?
+      @name == :minutely
+    end
+
+    def beginning(time)
+      if minutes?
+        time.change(:seconds => 0)
+      else
+        time.send(:"beginning_of_#{time_unit}")
+      end
+    end
+
+    def prev(unit = 1)
+      beginning(unit.send(time_unit.to_sym).ago).strftime(@format)
+    end
+
+    def timestamp
+      beginning(Time.now).strftime(format)
     end
 
-    # Returns the Redis hash key used for storing counts for this Period
-    def hash_key
-      @hash ||= "#{Von.config.namespace}:counters:#{@counter_key}:#{@period}"
+    def self.unit_to_period(time_unit)
+      PERIOD_MAPPING.invert[time_unit]
     end
 
-    # Returns the Redis list key used for storing current "active" counters
-    def list_key
-      @list ||= "#{Von.config.namespace}:lists:#{@counter_key}:#{@period}"
+    def self.exists?(period)
+      AVAILABLE_PERIODS.include?(period)
     end
 
-    # Returns the Redis field representation used for storing the count value
-    def field
-      Time.now.strftime(format)
+    def self.time_unit_exists?(time_unit)
+      AVAILABLE_TIME_UNITS.include?(time_unit)
     end
   end
 end

data/lib/von/version.rb

@@ -1,3 +1,3 @@
 module Von
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/test/config_test.rb

@@ -18,24 +18,44 @@ describe Von::Config do
     @config.namespace.must_equal 'something'
   end
 
-  it 'stores counter options per key and retrieves them' do
-    options = { :monthly => 3, :total => false }
-
-    @config.counter 'bar', options
+  it "sets periods via counter method" do
+    Von.configure do |config|
+      config.counter 'bar', :monthly => 3, :daily => 6
+    end
 
-    @config.namespace.must_equal 'von'
-    @config.counter_options('bar').must_equal options
+    Von.config.periods[:bar].length.must_equal 2
+    Von.config.periods[:bar].first.name.must_equal :monthly
+    Von.config.periods[:bar].first.length.must_equal 3
+    Von.config.periods[:bar].last.name.must_equal :daily
+    Von.config.periods[:bar].last.length.must_equal 6
   end
 
-  it "allows config options to be updated via configure" do
-    options = { :monthly => 3, :total => false }
+  it "sets bests via counter method" do
+    Von.configure do |config|
+      config.counter 'bar', :best => :day
+      config.counter 'foo', :best => [ :month, :year ]
+    end
+
+    Von.config.bests[:bar].first.must_be_instance_of Von::Period
+    Von.config.bests[:bar].first.name.must_equal :daily
+    Von.config.bests[:foo].first.must_be_instance_of Von::Period
+    Von.config.bests[:foo].first.name.must_equal :monthly
+    Von.config.bests[:foo].last.must_be_instance_of Von::Period
+    Von.config.bests[:foo].last.name.must_equal :yearly
+  end
 
+  it "sets currents via counter method" do
     Von.configure do |config|
-      config.counter 'bar', options
+      config.counter 'bar', :current => :day
+      config.counter 'foo', :current => [ :month, :year ]
     end
 
-    Von.config.namespace.must_equal 'von'
-    Von.config.counter_options('bar').must_equal options
+    Von.config.currents[:bar].first.must_be_instance_of Von::Period
+    Von.config.currents[:bar].first.name.must_equal :daily
+    Von.config.currents[:foo].first.must_be_instance_of Von::Period
+    Von.config.currents[:foo].first.name.must_equal :monthly
+    Von.config.currents[:foo].last.must_be_instance_of Von::Period
+    Von.config.currents[:foo].last.name.must_equal :yearly
   end
 
 end

data/test/counter_test.rb

@@ -4,94 +4,69 @@ describe Von::Counter do
   Counter = Von::Counter
 
   before :each do
-    Timecop.freeze(Time.local(2013, 01))
+    Timecop.freeze(Time.local(2013, 01, 01, 01, 01))
     Von.config.init!
-    mock_connection!
+    @redis = Redis.new
+    @redis.flushall
   end
 
-  it "increments the total counter if given a single key" do
-    Counter.increment('foo')
-
-    @store.has_key?('von:counters:foo').must_equal true
-    @store['von:counters:foo']['total'].must_equal 1
-
-    Counter.increment('foo')
-    @store['von:counters:foo']['total'].must_equal 2
+  it "returns count for key" do
+    3.times { Von.increment('foo') }
+    Counter.new('foo').total.must_equal 3
   end
 
-  it "increments the total counter for a key and it's parent keys" do
-    Counter.increment('foo:bar')
-
-    @store.has_key?('von:counters:foo').must_equal true
-    @store['von:counters:foo']['total'].must_equal 1
-    @store.has_key?('von:counters:foo:bar').must_equal true
-    @store['von:counters:foo:bar']['total'].must_equal 1
-
-    Counter.increment('foo:bar')
-    @store['von:counters:foo']['total'].must_equal 2
-    @store['von:counters:foo:bar']['total'].must_equal 2
+  it "returns count for key and parent keys" do
+    3.times { Von.increment('foo:bar') }
+    Counter.new('foo').total.must_equal 3
+    Counter.new('foo:bar').total.must_equal 3
   end
 
-  it "increments a month counter" do
+
+  it "returns counts for a given period" do
     Von.configure do |config|
-      config.counter 'foo', :monthly => 1
+      config.counter 'foo', :monthly => 2
     end
 
-    Counter.increment('foo')
-    Counter.increment('foo')
+    Von.increment('foo')
+    Timecop.freeze(Time.local(2013, 02))
+    Von.increment('foo')
+    Timecop.freeze(Time.local(2013, 03))
+    Von.increment('foo')
 
-    @store.has_key?('von:counters:foo').must_equal true
-    @store.has_key?('von:counters:foo:monthly').must_equal true
-    @store['von:counters:foo']['total'].must_equal 2
-    @store['von:counters:foo:monthly']['2013-01'].must_equal 2
-    @store['von:lists:foo:monthly'].size.must_equal 1
+    Counter.new('foo').per(:month).must_equal [{:timestamp => "2013-02", :count => 1}, {:timestamp => "2013-03", :count => 1}]
   end
 
-  it "expires counters past the limit" do
+  it "returns best count for a given period" do
     Von.configure do |config|
-      config.counter 'foo', :monthly => 1
+      config.counter 'foo', :best => [:minute, :week]
     end
 
-    Counter.increment('foo')
-    Timecop.freeze(Time.local(2013, 02))
-    Counter.increment('foo')
-
-    @store.has_key?('von:counters:foo').must_equal true
-    @store.has_key?('von:counters:foo:monthly').must_equal true
-    @store['von:counters:foo']['total'].must_equal 2
-    @store['von:counters:foo:monthly'].has_key?('2013-02').must_equal true
-    @store['von:lists:foo:monthly'].size.must_equal 1
-  end
+    Von.increment('foo')
 
-  it "gets a total count for a counter" do
-    Counter.increment('foo')
-    Counter.increment('foo')
-    Counter.increment('foo')
+    Timecop.freeze(Time.local(2013, 01, 13, 06, 05))
+    4.times { Von.increment('foo') }
+    Timecop.freeze(Time.local(2013, 01, 20, 06, 10))
+    3.times { Von.increment('foo') }
 
-    Von.count('foo').must_equal 3
+    Counter.new('foo').best(:minute).must_equal({:timestamp => "2013-01-13 06:05", :count => 4})
+    Counter.new('foo').best(:week).must_equal({:timestamp => "2013-01-07", :count => 4})
   end
 
-  it "gets a count for a time period and 0s missing entries" do
+  it "returns current count for a given period" do
     Von.configure do |config|
-      config.counter 'foo', :monthly => 1, :hourly => 6
+      config.counter 'foo', :current => [:minute, :day]
     end
 
-    Timecop.freeze(Time.local(2013, 02, 01, 05))
-    Counter.increment('foo')
-    Timecop.freeze(Time.local(2013, 02, 01, 07))
-    Counter.increment('foo')
-
-    Von.count('foo').must_equal 2
-
-    Von.count('foo', :monthly).must_equal [{"2013-02" => 2}]
-    Von.count('foo', :hourly).must_equal [
-      {"2013-02-01 02:00"=>0},
-      {"2013-02-01 03:00"=>0},
-      {"2013-02-01 04:00"=>0},
-      {"2013-02-01 05:00"=>1},
-      {"2013-02-01 06:00"=>0},
-      {"2013-02-01 07:00"=>1}
-    ]
+    4.times { Von.increment('foo') }
+    Timecop.freeze(Time.local(2013, 01, 20, 06, 10))
+    3.times { Von.increment('foo') }
+
+    Counter.new('foo').this(:minute).must_equal 3
+    Counter.new('foo').current(:minute).must_equal 3
+    Counter.new('foo').this(:day).must_equal 3
+    Counter.new('foo').current(:day).must_equal 3
+    Counter.new('foo').today.must_equal 3
   end
 
+
 end