route_counter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1fc94b92228e7bbabc32aac5993cc9c40d419b05
+  data.tar.gz: aeb549b53956c26c7c6b34d6ec83491c184deddc
+SHA512:
+  metadata.gz: 370d759b06abd2057c2e855b55c83dd2913bda8aff7813c4fcbb8972c498cab8befa68f83a9f01a3acce5abc017821307c1e280d2d9cbfa15890155d37495892
+  data.tar.gz: 404f635724b19c567538865396b2e85edb3b96033894c15d491f77848c2d15e78ee7cb98c829b9db6b1814ed6cc843d541d13634d6910b865882d6937798efa3

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 TODO: Write your name
+
+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,82 @@
+# RouteCounter
+
+When you want to know how much your routes are being used.
+
+This is particularly useful if you are wondering if they are used at all.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'route_counter'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install route_counter
+
+Enable the recording in an initializer and insert the middleware:
+
+```ruby
+  RouteCounter.config.enabled = true
+  Rails.application.config.middleware.use RouteCounter::Middleware
+```
+
+Add to Rakefile:
+
+```ruby
+require "route_counter/tasks"
+```
+
+## Usage
+
+
+Check what's been used.
+
+```bash
+  $ bundle exec rake routes:count:local
+```
+
+All of this gets stored on your disk. If you want to clear it out.
+
+```bash
+  $ bundle exec rake route_counter:local:clear
+```
+
+##  Global Usage
+
+You might want to see the counts across your servers.
+This will use Redis to aggregate info from across all of them.
+First, you'll need to tell it where Redis is:
+
+```ruby
+RouteCounter.config.redis = Redis.new(connection_hash)
+```
+
+Then, you can clear out the remote store.
+Or not to be cumulative to last time you took a snapshot
+
+```bash
+  $ bundle exec rake route_counter:global:clear
+```
+
+Then take a snapshot. You can do this in parallel on all of your servers (with Capistrano for example).
+
+```bash
+  $ bundle exec rake route_counter:snapshot
+```
+
+Then on one of the servers you can run to use the global numbers
+
+```bash
+  $ bundle exec rake routes:count:global
+```
+
+## TODO
+
+* could make a middleware (or config option) that wrote directly to Redis
+* should it record more info about the request?
+* configurable error handler

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/route_counter.rb

@@ -0,0 +1,24 @@
+require "route_counter/version"
+
+module RouteCounter
+  autoload :Config,           'route_counter/config'
+  autoload :ConsoleFormatter, 'route_counter/console_formatter'
+  autoload :FileRecorder,     'route_counter/file_recorder'
+  autoload :Middleware,       'route_counter/middleware'
+  autoload :RedisRecorder,    'route_counter/redis_recorder'
+  autoload :Snapshot,         'route_counter/snapshot'
+  autoload :Util,             'route_counter/util'
+
+  class << self
+    def config
+      @config ||= RouteCounter::Config.new
+    end
+
+    protected
+
+    def reset
+      # mostly for tests, resets eveything
+      @config = nil
+    end
+  end
+end

data/lib/route_counter/config.rb

@@ -0,0 +1,27 @@
+module RouteCounter
+  class Config
+    attr_writer :directory, :enabled, :redis
+
+    def directory
+      @directory ||= File.join(Dir.home, "route_counter")
+    end
+
+    def enabled
+      !!@enabled
+    end
+    alias :enabled? :enabled
+
+    def redis
+      return @redis if @redis
+      require 'redis'
+      @redis = Redis.new
+    end
+
+    def error!(e)
+      # TODO: not worth it to crash but should log. allow settable
+      if defined?(Rails)
+        Rails.logger.error(e)
+      end
+    end
+  end
+end

data/lib/route_counter/console_formatter.rb

@@ -0,0 +1,84 @@
+require 'action_dispatch/routing/inspector'
+
+module RouteCounter
+  class ConsoleFormatter # like ActionDispatch::Routing::ConsoleFormatter
+    class << self
+      def puts!(recorder_klass)
+        # from railties/routes.rake
+        all_routes = Rails.application.routes.routes
+        inspector = ActionDispatch::Routing::RoutesInspector.new(all_routes)
+        path_hash = recorder_klass.actions_visited
+        formatter = RouteCounter::ConsoleFormatter.new(path_hash)
+        puts inspector.format(formatter, ENV['CONTROLLER'])
+      end
+    end
+
+    def initialize(path_hash)
+      @buffer = []
+      @path_hash = path_hash || {}
+    end
+
+    def result
+      @buffer.join("\n")
+    end
+
+    def section_title(title)
+      @buffer << "\n#{title}:"
+    end
+
+    def section(routes)
+      @buffer << draw_section(routes)
+    end
+
+    def header(routes)
+      @buffer << draw_header(routes)
+    end
+
+    def no_routes
+      @buffer << <<-MESSAGE.strip_heredoc
+        You don't have any routes defined!
+
+        Please add some routes in config/routes.rb.
+
+        For more information about routes, see the Rails guide: http://guides.rubyonrails.org/routing.html.
+        MESSAGE
+    end
+
+    private
+      def draw_section(routes)
+        count_width, name_width, verb_width, path_width = widths(routes)
+
+        routes.map do |r|
+          "#{count_for_route(r).ljust(count_width)} #{r[:name].ljust(name_width)} #{r[:verb].ljust(verb_width)} #{r[:path].ljust(path_width)} #{r[:reqs]}"
+        end
+      end
+
+      def draw_header(routes)
+        count_width, name_width, verb_width, path_width = widths(routes)
+
+        "#{"Count".rjust(count_width)} #{"Prefix".ljust(name_width)} #{"Verb".ljust(verb_width)} #{"URI Pattern".ljust(path_width)} Controller#Action"
+      end
+
+      def widths(routes)
+        [ max_count_width,
+         routes.map { |r| r[:name].length }.max,
+         routes.map { |r| r[:verb].length }.max,
+         routes.map { |r| r[:path].length }.max]
+      end
+
+      def max_count_width
+        @max_count_width ||= [@path_hash.values.max.to_s.length, "Count".length].max
+      end
+
+      def count_for_route(r)
+        has_action = r[:reqs].to_s
+        return "~" unless has_action.include?("#")
+        count = 0
+        @path_hash.each do |action, num|
+          next unless has_action.start_with?(action)
+          count += num
+        end
+        count.to_s
+      end
+  end
+end

data/lib/route_counter/file_recorder.rb

@@ -0,0 +1,127 @@
+require 'fileutils'
+require 'monitor'
+
+# A recorder implements these class methods
+#   * action_visited(controller_name, action_name) : record that it was visited
+#   * actions_visited : returns hash of url => count
+#   * rotate! : backup what was recorded and start counting again. returns hash.
+#   * clear!  : clear everything out
+
+module RouteCounter
+  class FileRecorder
+    class << self
+
+      def parent_directory
+        RouteCounter.config.directory
+      end
+
+      def current_directory
+        File.join(parent_directory, 'current')
+      end
+
+      def read_directory(root)
+        out = {}
+        Dir[ File.join(root, '**', '*') ].each do |file|
+          next if File.directory?(file)
+          hits = File.size(file) # each should be 1 byte
+          action_name = File.basename(file)
+          controller_name = File.dirname(file)
+          controller_name.gsub!("#{root}/", '')
+          key = "#{controller_name}##{action_name}"
+          out[key] ||= 0
+          out[key] += hits
+        end
+        out
+      end
+
+      def action_visited(controller_name, action_name)
+        # write down it was visited
+        file_path = File.join(File.join(current_directory, controller_name, action_name))
+        logdev = LogDevice.new(file_path)
+        logdev.write('X')
+        logdev.close
+      end
+
+      def actions_visited
+        # returns what was visited and counts
+        read_directory(current_directory)
+      end
+
+      def rotate!
+        # lock the current one and return the visited
+        alt_directory = File.join(parent_directory, "#{Time.now.to_i}-#{rand(99999999)}")
+        FileUtils.mkdir_p(current_directory) # make sure it's there
+        FileUtils.mv(current_directory, alt_directory)
+        read_directory(alt_directory)
+      end
+
+      def clear!
+        FileUtils.rm_rf(parent_directory)
+      end
+    end
+
+    class LogDevice # from Logger
+
+      attr_reader :dev
+      attr_reader :filename
+
+      class LogDeviceMutex
+        include MonitorMixin
+      end
+
+      def initialize(log = nil, opt = {})
+        @dev = @filename = nil
+        @mutex = LogDeviceMutex.new
+        if log.respond_to?(:write) and log.respond_to?(:close)
+          @dev = log
+        else
+          @dev = open_logfile(log)
+          @dev.sync = true
+          @filename = log
+        end
+      end
+
+      def write(message)
+        @mutex.synchronize do
+          @dev.write(message)
+        end
+      end
+
+      def close
+        begin
+          @mutex.synchronize do
+            @dev.close rescue nil
+          end
+        rescue Exception
+          @dev.close rescue nil
+        end
+      end
+
+    private
+
+      def open_logfile(filename)
+        begin
+          open(filename, (File::WRONLY | File::APPEND))
+        rescue Errno::ENOENT
+          create_logfile(filename)
+        end
+      end
+
+      def create_logfile(filename)
+        begin
+          FileUtils.mkdir_p(File.dirname(filename))
+
+          logdev = open(filename, (File::WRONLY | File::APPEND | File::CREAT | File::EXCL))
+          logdev.flock(File::LOCK_EX)
+          logdev.sync = true
+          logdev.flock(File::LOCK_UN)
+        rescue Errno::EEXIST
+          # file is created by another process
+          logdev = open_logfile(filename)
+          logdev.sync = true
+        end
+        logdev
+      end
+    end
+  end
+end

data/lib/route_counter/middleware.rb

@@ -0,0 +1,31 @@
+module RouteCounter
+  class Middleware
+    attr_reader :env
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @env = env
+      status, headers, body = @app.call(env)
+      write_result! if RouteCounter.config.enabled?
+      [status, headers, body]
+    end
+
+    def write_result!
+      result = env['action_dispatch.request.path_parameters']
+      return unless result
+
+      controller_name = result[:controller]
+      action_name     = result[:action]
+
+      return unless controller_name && action_name
+
+      # TODO: case on config for types: file, redis, other
+      # TODO: use env['REQUEST_METHOD'] ?
+      RouteCounter::FileRecorder.action_visited(controller_name, action_name)
+    rescue Exception => e
+      RouteCounter.config.error!("[RouteCleaner] #{e.message}\n#{e.backtrace.join("\n")}")
+    end
+  end
+end

data/lib/route_counter/redis_recorder.rb

@@ -0,0 +1,53 @@
+require 'fileutils'
+require 'monitor'
+
+# A recorder implements these class methods
+#   * action_visited(controller_name, action_name) : record that it was visited
+#   * actions_visited : returns hash of url => count
+#   * rotate! : backup what was recorded and start counting again. returns hash.
+#   * clear!  : clear everything out
+
+module RouteCounter
+  class RedisRecorder
+    class << self
+
+      def client
+        RouteCounter.config.redis
+      end
+
+      def current_key
+        "route_counter:current"
+      end
+
+      def read_key(key)
+        out = {}
+        client.hgetall(key).each do |action, num|
+          out[action] = num.to_i
+        end
+        out
+      end
+
+      def increment!(action_key, amount)
+        client.hincrby(current_key, action_key, amount)
+      end
+
+      def action_visited(controller_name, action_name)
+        key = "#{controller_name}##{action_name}"
+        increment!(key, 1)
+      end
+
+      def actions_visited
+        # returns what was visited and counts
+        read_key(current_key)
+      end
+
+      def rotate!
+        raise "not supported"
+      end
+
+      def clear!
+        client.del(current_key)
+      end
+    end
+  end
+end

data/lib/route_counter/snapshot.rb

@@ -0,0 +1,13 @@
+module RouteCounter
+  class Snapshot
+    class << self
+      # send to redis
+      def transfer!(recorder_klass)
+        hash = recorder_klass.rotate!
+        hash.each do |action, num|
+          RedisRecorder.increment!(action, num)
+        end
+      end
+    end
+  end
+end

data/lib/route_counter/tasks.rb

@@ -0,0 +1,34 @@
+namespace :routes do
+  namespace :count do
+    desc "Shows the routes and if they've been used locally"
+    task local: :environment do
+      RouteCounter::ConsoleFormatter.puts!(RouteCounter::FileRecorder)
+    end
+
+    desc "Shows the routes and if they've been used globally"
+    task global: :environment do
+      RouteCounter::ConsoleFormatter.puts!(RouteCounter::RedisRecorder)
+    end
+  end
+end
+
+namespace :route_counter do
+  desc "send local information to global"
+  task snapshot: :environment do
+    RouteCounter::Snapshot.transfer!(RouteCounter::FileRecorder)
+  end
+
+  namespace :local do
+    desc "clears out the local store"
+    task clear: :environment do
+      RouteCounter::FileRecorder.clear!
+    end
+  end
+
+  namespace :global do
+    desc "clears out the global store"
+    task clear: :environment do
+      RouteCounter::RedisRecorder.clear!
+    end
+  end
+end

data/lib/route_counter/version.rb

@@ -0,0 +1,3 @@
+module RouteCounter
+  VERSION = "0.1.0"
+end

data/route_counter.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'route_counter/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "route_counter"
+  spec.version       = RouteCounter::VERSION
+  spec.authors       = ["Brian Leonard"]
+  spec.email         = ["brian@bleonard.com"]
+  spec.summary       = %q{Monitors the usage of your routes}
+  spec.description   = %q{Helps you to find unused Rails routes}
+  spec.homepage      = "https://github.com/taskrabbit/route_counter"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rack"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "redis"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "byebug"
+end

data/spec/config_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe RouteCounter::Config do
+  it "should be returned from the module" do
+    RouteCounter.config.class.name.should == "RouteCounter::Config"
+  end
+
+  describe ".directory" do
+    it "should default to ~/" do
+      RouteCounter.send(:reset)
+      RouteCounter.config.directory.to_s.should == File.join(Dir.home, "route_counter")
+    end
+
+    it "should be defaulting to tmp directory in test" do
+      RouteCounter.config.directory.should =~ /\/tmp\/recorder/
+    end
+
+    it "should be able to be set" do
+      RouteCounter.config.directory = "something"
+      RouteCounter.config.directory.should == "something"
+    end
+  end
+
+  describe ".enabled" do
+    it "should defualt to false" do
+      RouteCounter.config.enabled.should == false
+      RouteCounter.config.enabled?.should == false
+    end
+
+    it "should be able to be set" do
+      RouteCounter.config.enabled = true
+
+      RouteCounter.config.enabled.should == true
+      RouteCounter.config.enabled?.should == true
+    end
+  end
+
+end

data/spec/file_recorder_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'fileutils'
+
+describe RouteCounter::FileRecorder do
+  before(:each) do
+    RouteCounter::FileRecorder.clear!
+  end
+
+  describe "#action_visited" do
+    it "should write to file" do
+      controller = "comments"
+      action_name = "create"
+
+      current_path = File.join(RouteCounter::FileRecorder.parent_directory, "current")
+      check_path = File.join(current_path, "comments", "create")
+
+      File.exists?(check_path).should == false
+
+      RouteCounter::FileRecorder.action_visited(controller, action_name)
+
+      File.exists?(check_path).should == true
+      File.read(check_path).should == 'X'
+
+      RouteCounter::FileRecorder.action_visited(controller, action_name)
+
+      File.read(check_path).should == 'XX'
+
+      paths = RouteCounter::FileRecorder.actions_visited
+      paths.should == { "comments#create" => 2 }
+
+      RouteCounter::FileRecorder.action_visited("engine/comments", "create")
+      paths = RouteCounter::FileRecorder.actions_visited
+      paths.should == { "comments#create" => 2, "engine/comments#create" => 1 }
+
+      File.exist?(current_path).should == true
+
+      paths = RouteCounter::FileRecorder.rotate!
+      paths.should == { "comments#create" => 2, "engine/comments#create" => 1 }
+
+      File.exist?(current_path).should == false
+    end
+  end
+end

data/spec/redis_recorder_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe RouteCounter::RedisRecorder do
+  before(:each) do
+    @redis = RouteCounter.config.redis
+    RouteCounter::RedisRecorder.clear!
+  end
+
+  describe "#action_visited" do
+    it "should write to file" do
+      controller = "comments"
+      action_name = "create"
+
+      key = "route_counter:current"
+      action_key = "#{controller}##{action_name}"
+      @redis.exists(key).should == false
+
+      RouteCounter::RedisRecorder.action_visited(controller, action_name)
+
+      @redis.exists(key).should == true
+      @redis.hget(key, action_key).to_i.should == 1
+
+      RouteCounter::RedisRecorder.action_visited(controller, action_name)
+
+      @redis.hget(key, action_key).to_i.should == 2
+
+      paths = RouteCounter::RedisRecorder.actions_visited
+      paths.should == { "comments#create" => 2 }
+
+      RouteCounter::RedisRecorder.action_visited("engine/comments", "create")
+      paths = RouteCounter::RedisRecorder.actions_visited
+      paths.should == { "comments#create" => 2, "engine/comments#create" => 1 }
+
+      @redis.exists(key).should == true
+
+      RouteCounter::RedisRecorder.clear!
+
+      @redis.exists(key).should == false
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'route_counter'
+
+begin
+  require 'byebug'
+
+  module Kernel
+    alias :debugger :byebug
+  end
+
+rescue LoadError => e
+  # byebug isn't installed - no debugging here!
+end
+
+
+RSpec.configure do |config|
+  config.mock_framework = :rspec
+  
+  config.before(:each) do
+    RouteCounter.send(:reset)
+    RouteCounter.config.directory = File.expand_path("tmp/recorder")
+  end
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: route_counter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Brian Leonard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Helps you to find unused Rails routes
+email:
+- brian@bleonard.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/route_counter.rb
+- lib/route_counter/config.rb
+- lib/route_counter/console_formatter.rb
+- lib/route_counter/file_recorder.rb
+- lib/route_counter/middleware.rb
+- lib/route_counter/redis_recorder.rb
+- lib/route_counter/snapshot.rb
+- lib/route_counter/tasks.rb
+- lib/route_counter/version.rb
+- route_counter.gemspec
+- spec/config_spec.rb
+- spec/file_recorder_spec.rb
+- spec/redis_recorder_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/taskrabbit/route_counter
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Monitors the usage of your routes
+test_files:
+- spec/config_spec.rb
+- spec/file_recorder_spec.rb
+- spec/redis_recorder_spec.rb
+- spec/spec_helper.rb
+has_rdoc: