rails_routes_analyzer 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9583c3be5fc1f04a24b558d4ff440fbd07a74126
+  data.tar.gz: 8ae1e79bd2f253902b087d950bb77a8b529de713
+SHA512:
+  metadata.gz: a39ca46f44f864fcc6a25dd39141ba1cef9cd67c2a561078356d7359bf8f5437e2105ddca5dc879110abb4d81b642326faadc49e6d801d7c07fc786ab1b2b412
+  data.tar.gz: c7eb4f526012dbcce947293f63d2d99eca76fd4c86400d32c0c357b2c351cf5a3dc6d1cd9d03a77d82799f08d3a421d4bf061bfa92f0b54c399e17ec0cb78a0a

data/.autotest

@@ -0,0 +1,6 @@
+require 'autotest/restart'
+require "autotest/suffix"
+
+Autotest.add_hook :initialize do |at|
+  at.testlib = "minitest/autorun"
+end

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/Gemfile*.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/test/dummy/test.log
+/.byebug_history

data/.travis.yml

@@ -0,0 +1,17 @@
+sudo: false
+language: ruby
+cache: bundler
+bundler_args: --quiet
+rvm:
+  - 2.1.10
+  - 2.2.3
+  - 2.3.1
+gemfile:
+  - Gemfile_3.2
+  - Gemfile_4.2
+  - Gemfile
+matrix:
+  exclude:
+  - rvm: 2.1.10
+    gemfile: Gemfile
+before_install: gem install bundler -v 1.13.6

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rails-routes-analyzer.gemspec
+gemspec
+
+gem 'rails', '~> 5.0'

data/Gemfile_3.2

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rails-routes-analyzer.gemspec
+gemspec
+
+gem 'rails', '~> 3.2'

data/Gemfile_4.2

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rails-routes-analyzer.gemspec
+gemspec
+
+gem 'rails', '~> 4.2'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Bear Metal OÜ
+
+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,60 @@
+[![Build Status](https://travis-ci.org/bear-metal/rails_routes_analyzer.svg)](https://travis-ci.org/bear-metal/rails_routes_analyzer)
+
+Adds rake tasks to detect extraneous routes and unreachable controller actions Ruby on Rails applications. It's also able to provide suggestions on how to change routes.rb to avoid defining dead routes and can generate an annotated version of a route file with suggestions for each line added as comments.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rails_routes_analyzer'
+```
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+``` sh
+rake routes:dead
+```
+
+Without any additional options this will scan all the routes and check for a matching action for each. For single routes created with methods such as `get' or `post' it will tell you when that line could be removed.
+
+For multi-route calls like `resource' and `resources' it can also let you know if and how to set the :except or :only parameter to better match the actions a controller actually provides. When suggesting :only/:except by default the one that provides a shorter list will be used.
+
+For complex cases where for example a routes are created in a loop for multiple controllers a suggestion will be provided for each iteration but only if that specific iteration created a dead route. Every such suggestion will identify the exact controller to which it applies.
+
+``` sh
+rake routes:annotate_dead [ANNOTATE=path/to/routes.rb]
+```
+
+Will output an annotated version of config/routes.rb or any other routes file as provided in the ANNOTATE parameter.
+
+
+#### Additional options:
+
+* ONLY\_ONLY=1 - suggestions for resource routes will only generate "only:" regardless of how many elements are listed.
+* ONLY\_EXCEPT=1 - suggestions for resource routes will only generate "except:" regardless of how many elements are listed.
+* VERBOSE=1 - more verbosity, currently this means listing which non-existing actions a given call provides routes for.
+
+```sh
+rake routes:missing
+```
+
+#### Additional options:
+
+Lists all action methods for all controllers which have no route pointing to them. Uses the (maybe not so well known) ActionController#Base.action\_methods method which usually returns a list of all public methods of the controller class excluding any special Rails provided methods. To make the output of ActionController#Base.action\_methods it would be ideal to try to make all application-provided controller methods non-public if they are not meant to be callable as an action. Alternatively it's also possible (but less desirable) to override the action\_methods call in any controller class to explicitly remove mis-characterised methods.
+
+* STRICT=1 - causes controller base class provided public methods to be considered as actions for a subclass controller and thus reported as errors if they lack routes. Enabling this can generate a lot of noise for applications that have public non-actions in a controller base class.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/bear-metal/rails_routes_analyzer.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+Copyright (c) 2016 [Bear Metal](http://bearmetal.eu)

data/Rakefile

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

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rails/routes/analyzer"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rails_routes_analyzer.rb

@@ -0,0 +1,7 @@
+require "rails_routes_analyzer/version"
+require "rails_routes_analyzer/rails_routes_analyzer"
+require "rails_routes_analyzer/route_interceptor"
+require "rails_routes_analyzer/route_issue"
+require "rails_routes_analyzer/route_analysis"
+require "rails_routes_analyzer/route_file_annotator"
+

data/lib/rails_routes_analyzer/rails_routes_analyzer.rb

@@ -0,0 +1,46 @@
+require 'rails/railtie'
+
+module RailsRoutesAnalyzer
+
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      load File.join(File.dirname(__FILE__), '../tasks/rails_routes_analyzer.rake')
+    end
+  end
+
+  MULTI_METHODS = %w[resource resources].freeze
+  SINGLE_METHODS = %w[match get head post patch put delete options root].freeze
+  ROUTE_METHODS = (MULTI_METHODS + SINGLE_METHODS).freeze
+
+  def self.get_full_filename(filename)
+    return filename.to_s if filename.to_s.starts_with?('/')
+    Rails.root.join(filename).to_s
+  end
+
+  RESOURCE_ACTIONS = [:index, :create, :new, :show, :update, :destroy, :edit]
+
+  def self.identify_route_issues
+    RouteAnalysis.new
+  end
+
+  def self.get_all_defined_routes
+    identify_route_issues[:implemented_routes]
+  end
+
+  def self.get_all_action_methods(ignore_parent_provided: true)
+    [].tap do |result|
+      ApplicationController.descendants.each do |controller_class|
+        action_methods = controller_class.action_methods
+
+        if ignore_parent_provided && (super_class_actions = controller_class.superclass.try(:action_methods)).present?
+          action_methods -= super_class_actions
+        end
+
+        action_methods.each do |action_method|
+          result << [controller_class.name, action_method.to_sym]
+        end
+      end
+    end
+  end
+
+end

data/lib/rails_routes_analyzer/route_analysis.rb

@@ -0,0 +1,131 @@
+module RailsRoutesAnalyzer
+
+  class RouteAnalysis
+    attr_accessor :app, :verbose, :only_only, :only_except
+    attr_accessor :route_log
+    attr_writer :all_issues
+
+    def initialize(app: Rails.application, verbose: false, only_only: false, only_except: false)
+      self.app         = app
+      self.verbose     = verbose
+      self.only_only   = only_only
+      self.only_except = only_except
+
+      analyze!
+    end
+
+    def analyze!
+      app.eager_load! # all controller classes need to be loaded
+
+      ::ActionDispatch::Routing::Mapper::Mapping.prepend RouteInterceptor
+
+      RouteInterceptor.route_log.clear
+
+      app.reload_routes!
+
+      all_issues = []
+
+      RouteInterceptor.route_data.each do |(file_location, route_creation_method, controller_name), action_names|
+        controller_class_name = "#{controller_name}_controller".camelize
+
+        action_names = action_names.uniq.sort
+
+        opts = {
+          file_location:         file_location,
+          route_creation_method: route_creation_method,
+          controller_name:       controller_name,
+          controller_class_name: controller_class_name,
+          action_names:          action_names,
+        }
+
+        controller = nil
+        begin
+          controller = Object.const_get(controller_class_name)
+        rescue LoadError, RuntimeError, NameError => e
+          all_issues << RouteIssue.new(opts.merge(type: :no_controller, error: e.message))
+          next
+        end
+
+        if controller.nil?
+          all_issues << RouteIssue.new(opts.merge(type: :no_controller))
+          next
+        end
+
+        present, missing = action_names.partition {|name| controller.action_methods.include?(name.to_s) }
+        extra = action_names - RESOURCE_ACTIONS
+
+        if present.any?
+          all_issues << RouteIssue.new(opts.merge(type: :non_issue, present_actions: present))
+        end
+
+        if SINGLE_METHODS.include?(route_creation_method)
+          # NOTE a single call like 'get' can add multiple actions if called in a loop
+          if missing.present?
+            all_issues << RouteIssue.new(opts.merge(type: :no_action, missing_actions: missing))
+          end
+
+          next
+        end
+
+        next if missing.empty? # Everything is perfect
+
+        if present.sort == RESOURCE_ACTIONS.sort
+          unless missing.empty?
+            raise "shouldn't get all methods being present and missing at the same time: #{present.inspect} #{missing.inspect}"
+          end
+          next
+        end
+
+        suggested_param = if (present.size < 4 || only_only) && !only_except
+          "only: [#{present.sort.map {|x| ":#{x}" }.join(', ')}]"
+        else
+          "except: [#{(RESOURCE_ACTIONS - present).sort.map {|x| ":#{x}" }.join(', ')}]"
+        end
+
+        if verbose
+          verbose_message = "This route currently covers unimplemented actions: [#{missing.sort.map {|x| ":#{x}" }.join(', ')}]"
+        end
+
+        all_issues << RouteIssue.new(opts.merge(type: :resources, suggested_param: suggested_param, verbose_message: verbose_message))
+      end
+
+      self.route_log = RouteInterceptor.route_log.dup
+      self.all_issues = all_issues
+    end
+
+    def all_issues
+      @all_issues || []
+    end
+
+    def issues
+      all_issues.select(&:issue?)
+    end
+
+    def non_issues
+      all_issues.reject(&:issue?)
+    end
+
+    def all_unique_issues_file_names
+      all_issues.map { |issue| issue.full_filename }.uniq.sort
+    end
+
+    def unique_issues_file_names
+      issues.map { |issue| issue.full_filename }.uniq.sort
+    end
+
+    def all_issues_for_file_name(full_filename)
+      all_issues.select { |issue| issue.full_filename == full_filename.to_s }
+    end
+
+    def implemented_routes
+      Set.new.tap do |implemented_routes|
+        non_issues.each do |non_issue|
+          non_issue.present_actions.each do |action|
+            implemented_routes << [non_issue.controller_class_name, action]
+          end
+        end
+      end
+    end
+  end
+
+end

data/lib/rails_routes_analyzer/route_file_annotator.rb

@@ -0,0 +1,74 @@
+module RailsRoutesAnalyzer
+
+  class RouteFileAnnotator
+    def initialize(analysis: RailsRoutesAnalyzer::RouteAnalysis.new)
+      @analysis = analysis
+    end
+
+    def annotated_file_content(route_filename)
+      relevant_issues = @analysis.all_issues_for_file_name(route_filename)
+
+      if relevant_issues.none?(&:issue?)
+        log_notice { "Didn't find any route issues for file: #{route_filename}, only have references to: #{@analysis.all_unique_issues_file_names.join(', ')}" }
+      end
+
+      log_notice { "Annotating #{route_filename}" }
+
+      lines = File.readlines(route_filename)
+      issue_map = relevant_issues.group_by { |issue| issue.line_number }
+
+      "".tap do |output|
+        File.readlines(route_filename).each_with_index do |line, index|
+          suggestion = combined_suggestion_for(issue_map[index + 1])
+
+          if suggestion.present?
+            output << line.sub(/( # SUGGESTION.*)?$/, " # SUGGESTION #{suggestion}")
+          else
+            output << line
+          end
+        end
+      end
+    end
+
+    def log_notice(message=nil, &block)
+      return if ENV['RAILS_ENV'] == 'test'
+      message ||= block.call if block
+      STDERR.puts "# #{message}" if message.present?
+    end
+
+    def combined_suggestion_for(all_issues)
+      return if all_issues.nil? || all_issues.none?(&:issue?)
+
+      issues, non_issues = all_issues.partition(&:issue?)
+
+      context = {
+        non_issues: non_issues.present?,
+        num_controllers: all_issues.map(&:controller_class_name).uniq.count,
+      }
+
+      issues.map { |issue| issue.suggestion(**context) }.join(', ')
+    end
+
+    def annotate_routes_file(filename)
+      filenames = @analysis.unique_issues_file_names
+
+      if filename.blank?
+        if filenames.size > 1
+          STDERR.puts "Please specify file to annotate with ANNOTATE='path/routes.rb' as you have more than one:\n#{filenames.join("\n  ")}"
+          exit 1
+        end
+        filename = filenames.first
+      end
+
+      filename = RailsRoutesAnalyzer.get_full_filename(filename)
+
+      unless File.exists?(filename)
+        STDERR.puts "Can't routes find file: #{filename}"
+        exit 1
+      end
+
+      puts annotated_file_content(filename)
+    end
+  end
+
+end

data/lib/rails_routes_analyzer/route_interceptor.rb

@@ -0,0 +1,82 @@
+require 'rails'
+
+module RailsRoutesAnalyzer
+
+  # Plugs into ActionDispatch::Routing::Mapper::Mapping to help get detailed information
+  # on which route was generated, exactly where and if there is a matching controller action
+  module RouteInterceptor
+    ROUTE_METHOD_REGEX = /action_dispatch\/routing\/mapper.rb:[0-9]+:in `(#{Regexp.union(*::RailsRoutesAnalyzer::ROUTE_METHODS)})'\z/
+
+    def self.route_data
+      {}.tap do |result|
+        route_log.each do |(location, controller_name, action, request_methods)|
+          (result[location] ||= []) << action
+        end
+      end
+    end
+
+    def self.route_log
+      @route_log ||= []
+    end
+
+    # Finds the most interesting Rails.root file from the backtrace that called a method in mapper.rb
+    def get_routes_rb_location
+      bt = caller
+      base = 0
+      while true
+        index = bt[base..-1].index {|l| l =~ ROUTE_METHOD_REGEX }
+        return "" if index.nil?
+
+        next_line = bt[base + index + 1]
+
+        if next_line =~ /action_dispatch\/routing\/mapper.rb/
+          base += index + 1
+          next
+        else
+          file_location = next_line[/:?\A#{Rails.root}\/(.*:[0-9]+)/, 1] || next_line
+
+          bt[base + index] =~ ROUTE_METHOD_REGEX
+          route_creation_method = $1
+
+          return [file_location, route_creation_method]
+        end
+      end
+    end
+
+    if Rails.version =~ /\A3[.]/
+      def initialize(*args)
+        super.tap do
+          record_route(@options[:controller], @options[:action], conditions[:request_method])
+        end
+      end
+    elsif Rails.version =~ /\A4\./
+      def initialize(*args)
+        super.tap do
+          record_route(@defaults[:controller], @defaults[:action], conditions[:request_method])
+        end
+      end
+    else # Rails 5+
+      def initialize(*args)
+        super.tap do
+          record_route(@defaults[:controller], @defaults[:action], request_method.map(&:verb))
+        end
+      end
+    end
+
+    def record_route(controller_name, action, request_methods)
+      return unless controller_name && action
+
+      location = get_routes_rb_location + [controller_name]
+
+      if location[0].nil?
+        puts "Failed to find call location for: #{controller_name}/#{action}"
+      else
+        record = [location, controller_name, action.to_sym, request_methods]
+
+        RouteInterceptor.route_log << record
+      end
+    end
+
+  end
+
+end

data/lib/rails_routes_analyzer/route_issue.rb

@@ -0,0 +1,109 @@
+module RailsRoutesAnalyzer
+
+  class RouteIssue < Hash
+    %i[
+      action
+      action_names
+      missing_actions
+      present_actions
+      controller_class_name
+      controller_name
+      error
+      file_location
+      route_creation_method
+      suggested_param
+      type
+      verbose_message
+    ].each do |name|
+      define_method(name) { self[name] }
+    end
+
+    def initialize(opts={})
+      self.update(opts)
+    end
+
+    def issue?
+      type != :non_issue
+    end
+
+    def resource?
+      type == :resources
+    end
+
+    def full_filename
+      RailsRoutesAnalyzer.get_full_filename(file_location.sub(/:[0-9]*\z/, ''))
+    end
+
+    def line_number
+      file_location[/:([0-9]+)\z/, 1].to_i
+    end
+
+    def human_readable
+      case self[:type]
+      when :non_issue
+        ''
+      when :no_controller
+        "`#{route_creation_method}' call at #{file_location} there is no controller: #{controller_class_name} for '#{controller_name}' (actions: #{action_names.inspect})".tap do |msg|
+          msg << " error: #{error}" if error.present?
+        end
+      when :no_action
+        missing_actions.map do |action|
+          "`#{route_creation_method} :#{action}' call at #{file_location} there is no matching action in #{controller_class_name}"
+        end.tap do |result|
+          return nil if result.size == 0
+          return result[0] if result.size == 1
+        end
+      when :resources
+        "`#{route_creation_method}' call at #{file_location} for #{controller_class_name} should use #{suggested_param}"
+      else
+        raise ArgumentError, "Unknown issue_type: #{self[:type].inspect}"
+      end.tap do |message|
+        message << "| #{verbose_message}" if verbose_message
+      end
+    end
+
+    def suggestion(non_issues:, num_controllers:)
+      case self[:type]
+      when :non_issue
+        nil
+      when :no_controller
+        if non_issues
+          "remove case for #{controller_class_name} as it doesn't exist"
+        else
+          "delete, #{controller_class_name} not found"
+        end
+      when :no_action
+        actions = format_actions(missing_actions)
+        if non_issues
+          "remove case#{'s' if missing_actions.size > 1} for #{actions}"
+        else
+          "delete line, #{actions} matches nothing"
+        end.tap do |message|
+          message << " for controller #{controller_class_name}" if num_controllers > 1
+        end
+      when :resources
+        "use #{suggested_param}".tap do |message|
+          if num_controllers > 1
+            message << " only for #{controller_class_name}"
+          end
+        end
+      else
+        raise ArgumentError, "Unknown issue_type: #{self[:type].inspect}"
+      end.tap do |message|
+        message << "| #{verbose_message}" if verbose_message
+      end
+    end
+
+    def format_actions(actions)
+      case actions.size
+      when 0
+      when 1
+        ":#{actions.first}"
+      else
+        list = actions.map { |action| ":#{action}" }.sort.join(', ')
+        "[#{list}]"
+      end
+    end
+  end
+
+end

data/lib/rails_routes_analyzer/version.rb

@@ -0,0 +1,3 @@
+module RailsRoutesAnalyzer
+  VERSION = "1.0.1"
+end

data/lib/tasks/rails_routes_analyzer.rake

@@ -0,0 +1,62 @@
+namespace :routes do
+
+  desc 'Scan for dead-end routes including bad map.resource(s) :only/:except parameters'
+  task dead: :environment do
+    analysis = RailsRoutesAnalyzer::RouteAnalysis.new(
+                 verbose:     !ENV['VERBOSE'].nil?,
+                 only_only:   !ENV['ONLY_ONLY'].nil?,
+                 only_except: !ENV['ONLY_EXCEPT'].nil?)
+
+    if analysis.issues.empty?
+      puts "No route issues found"
+      return
+    end
+
+    analysis.issues.each do |issue|
+      puts issue.human_readable
+    end
+  end
+
+  desc "Output a routes file with suggested modifications in comments (NOTE: doesn't touch the original file)"
+  task annotate_dead: :environment do
+    annotator = RailsRoutesAnalyzer::RouteFileAnnotator.new
+    annotator.annotate_routes_file(ENV['ANNOTATE'])
+  end
+
+  desc 'Scan for controller action methods that are missing a route (pass STRICT=1 to account for inherited actions)'
+  task missing: :environment do
+    analysis = RailsRoutesAnalyzer::RouteAnalysis.new
+    implemented_routes = analysis.implemented_routes
+    all_action_methods = RailsRoutesAnalyzer.get_all_action_methods(ignore_parent_provided: ENV['STRICT'].blank?)
+
+    missing = all_action_methods.to_a - implemented_routes.to_a
+
+    if missing.any?
+      puts "NOTE Some gems, such as Devise, are expected to provide actions that have no matching"
+      puts "     routes in case a particular feature is not enabled, this is normal and expected."
+      puts "NOTE If any non-action methods are reported please consider making those non-public"
+      puts "     or using another solution that would make #action_methods not return those."
+      puts ""
+
+      unused_controllers = Set.new(all_action_methods.to_a.map(&:first) - implemented_routes.to_a.map(&:first))
+
+      if unused_controllers.any?
+        puts "Controllers with no routes pointing to them:"
+        unused_controllers.to_a.sort.each do |controller_name|
+          puts "  #{controller_name}"
+        end
+        puts ""
+      end
+
+      puts "Actions without a route:"
+      missing.sort.each do |(controller_name, action_name)|
+        unless unused_controllers.include?(controller_name)
+          puts "  #{controller_name}::#{action_name}"
+        end
+      end
+    else
+      puts "There are no actions without a route"
+    end
+  end
+
+end

data/rails_routes_analyzer.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rails_routes_analyzer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rails_routes_analyzer"
+  spec.version       = RailsRoutesAnalyzer::VERSION
+  spec.authors       = ["Tarmo Tänav"]
+  spec.email         = ["tarmo@bearmetal.eu"]
+
+  spec.summary       = %q{Helps clean up rails routes}
+  #spec.description   = %q{}
+  spec.homepage      = "https://github.com/bear-metal/rails_routes_analyzer"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "rails", "~> 5.0"
+  spec.add_development_dependency "minitest-reporters", "~> 1.1.12"
+  spec.add_development_dependency "minitest-color", "~> 0.0.2"
+  spec.add_development_dependency "byebug"
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: rails_routes_analyzer
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Tarmo Tänav
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-11-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.12
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.12
+- !ruby/object:Gem::Dependency
+  name: minitest-color
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+- !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: 
+email:
+- tarmo@bearmetal.eu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".autotest"
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile_3.2
+- Gemfile_4.2
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/rails_routes_analyzer.rb
+- lib/rails_routes_analyzer/rails_routes_analyzer.rb
+- lib/rails_routes_analyzer/route_analysis.rb
+- lib/rails_routes_analyzer/route_file_annotator.rb
+- lib/rails_routes_analyzer/route_interceptor.rb
+- lib/rails_routes_analyzer/route_issue.rb
+- lib/rails_routes_analyzer/version.rb
+- lib/tasks/rails_routes_analyzer.rake
+- rails_routes_analyzer.gemspec
+homepage: https://github.com/bear-metal/rails_routes_analyzer
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: Helps clean up rails routes
+test_files: []