widescreen 0.0.1

data/.gitignore

@@ -0,0 +1,20 @@
+# rcov generated
+coverage
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# jeweler generated
+pkg
+
+.DS_Store
+
+Gemfile.lock
+.rvmrc

data/.travis.yml

@@ -0,0 +1,7 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - rbx
+  - jruby
+  - ree

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Marcin Ciunelis
+
+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,122 @@
+# Widescreen[![travis-ci](https://secure.travis-ci.org/martinciu/widescreen.png?branch=master)](http://travis-ci.org/martinciu/widescreen)
+Rack based event statistic framework for any Rack app
+
+## Requirements
+
+Widescreen uses redis as a datastore.
+
+Widescreen only supports redis 2.0 or greater.
+
+If you're on OS X, Homebrew is the simplest way to install Redis:
+
+    $ brew install redis
+    $ redis-server /usr/local/etc/redis.conf
+
+You now have a Redis daemon running on 6379.
+
+## Setup
+
+If you are using bundler add widescreen to your Gemfile:
+
+    gem 'widescreen'
+
+Then run:
+
+    bundle install
+
+Otherwise install the gem:
+
+    gem install widescreen
+
+and require it in your project:
+
+    require 'widescreen'
+
+## Usage
+
+Anywhere in you code call
+  
+    Widescreen::Stat.add(:metric_name, 10)
+
+to increase counter by 10 for `metric_name` metric or
+    
+    Widescreen::Stat.add(:metric_name)
+
+to increase it by 1
+
+## Web Interface
+
+Web interface is on to-do list. It will be simple sinatra app similar to Resque web interface
+
+## Configuration
+
+### Redis
+
+You may want to change the Redis host and port Wide connects to, or
+set various other options at startup.
+
+Widescreen has a `redis` setter which can be given a string or a Redis
+object. This means if you're already using Redis in your app, Widescreen
+can re-use the existing connection.
+
+String: `Widescreen.redis = 'localhost:6379'`
+
+Redis: `Widescreen.redis = $redis`
+
+For our rails app we have a `config/initializers/widescreen.rb` file where
+we load `config/widescreen.yml` by hand and set the Redis information
+appropriately.
+
+Here's our `config/widescreen.yml`:
+
+    development: localhost:6379
+    test: localhost:6379
+    staging: redis1.example.com:6379
+    fi: localhost:6379
+    production: redis1.example.com:6379
+
+And our initializer:
+
+    rails_root = ENV['RAILS_ROOT'] || File.dirname(__FILE__) + '/../..'
+    rails_env = ENV['RAILS_ENV'] || 'development'
+
+    widescreen_config = YAML.load_file(rails_root + '/config/widescreen.yml')
+    Widescreen.redis = widescreen_config[rails_env]
+
+## Namespaces
+
+If you're running multiple, separate instances of widescreen you may want
+to namespace the keyspaces so they do not overlap. This is not unlike
+the approach taken by many memcached clients.
+
+This feature is provided by the [redis-namespace][rs] library, which
+widescreen uses by default to separate the keys it manages from other keys
+in your Redis server.
+
+Simply use the `Widescreen.redis.namespace` accessor:
+
+    Widescreen.redis.namespace = "widescreen:blog"
+
+We recommend sticking this in your initializer somewhere after Redis
+is configured.
+
+## Development
+
+Source hosted at [GitHub](http://github.com/martinciu/widescreen).
+Report Issues/Feature requests on [GitHub Issues](http://github.com/martinciu/widescreen/issues).
+
+Tests can be ran with `rake test`
+
+### Note on Patches/Pull Requests
+
+ * Fork the project.
+ * Make your feature addition or bug fix.
+ * Add tests for it. This is important so I don't break it in a
+   future version unintentionally.
+ * Commit, do not mess with rakefile, version, or history.
+   (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+ * Send me a pull request. Bonus points for topic branches.
+
+## Copyright
+
+Copyright (c) 2011 Marcin Ciunelis. See [LICENSE](https://github.com/martinciu/widescreen/blob/master/LICENSE) for details.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake/testtask'
+require 'bundler/gem_tasks'
+Bundler.setup(:default, :test)
+
+Rake::TestTask.new do |t|
+  t.libs << "spec"
+  t.test_files = FileList['spec/**/*_spec.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/lib/widescreen/metric.rb

@@ -0,0 +1,58 @@
+module Widescreen
+  class Metric
+    attr_accessor :name
+    
+    def initialize(name)
+      @name     = name
+    end
+    
+    def new_record?
+      !Widescreen.redis.sismember(:metrics, name)
+    end
+
+    def save
+      return false unless valid?
+      Widescreen.redis.sadd(:metrics, name) if new_record?
+      true
+    end
+    
+    def valid?
+      !name.empty?
+    end
+    
+    def push(value)
+      Widescreen::Stat.add(self, value)
+    end
+    
+    def stats
+      Widescreen.redis.keys("#{name}#{Widescreen::SEPARATOR}*").map { |s| Widescreen::Stat.find(s) }
+    end
+    
+    def self.find(name)
+      new(name)
+    end
+
+    def to_s
+      name
+    end
+
+    def self.find_or_create(metric)
+      if Widescreen.redis.sismember(:metrics, metric)
+        find(metric)
+      else
+        create(metric)
+      end
+    end
+    
+    def self.all
+      Widescreen.redis.smembers(:metrics).map {|m| find(m)}
+    end
+
+    def self.create(name)
+      metric = new(name)
+      metric.save
+      metric
+    end
+    
+  end
+end

data/lib/widescreen/stat.rb

@@ -0,0 +1,38 @@
+module Widescreen
+  class Stat
+    attr_accessor :metric, :time, :value
+
+    def initialize(metric, time, value = 1)
+      @metric = Widescreen::Metric.find_or_create(metric)
+      @time   = time
+      @value  = value
+    end
+
+    def save
+      Widescreen.redis.incrby(key, value)
+    end
+
+    def self.add(metric, value = 1)
+      new(metric, Time.now, value).save
+    end
+    
+    def self.find(key)
+      value = Widescreen.redis.get(key)
+      return if value.nil?
+      metric_name, time = key.split(Widescreen::SEPARATOR, 2)
+      new(metric_name, Time.parse(time), value)
+    end
+
+    protected
+      def key
+        [metric.name, time_string].join(Widescreen::SEPARATOR)
+      end
+
+      def time_string
+        time.iso8601
+      rescue NoMethodError
+        time
+      end
+      
+  end
+end

data/lib/widescreen/version.rb

@@ -0,0 +1,3 @@
+module Widescreen
+  VERSION = "0.0.1"
+end

data/lib/widescreen.rb

@@ -0,0 +1,48 @@
+require 'redis/namespace'
+require 'time'
+
+require 'widescreen/version'
+require 'widescreen/metric'
+require 'widescreen/stat'
+
+module Widescreen
+  SEPARATOR = "|"
+  
+  extend self
+
+  # Accepts:
+  #   1. A 'hostname:port' String
+  #   2. A 'hostname:port:db' String (to select the Redis db)
+  #   3. A 'hostname:port/namespace' String (to set the Redis namespace)
+  #   4. A Redis URL String 'redis://host:port'
+  #   5. An instance of `Redis`, `Redis::Client`, `Redis::DistRedis`,
+  #      or `Redis::Namespace`.
+  def redis=(server)
+    case server
+    when String
+      if server =~ /redis\:\/\//
+        redis = Redis.connect(:url => server, :thread_safe => true)
+      else
+        server, namespace = server.split('/', 2)
+        host, port, db = server.split(':')
+        redis = Redis.new(:host => host, :port => port,
+          :thread_safe => true, :db => db)
+      end
+      namespace ||= :resque
+
+      @redis = Redis::Namespace.new(namespace, :redis => redis)
+    when Redis::Namespace
+      @redis = server
+    else
+      @redis = Redis::Namespace.new(:resque, :redis => server)
+    end
+  end
+
+  # Returns the current Redis connection. If none has been created, will
+  # create a new one.
+  def redis
+    return @redis if @redis
+    self.redis = Redis.respond_to?(:connect) ? Redis.connect : "localhost:6379"
+    self.redis
+  end
+end

data/spec/redis-test.conf

@@ -0,0 +1,115 @@
+# Redis configuration file example
+
+# By default Redis does not run as a daemon. Use 'yes' if you need it.
+# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
+daemonize yes
+
+# When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.
+# You can specify a custom pid file location here.
+pidfile ./spec/redis-test.pid
+
+# Accept connections on the specified port, default is 6379
+port 9736
+
+# If you want you can bind a single interface, if the bind option is not
+# specified all the interfaces will listen for connections.
+#
+# bind 127.0.0.1
+
+# Close the connection after a client is idle for N seconds (0 to disable)
+timeout 300
+
+# Save the DB on disk:
+#
+#   save <seconds> <changes>
+#
+#   Will save the DB if both the given number of seconds and the given
+#   number of write operations against the DB occurred.
+#
+#   In the example below the behaviour will be to save:
+#   after 900 sec (15 min) if at least 1 key changed
+#   after 300 sec (5 min) if at least 10 keys changed
+#   after 60 sec if at least 10000 keys changed
+save 900 1
+save 300 10
+save 60 10000
+
+# The filename where to dump the DB
+dbfilename dump.rdb
+
+# For default save/load DB in/from the working directory
+# Note that you must specify a directory not a file name.
+dir ./spec/
+
+# Set server verbosity to 'debug'
+# it can be one of:
+# debug (a lot of information, useful for development/testing)
+# notice (moderately verbose, what you want in production probably)
+# warning (only very important / critical messages are logged)
+loglevel debug
+
+# Specify the log file name. Also 'stdout' can be used to force
+# the demon to log on the standard output. Note that if you use standard
+# output for logging but daemonize, logs will be sent to /dev/null
+logfile stdout
+
+# Set the number of databases. The default database is DB 0, you can select
+# a different one on a per-connection basis using SELECT <dbid> where
+# dbid is a number between 0 and 'databases'-1
+databases 16
+
+################################# REPLICATION #################################
+
+# Master-Slave replication. Use slaveof to make a Redis instance a copy of
+# another Redis server. Note that the configuration is local to the slave
+# so for example it is possible to configure the slave to save the DB with a
+# different interval, or to listen to another port, and so on.
+
+# slaveof <masterip> <masterport>
+
+################################## SECURITY ###################################
+
+# Require clients to issue AUTH <PASSWORD> before processing any other
+# commands.  This might be useful in environments in which you do not trust
+# others with access to the host running redis-server.
+#
+# This should stay commented out for backward compatibility and because most
+# people do not need auth (e.g. they run their own servers).
+
+# requirepass foobared
+
+################################### LIMITS ####################################
+
+# Set the max number of connected clients at the same time. By default there
+# is no limit, and it's up to the number of file descriptors the Redis process
+# is able to open. The special value '0' means no limts.
+# Once the limit is reached Redis will close all the new connections sending
+# an error 'max number of clients reached'.
+
+# maxclients 128
+
+# Don't use more memory than the specified amount of bytes.
+# When the memory limit is reached Redis will try to remove keys with an
+# EXPIRE set. It will try to start freeing keys that are going to expire
+# in little time and preserve keys with a longer time to live.
+# Redis will also try to remove objects from free lists if possible.
+#
+# If all this fails, Redis will start to reply with errors to commands
+# that will use more memory, like SET, LPUSH, and so on, and will continue
+# to reply to most read-only commands like GET.
+#
+# WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
+# 'state' server or cache, not as a real DB. When Redis is used as a real
+# database the memory usage will grow over the weeks, it will be obvious if
+# it is going to use too much memory in the long run, and you'll have the time
+# to upgrade. With maxmemory after the limit is reached you'll start to get
+# errors for write operations, and this may even lead to DB inconsistency.
+
+# maxmemory <bytes>
+
+############################### ADVANCED CONFIG ###############################
+
+# Glue small output buffers together in order to send small replies in a
+# single TCP packet. Uses a bit more CPU but most of the times it is a win
+# in terms of number of queries per second. Use 'yes' if unsure.
+glueoutputbuf yes

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup(:default, :test)
+Bundler.require(:default, :test)
+
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + '/../lib'
+$TESTING = true
+require 'minitest/autorun'
+require 'timecop'
+
+if !ENV['TRAVIS']
+
+  # make sure we can run redis
+
+  if !system("which redis-server")
+    puts '', "** can't find `redis-server` in your path"
+    puts "** try running `sudo rake install`"
+    abort ''
+  end
+
+  #
+  # start our own redis when the tests start,
+  # kill it when they end
+  #
+
+  at_exit do
+    next if $!
+
+    if defined?(MiniTest)
+      exit_code = MiniTest::Unit.new.run(ARGV)
+    else
+      exit_code = Test::Unit::AutoRunner.run
+    end
+
+    pid = `ps -A -o pid,command | grep [r]edis-test`.split(" ")[0]
+    puts "Killing test redis server..."
+    `rm -f #{dir}/dump.rdb`
+    Process.kill("KILL", pid.to_i)
+    exit exit_code
+  end
+
+  puts "Starting redis for testing at localhost:9736..."
+  `redis-server #{dir}/redis-test.conf`
+  Widescreen.redis = 'localhost:9736'
+end
+

data/spec/widescreen/metric_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Widescreen::Metric do
+
+  before(:each) do
+    Widescreen.redis.flushall
+  end
+
+  describe "instance methods" do
+    describe "initialize" do
+      it "set name" do
+        Widescreen::Metric.new("foo").name.must_equal "foo"
+      end
+    end
+
+    describe "save" do
+      it "saves valid record" do
+        metric = Widescreen::Metric.new("foo")
+        metric.save.must_equal true
+        Widescreen.redis.sismember(:metrics, "foo").must_equal true
+      end
+      it "doesn't save invalid record" do
+        metric = Widescreen::Metric.new("")
+        metric.save.must_equal false
+        Widescreen.redis.sismember(:metrics, "foo").must_equal false
+      end
+    end
+
+    describe "valid?" do
+      it "returns true if name is not empty" do
+        Widescreen::Metric.new("foo").valid?.must_equal true
+      end
+      it "returns false if name is empty" do
+        Widescreen::Metric.new("").valid?.must_equal false
+      end
+    end
+
+    describe "new_record?" do
+      before {@metric = Widescreen::Metric.new("foo")}
+      it { @metric.new_record?.must_equal true }
+      
+      it "knows when it is an existed record" do
+        @metric.save
+        @metric.new_record?.must_equal false
+      end
+    end
+
+  end
+
+  describe "class methods" do
+    describe "create" do
+      before { @metric = Widescreen::Metric.create("foo") }
+      it { Widescreen.redis.sismember(:metrics, "foo").must_equal true }
+      it { @metric.must_be_instance_of Widescreen::Metric }
+    end
+
+    describe "all" do
+      before(:each) do
+        Widescreen::Metric.create("foo")
+        Widescreen::Metric.create("bar")
+        Widescreen::Metric.create("baz")
+      end
+
+      it { Widescreen::Metric.all.must_be_instance_of Array }
+      it { Widescreen::Metric.all.size.must_equal 3 }
+      it "returns array of Metrics" do
+        Widescreen::Metric.all.each do |metric|
+          metric.must_be_instance_of Widescreen::Metric
+        end
+      end
+    end
+
+    describe "stats" do
+      before(:each) do
+        @metric = Widescreen::Metric.create("foo")
+        now = Time.now
+        [1, 2, 5].each do |n|
+          Timecop.freeze(now - n*3600) do
+            Widescreen::Stat.add("foo")
+          end
+        end
+        Timecop.freeze(now)
+      end
+
+      after(:each) do
+        Timecop.return
+      end
+
+      it { @metric.stats.size.must_equal 3 }
+      it { @metric.stats.must_be_instance_of Array}
+      
+      it "returns instances of Stat" do
+        @metric.stats.each do |m|
+          m.must_be_instance_of Widescreen::Stat
+        end
+      end
+
+    end
+
+  end
+end

data/spec/widescreen/stat_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Widescreen::Stat do
+  before(:each) do
+    Widescreen.redis.flushall
+  end
+  
+  describe "instance methods" do
+    describe "initialize" do
+      before(:each) do
+        Timecop.freeze
+        @metric = Widescreen::Metric.create("foo")
+        @time = Time.now.iso8601
+        @stat = Widescreen::Stat.new("foo", @time, 5)
+      end
+      
+      after(:each) do
+        Timecop.return
+      end
+
+      it "has metric" do
+        @stat.metric.must_be_instance_of Widescreen::Metric
+      end
+      
+      it "has time" do
+        @stat.time.must_equal @time
+      end
+      
+      it "has value" do
+        @stat.value.must_equal 5
+      end
+    end
+    
+    describe "find" do
+      before(:each) do
+        @key = ["foo", Time.now.strftime('%Y-%m-%dT%H')].join(Widescreen::SEPARATOR)
+        Widescreen.redis.set(@key, 10)
+      end
+      
+      it "returns instance of Stat if it exist" do
+        Widescreen::Stat.find(@key).must_be_instance_of Widescreen::Stat
+      end
+      
+      it "returns nil if not found" do
+        Widescreen::Stat.find("#{@key}1").must_be_nil
+      end
+      
+    end
+  end
+
+  describe "class methods" do
+    describe "add" do
+      before(:each) do
+        Timecop.freeze
+        @time = Time.now.iso8601
+        @metric_name = "foo"
+        Widescreen::Metric.create(@metric_name)
+        @key = [@metric_name, @time].join(Widescreen::SEPARATOR)
+      end
+
+      after(:each) do
+        Timecop.return
+      end
+
+      describe "when no entry for a given time" do
+        it "creates entry with default value" do
+          Widescreen::Stat.add(@metric_name)
+          Widescreen.redis.get(@key).must_equal "1"
+        end
+
+        it "creates entry with value" do
+          Widescreen::Stat.add(@metric_name, 5)
+          Widescreen.redis.get(@key).must_equal "5"
+        end
+      end
+
+      describe "when there is an entry for a given time" do
+        before(:each) do
+          Widescreen::Stat.add(@metric_name, 5)
+        end
+
+        it "updates entry with default value" do
+          Widescreen::Stat.add(@metric_name)
+          Widescreen.redis.get(@key).must_equal "6"
+        end
+
+        it "updates entry with value" do
+          Widescreen::Stat.add(@metric_name, 5)
+          Widescreen.redis.get(@key).must_equal "10"
+        end
+
+      end
+
+    end
+  end
+
+end

data/widescreen.gemspec

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'widescreen/version'
+
+Gem::Specification.new do |s|
+  s.name         = "widescreen"
+  s.version      = Widescreen::VERSION
+  s.authors      = ["Marcin Ciunelis"]
+  s.email        = "marcin.ciunelis@gmail.com"
+  s.homepage     = "http://github.com/martinciu/widescreen"
+  s.summary      = "Rack based event statistic framework for any Rack app"
+ 
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.platform     = Gem::Platform::RUBY
+
+  s.add_dependency 'redis',           '~> 2.2.2'
+  s.add_dependency 'redis-namespace', '~> 1.0.3'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'minitest', '~> 2.6.1'
+  s.add_development_dependency 'timecop', '~> 0.3.5'
+
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: widescreen
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Marcin Ciunelis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-21 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &2162119200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *2162119200
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: &2162118580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *2162118580
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2162118160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2162118160
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &2162117460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.1
+  type: :development
+  prerelease: false
+  version_requirements: *2162117460
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: &2162096100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.5
+  type: :development
+  prerelease: false
+  version_requirements: *2162096100
+description: 
+email: marcin.ciunelis@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/widescreen.rb
+- lib/widescreen/metric.rb
+- lib/widescreen/stat.rb
+- lib/widescreen/version.rb
+- spec/redis-test.conf
+- spec/spec_helper.rb
+- spec/widescreen/metric_spec.rb
+- spec/widescreen/stat_spec.rb
+- widescreen.gemspec
+homepage: http://github.com/martinciu/widescreen
+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'
+      segments:
+      - 0
+      hash: 225638225036064920
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 225638225036064920
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Rack based event statistic framework for any Rack app
+test_files:
+- spec/redis-test.conf
+- spec/spec_helper.rb
+- spec/widescreen/metric_spec.rb
+- spec/widescreen/stat_spec.rb