von 0.1.0

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 blahed
+
+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,105 @@
+# Von [![Build Status](https://travis-ci.org/blahed/von.png?branch=master)](https://travis-ci.org/blahed/von)
+
+Von is an opinionated Redis stats tracker. It works with keys, you choose one, Von increments it. It has a few built in conveniences:
+
+## Requirements
+
+Von uses Redis for storing counters so you'll need it get going. If you're on OS X you can use homebrew:
+
+```bash
+$ brew install redis
+```
+
+## Auto Incrementing Parent Keys
+
+Keys are namespaced and every parent key is incremented when you increment a child key, for example:
+
+```ruby
+Von.increment('downloads')          # bumps the 'downloads' key 1 time
+Von.increment('downloads:app123')   # bumps the 'downloads:app123' key 1 time AND the 'downloads' key 1 time
+```
+
+## Time Period Grouping and Limiting
+
+By default Von will only bump a "total" counter for the given key. This is great, but what makes Von really useful is that it can be configured to group certain keys by hour, day, week, month, and year. And you can set limits on how many of each you want to keep around. Here's how it works:
+
+### Configuring Time Periods
+```ruby
+Von.configure do |config|
+    # Keep daily stats for 30 days
+    config.counter 'downloads', :daily => 30
+
+    # Keep monthly stats for 3 months and yearly stats for 2 years
+    config.counter 'uploads', :monthly => 3, :yearly => 2
+end
+```
+
+### Incrementing Time Periods
+
+Once you've configured the keys you want to use Time Periods on, you just increment them like normal, Von handles the rest.
+
+```ruby
+Von.increment('downloads')
+Von.increment('uploads')
+```
+
+## Getting Stats
+
+```ruby
+# get the total downloads (returns an Integer)
+Von.count('downloads')  #=> 4
+# get the monthly counts (returns an Array of Hashes)
+Von.count('uploads', :monthly)  #=> [ { '2012-03 => 3}, { '2013-04' => 1 }, { '2013-05' => 0 }]
+
+```
+
+One nice thing to note, if you're counting a time period and there wasn't a value stored for the particular hour/day/week/etc, it'll be populated with a zero, this ensures that if you want 30 days of stats, you get 30 days of stats.
+
+## Configuration
+
+There are a few things you might want to configure in Von, you can do this in the configure block where you would also set time periods and expirations.
+
+```ruby
+Von.configure do |config|
+    # set the Redis connection to an already existing connection
+    config.redis = Redis.current
+    # Initialize a new Redis connection given options
+    config.redis = { :host => 'localhost', :port => 6379 }
+    
+    # rescue Redis connection errors
+    # if the connection fails, no errors are raised by default
+    config.raise_connection_errors = false
+
+    # set the top level Redis key namespace
+    config.namespace = 'von'
+
+    # set the various formatting for time periods (defaults shown)
+    config.yearly_format  = '%Y'
+    config.monthly_format = '%Y-%m'
+    config.weekly_format  = '%Y-%m-%d'
+    config.daily_format   = '%Y-%m-%d'
+    config.hourly_format  = '%Y-%m-%d %H:00'
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'von'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install von
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+require 'rake/testtask'
+require 'bundler/gem_tasks'
+
+Rake::TestTask.new do |t|
+    t.libs << 'test'
+    t.test_files = FileList['test/*_test.rb']
+end
+
+task :default => :test

data/lib/von/config.rb

@@ -0,0 +1,81 @@
+require 'yaml'
+
+module Von
+  module Config
+    extend self
+
+    attr_accessor :namespace
+    attr_accessor :raise_connection_errors
+    attr_accessor :yearly_format
+    attr_accessor :monthly_format
+    attr_accessor :weekly_format
+    attr_accessor :daily_format
+    attr_accessor :hourly_format
+
+    attr_reader  :periods
+
+    def init!
+      @counter_options = {}
+      @periods         = {}
+      # all keys are prefixed with this namespace
+      self.namespace = 'von'
+      # rescue Redis connection errors
+      self.raise_connection_errors = false
+      # 2013
+      self.yearly_format  = '%Y'
+      # 2013-01
+      self.monthly_format = '%Y-%m'
+      # 2013-01-02
+      self.weekly_format  = '%Y-%m-%d'
+      # 2013-01-02
+      self.daily_format   = '%Y-%m-%d'
+      # 2013-01-02 12:00
+      self.hourly_format  = '%Y-%m-%d %H:00'
+    end
+
+    # Set the Redis connection to use
+    #
+    # arg - A Redis connection or a Hash of Redis connection options
+    #
+    # Returns the Redis client
+    def redis=(arg)
+      if arg.is_a? Redis
+        @redis = arg
+      else
+        @redis = Redis.new(arg)
+      end
+    end
+
+    # Returns the Redis connection
+    def redis
+      @redis ||= Redis.new
+    end
+
+    # Configure options for given Counter. Configures length of given time period
+    # and any other options for the Counter
+    def counter(field, options = {})
+      options.each do |key, value|
+        if Period::AVAILABLE_PERIODS.include?(key)
+          @periods[field.to_sym] ||= {}
+          @periods[field.to_sym][key.to_sym] = Period.new(field, key, value)
+          options.delete(key)
+        end
+      end
+
+      @counter_options[field.to_sym] = options
+    end
+
+    # Returns a True if a Period is defined for the
+    # given period identifier and the period has a length
+    # False if not
+    def period_defined_for?(key, period)
+      @periods.has_key?(key) && @periods[key].has_key?(period)
+    end
+
+    # TODO: rename
+    def counter_options(field)
+      @counter_options[field.to_sym] ||= {}
+    end
+
+  end
+end

data/lib/von/counter.rb

@@ -0,0 +1,113 @@
+module Von
+  class Counter
+    PARENT_REGEX = /:?[^:]+\z/
+
+    # Initialize a new Counter
+    #
+    # field - counter field name
+    def initialize(field)
+      @field = field.to_sym
+    end
+
+    # Returns options specified in config for this Counter
+    def options
+      @options ||= Von.config.counter_options(@field)
+    end
+
+    # Returns the Redis hash key used for storing counts for this Counter
+    def hash_key
+      @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
+      total = Von.connection.hincrby(hash_key, 'total', 1)
+
+      increment_periods
+
+      total
+    end
+
+    # Increment periods associated with this key
+    def increment_periods
+      return unless Von.config.periods.has_key?(@field.to_sym)
+
+      Von.config.periods[@field.to_sym].each do |key, period|
+        Von.connection.hincrby(period.hash_key, period.field, 1)
+        unless Von.connection.lrange(period.list_key, 0, -1).include?(period.field)
+          Von.connection.rpush(period.list_key, period.field)
+        end
+
+        if Von.connection.llen(period.list_key) > period.length
+          expired_counter = Von.connection.lpop(period.list_key)
+          Von.connection.hdel(period.hash_key, expired_counter)
+        end
+      end
+    end
+
+    # Increment the Redis count for this Counter.
+    # If the key has parents, increment them as well.
+    #
+    # Returns the Integer total for the key
+    def self.increment(field)
+      total   = Counter.new(field).increment
+      parents = field.sub(PARENT_REGEX, '')
+
+      until parents.empty? do
+        Counter.new(parents).increment
+        parents.sub!(PARENT_REGEX, '')
+      end
+
+      total
+    end
+
+    # Count the "total" field for this Counter.
+    #
+    # Returns an Integer count
+    def count
+      Von.connection.hget(hash_key, 'total')
+    end
+
+    # Count the fields for the given time period for this Counter.
+    #
+    # Returns an Array of Hashes representing the count
+    def count_period(period)
+      return unless Von.config.period_defined_for?(@field, period)
+
+      _counts   = []
+      _period   = Von.config.periods[@field][period]
+      now       = DateTime.now.beginning_of_hour
+
+      _period.length.times do
+        this_period = now.strftime(_period.format)
+        _counts.unshift(this_period)
+        now = _period.hours? ? now.ago(3600) : now.send(:"prev_#{_period.time_unit}")
+      end
+
+      keys = Von.connection.hgetall("#{hash_key}:#{period}")
+      _counts.map { |date| { date => keys.fetch(date, 0) }}
+    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, period = nil)
+      counter = Counter.new(field)
+
+      if period.nil?
+        counter.count
+      else
+        counter.count_period(period.to_sym)
+      end
+    end
+
+  end
+end

data/lib/von/model_counter.rb

@@ -0,0 +1,28 @@
+module Von
+  module ModelCounter
+    extend ::ActiveSupport::Concern
+
+     module ClassMethods
+       def increments_stat(key, options = {})
+          increment_method = "increment_stat_#{key.gsub(/:/, '_')}".to_sym
+
+          define_method increment_method do
+            Von.increment(key)
+          end
+
+          case options[:on]
+          when :create
+            after_create increment_method
+          when :save
+            after_save increment_method
+          when :update
+            after_update increment_method
+          else
+            # default to create
+            after_create increment_method
+          end
+       end
+     end
+
+  end
+end

data/lib/von/period.rb

@@ -0,0 +1,58 @@
+module Von
+  class Period
+    AVAILABLE_PERIODS = [ :hourly, :daily, :weekly, :monthly, :yearly ]
+
+    attr_reader :counter_key
+    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")
+    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
+    end
+
+    # Returns True or False if the period is hourly
+    def hours?
+      @period == :hourly
+    end
+
+    # Returns the Redis hash key used for storing counts for this Period
+    def hash_key
+      @hash ||= "#{Von.config.namespace}:counters:#{@counter_key}:#{@period}"
+    end
+
+    # Returns the Redis list key used for storing current "active" counters
+    def list_key
+      @list ||= "#{Von.config.namespace}:lists:#{@counter_key}:#{@period}"
+    end
+
+    # Returns the Redis field representation used for storing the count value
+    def field
+      Time.now.strftime(format)
+    end
+  end
+end

data/lib/von/version.rb

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

data/lib/von.rb

@@ -0,0 +1,35 @@
+require 'redis'
+require 'active_support/time'
+
+require 'von/config'
+require 'von/counter'
+require 'von/period'
+require 'von/version'
+
+module Von
+  def self.connection
+    @connection ||= config.redis
+  end
+
+  def self.config
+    Config
+  end
+
+  def self.configure
+    yield(config)
+  end
+
+  def self.increment(field)
+    Counter.increment(field)
+  rescue Redis::BaseError => e
+    raise e if config.raise_connection_errors
+  end
+
+  def self.count(field, period = nil)
+    Counter.count(field, period)
+  rescue Redis::BaseError => e
+    raise e if config.raise_connection_errors
+  end
+
+  config.init!
+end

data/test/config_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+describe Von::Config do
+
+  before :each do
+    @config = Von::Config
+    @config.init!
+  end
+
+  it 'intiializes a config with defaults' do
+    @config.namespace.must_equal 'von'
+    @config.hourly_format.must_equal '%Y-%m-%d %H:00'
+  end
+
+  it 'initializes a config and overloads it with a block' do
+    @config.namespace = 'something'
+
+    @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
+
+    @config.namespace.must_equal 'von'
+    @config.counter_options('bar').must_equal options
+  end
+
+  it "allows config options to be updated via configure" do
+    options = { :monthly => 3, :total => false }
+
+    Von.configure do |config|
+      config.counter 'bar', options
+    end
+
+    Von.config.namespace.must_equal 'von'
+    Von.config.counter_options('bar').must_equal options
+  end
+
+end

data/test/counter_test.rb

@@ -0,0 +1,97 @@
+require 'test_helper'
+
+describe Von::Counter do
+  Counter = Von::Counter
+
+  before :each do
+    Timecop.freeze(Time.local(2013, 01))
+    Von.config.init!
+    mock_connection!
+  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
+  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
+  end
+
+  it "increments a month counter" do
+    Von.configure do |config|
+      config.counter 'foo', :monthly => 1
+    end
+
+    Counter.increment('foo')
+    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']['2013-01'].must_equal 2
+    @store['von:lists:foo:monthly'].size.must_equal 1
+  end
+
+  it "expires counters past the limit" do
+    Von.configure do |config|
+      config.counter 'foo', :monthly => 1
+    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
+
+  it "gets a total count for a counter" do
+    Counter.increment('foo')
+    Counter.increment('foo')
+    Counter.increment('foo')
+
+    Von.count('foo').must_equal 3
+  end
+
+  it "gets a count for a time period and 0s missing entries" do
+    Von.configure do |config|
+      config.counter 'foo', :monthly => 1, :hourly => 6
+    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}
+    ]
+  end
+
+end

data/test/period_test.rb

@@ -0,0 +1,65 @@
+describe Von::Period do
+  Period = Von::Period
+
+  before :each do
+    @config = Von::Config
+    @config.init!
+  end
+
+  it "intiializes given a counter, period, and length" do
+    period = Period.new('foo', :monthly, 6)
+    period.counter_key.must_equal 'foo'
+    period.length.must_equal 6
+    period.format.must_equal '%Y-%m'
+  end
+
+  it "checks if the period is an hourly period" do
+    Period.new('foo', :hourly, 6).must_be :hours?
+    Period.new('foo', :daily, 6).wont_be :hours?
+    Period.new('foo', :weekly, 6).wont_be :hours?
+    Period.new('foo', :monthly, 6).wont_be :hours?
+    Period.new('foo', :yearly, 6).wont_be :hours?
+  end
+
+  it "knows what time unit it is" do
+    Period.new('foo', :hourly, 6).time_unit.must_equal :hour
+    Period.new('foo', :daily, 6).time_unit.must_equal :day
+    Period.new('foo', :weekly, 6).time_unit.must_equal :week
+    Period.new('foo', :monthly, 6).time_unit.must_equal :month
+    Period.new('foo', :yearly, 6).time_unit.must_equal :year
+  end
+
+  it "pulls a time format from config options" do
+    Period.new('foo', :hourly, 6).format.must_equal Von.config.hourly_format
+    Period.new('foo', :daily, 6).format.must_equal Von.config.daily_format
+    Period.new('foo', :weekly, 6).format.must_equal Von.config.weekly_format
+    Period.new('foo', :monthly, 6).format.must_equal Von.config.monthly_format
+    Period.new('foo', :yearly, 6).format.must_equal Von.config.yearly_format
+  end
+
+  it "builds a redis hash key string" do
+    field  = 'foo'
+    period = :hourly
+    period_obj = Period.new(field, period, 6)
+
+    period_obj.hash_key.must_equal "#{@config.namespace}:counters:#{field}:#{period}"
+  end
+
+  it "builds a redis list key string" do
+    field  = 'foo'
+    period = :hourly
+    period_obj = Period.new(field, period, 6)
+
+    period_obj.list_key.must_equal "#{@config.namespace}:lists:#{field}:#{period}"
+  end
+
+  it "builds a redis field for the given period and current time" do
+    Timecop.freeze(Time.local(2013, 02, 01, 05))
+    Period.new('foo', :hourly, 6).field.must_equal '2013-02-01 05:00'
+    Period.new('foo', :daily, 6).field.must_equal '2013-02-01'
+    Period.new('foo', :weekly, 6).field.must_equal '2013-02-01'
+    Period.new('foo', :monthly, 6).field.must_equal '2013-02'
+    Period.new('foo', :yearly, 6).field.must_equal '2013'
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,73 @@
+$LOAD_PATH.unshift(File.expand_path('../../test', __FILE__))
+
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'mocha'
+require 'timecop'
+
+require 'von'
+
+module Von
+  class TestConnection
+    attr_reader :store
+
+    def initialize
+      @store = {}
+    end
+
+    def hincrby(hash, key, counter)
+      @store[hash] ||= {}
+
+      if @store[hash].has_key?(key)
+        @store[hash][key] += counter
+      else
+        @store[hash][key] = counter
+      end
+
+       @store[hash][key]
+    end
+
+    def hget(hash, key)
+      @store[hash][key]
+    end
+
+    def hgetall(hash)
+      @store.fetch(hash, {})
+    end
+
+    def hdel(hash, key)
+      @store[hash].delete(key)
+    end
+
+    def rpush(list, member)
+      @store[list] ||= []
+      @store[list] << member
+    end
+
+    def lpop(list)
+      @store[list].shift
+    end
+
+    def lrange(list, start, stop)
+      @store[list] ||= []
+      @store[list][start..stop]
+    end
+
+    def llen(list)
+      @store[list].length
+    end
+
+  end
+end
+
+module MiniTest::Expectations
+  def mock_connection!
+    connection = Von::TestConnection.new
+    @store     = connection.store
+    Von.expects(:connection).returns(connection).at_least_once
+  end
+end

data/test/von_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+describe Von do
+
+  before :each do
+    Von.config.init!
+  end
+
+  it "increments a counter and counts it" do
+    mock_connection!
+
+    Von.increment('foo')
+    Von.increment('foo')
+    Von.count('foo').must_equal 2
+  end
+
+  it "raises a Redis connection errors if raise_connection_errors is true" do
+    Von.config.raise_connection_errors = true
+    Redis.expects(:new).raises(Redis::CannotConnectError)
+
+    lambda { Von.increment('foo') }.must_raise Redis::CannotConnectError
+  end
+
+end

data/von.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'von/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "von"
+  gem.version       = Von::VERSION
+  gem.authors       = ["blahed"]
+  gem.email         = ["tdunn13@gmail.com"]
+  gem.description   = "Von is an opinionated Redis stats tracker."
+  gem.summary       = "Von is an opinionated Redis stats tracker."
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'redis', '~> 3.0.2'
+  gem.add_dependency 'activesupport', '~> 3.2.11'
+
+  gem.add_development_dependency 'rake', '~> 10.0.3'
+  gem.add_development_dependency 'minitest', '~> 3.0.0'
+  gem.add_development_dependency 'mocha', '~> 0.11.4'
+  gem.add_development_dependency 'timecop', '~> 0.5.9.1'
+end

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: von
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- blahed
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.2
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.11
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.3
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.11.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.11.4
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.9.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.9.1
+description: Von is an opinionated Redis stats tracker.
+email:
+- tdunn13@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/von.rb
+- lib/von/config.rb
+- lib/von/counter.rb
+- lib/von/model_counter.rb
+- lib/von/period.rb
+- lib/von/version.rb
+- test/config_test.rb
+- test/counter_test.rb
+- test/period_test.rb
+- test/test_helper.rb
+- test/von_test.rb
+- von.gemspec
+homepage: ''
+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.23
+signing_key: 
+specification_version: 3
+summary: Von is an opinionated Redis stats tracker.
+test_files:
+- test/config_test.rb
+- test/counter_test.rb
+- test/period_test.rb
+- test/test_helper.rb
+- test/von_test.rb