rails_routes_analyzer 1.0.4 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 67a79ca7d35119c2df16b62e017573f47d933bd8
-  data.tar.gz: 38eac12198817bb09b77a7915b744b627fe54ac9
+  metadata.gz: 6438d7f464a7b4bfe625d5d7b0c046bb7dec19b6
+  data.tar.gz: e85d81221ecd342ec9b4a8ca995b9e9c4955586e
 SHA512:
-  metadata.gz: 44460432c3912943b80b26ae2abd1740c7b44b7e9b0d8885d91ad011ec8a02732e945df6b5dc2509d757c4bc5e1223e1703ff4dfff2bcc377db816d2d982f2b9
-  data.tar.gz: fa4b03e5eea3da9cd729bd9f60349c37cea6e789a9cbffa85d2548c479bab840f829ab905b4b702530555e030d9ab43ef587ae054f66b4d12c0ba2584b43e323
+  metadata.gz: d0a0f433be53c34ca4b61fc3167b0913807b1a967096c76dc903c52cb796b91ddb11c5088f27e6f201c81bc27115e972e5b58016304f15e5a36839fbbdf16e35
+  data.tar.gz: 8a6d61768c8ee3c80e513e7d05f8b98fed8ee70b3ba3b93ddba5268424bd32fb16f6126ac632db321cbfe664272d2dfb75c82aae619b64dd90de7920fdf10008

data/.autotest

@@ -3,4 +3,7 @@ require "autotest/suffix"
 
 Autotest.add_hook :initialize do |at|
   at.testlib = "minitest/autorun"
+
+  at.add_exception 'test/dummy/tmp'
+  at.add_exception 'test/dummy/routes_bad-for-git-test.rb'
 end

data/.gitignore

@@ -9,4 +9,6 @@
 /spec/reports/
 /tmp/
 /test/dummy/test.log
+/test/dummy/tmp
 /.byebug_history
+/coverage

data/.rubocop.yml

@@ -0,0 +1,141 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2016-12-04 10:48:23 +0200 using RuboCop version 0.46.0.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 17
+Metrics/AbcSize:
+  Max: 35
+
+# Offense count: 3
+# Configuration parameters: CountComments.
+Metrics/BlockLength:
+  Max: 30
+
+# Offense count: 6
+# Configuration parameters: CountComments.
+Metrics/ClassLength:
+  Max: 182
+
+# Offense count: 4
+Metrics/CyclomaticComplexity:
+  Max: 9
+
+# Offense count: 189
+# Configuration parameters: AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
+# URISchemes: http, https
+Metrics/LineLength:
+  Max: 236
+
+# Offense count: 25
+# Configuration parameters: CountComments.
+Metrics/MethodLength:
+  Max: 44
+
+# Offense count: 1
+# Configuration parameters: CountKeywordArgs.
+Metrics/ParameterLists:
+  Max: 7
+
+# Offense count: 3
+Metrics/PerceivedComplexity:
+  Max: 11
+
+# Offense count: 1
+# Cop supports --auto-correct.
+Style/AlignArray:
+  Exclude:
+    - 'test/rails_routes_analyzer/route_analysis_test.rb'
+
+# Offense count: 12
+Style/Documentation:
+  Exclude:
+    - 'spec/**/*'
+    - 'test/**/*'
+    - 'lib/rails_routes_analyzer/action_analysis.rb'
+    - 'lib/rails_routes_analyzer/gem_manager.rb'
+    - 'lib/rails_routes_analyzer/parameter_handler.rb'
+    - 'lib/rails_routes_analyzer/rails_routes_analyzer.rb'
+    - 'lib/rails_routes_analyzer/railtie.rb'
+    - 'lib/rails_routes_analyzer/route_analysis.rb'
+    - 'lib/rails_routes_analyzer/route_file_annotator.rb'
+    - 'lib/rails_routes_analyzer/route_issue/base.rb'
+    - 'lib/rails_routes_analyzer/route_issue/no_action.rb'
+    - 'lib/rails_routes_analyzer/route_issue/no_controller.rb'
+    - 'lib/rails_routes_analyzer/route_issue/resources.rb'
+
+# Offense count: 15
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle, SupportedStyles.
+# SupportedStyles: empty_lines, empty_lines_except_namespace, empty_lines_special, no_empty_lines
+Style/EmptyLinesAroundClassBody:
+  Enabled: false
+
+# Offense count: 29
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle, SupportedStyles.
+# SupportedStyles: empty_lines, empty_lines_except_namespace, empty_lines_special, no_empty_lines
+Style/EmptyLinesAroundModuleBody:
+  Enabled: false
+
+# Offense count: 9
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle, SupportedStyles.
+# SupportedStyles: compact, expanded
+Style/EmptyMethod:
+  Enabled: false
+
+# Offense count: 2
+# Cop supports --auto-correct.
+# Configuration parameters: SupportedStyles, IndentationWidth.
+# SupportedStyles: special_inside_parentheses, consistent, align_brackets
+Style/IndentArray:
+  EnforcedStyle: consistent
+
+# Offense count: 1
+# Configuration parameters: EnforcedStyle, SupportedStyles.
+# SupportedStyles: module_function, extend_self
+Style/ModuleFunction:
+  EnforcedStyle: extend_self
+
+# Offense count: 7
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle, SupportedStyles, AllowInnerSlashes.
+# SupportedStyles: slashes, percent_r, mixed
+Style/RegexpLiteral:
+  EnforcedStyle: mixed
+
+# Offense count: 337
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle, SupportedStyles, ConsistentQuotesInMultiline.
+# SupportedStyles: single_quotes, double_quotes
+Style/StringLiterals:
+  Enabled: false
+
+# Offense count: 10
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyleForMultiline, SupportedStyles.
+# SupportedStyles: comma, consistent_comma, no_comma
+Style/TrailingCommaInArguments:
+  Enabled: false
+
+# Offense count: 13
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyleForMultiline, SupportedStyles.
+# SupportedStyles: comma, consistent_comma, no_comma
+Style/TrailingCommaInLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+
+# Configuration parameters: EnforcedStyle, SupportedStyles.
+# SupportedStyles: snake_case, normalcase, non_integer
+Style/VariableNumber:
+  Enabled: false
+
+
+AllCops:
+  Exclude:
+    - 'test/dummy/routes*.rb'
+    - 'test/dummy/tmp/*.rb'

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016 Bear Metal OÜ
+Copyright (c) 2016 Tarmo Tänav, 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

data/README.md

@@ -1,6 +1,8 @@
 [![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.
+Adds rake tasks to detect extraneous routes and unreachable controller actions in Ruby on Rails applications. It's able to provide suggestions on how to change routes.rb to avoid defining dead routes.
+
+It can also add comments to routes files (even when there are multiple) to suggest fixes and for certain common patterns optionally apply those fixes automatically.
 
 ## Installation
 
@@ -27,32 +29,62 @@ For multi-route calls like `resource' and `resources' it can also let you know i
 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]
+rake routes:dead:annotate [ROUTES_FILE=path/to/routes.rb]
+rake routes:dead:fix      [ROUTES_FILE=path/to/routes.rb]
 
 # Best used like this:
-rake routes:annotate_dead > config/routest.rb.new
+rake routes:dead:annotate > config/routest.rb.new
 mv config/routes.rb.new config/routes.rb
 # And then update the file as requested in any SUGGESTION comments
 ```
 
-Will output an annotated version of config/routes.rb or any other routes file as provided in the ANNOTATE parameter.
-
+_routes:dead:annotate_ generates a commented version of a routes file. _routes:dead:fix_ generates a partly automatically fixed and partly commented version of a routes file. Without specifying a file in ROUTES_FILE parameter one is automatically picked provided that it is the only one that has problems, if there are more they will all be listed and a single name will have to be provided in the ROUTES_FILE 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
+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.
+ROUTES_VERBOSE=1 # more verbosity, currently this means listing which non-existing actions a given call provides routes for.
+```
+
+``` sh
+rake routes:dead:annotate:inplace [ROUTES_FILE=path/to/routes.rb]
+rake routes:dead:fix:inplace      [ROUTES_FILE=path/to/routes.rb]
+
+rake routes:dead:annotate:inplace[force] [ROUTES_FILE=path/to/routes.rb]
+rake routes:dead:fix:inplace[force]      [ROUTES_FILE=path/to/routes.rb]
+```
+
+Same as above but these commands change existing routes file content instead of printing it to standard output. By default they'll refuse to change a file if it's outside Rails root or has uncommited changes. To get around this protection set the ROUTES_FORCE=1 parameter.
+
 
 ```sh
-rake routes:missing
+rake actions:missing_route
+rake actions:missing_route[gems,modules,duplicates,full,metadata] # parameters can be combined in all ways
 ```
 
-#### Additional options:
+Lists all action methods for all controllers which have no route pointing to them. By default ignores methods coming from gems, included modules or inherited from a parent controller. Uses the ActionController#Base.action\_methods method which usually returns a list of all public methods of the controller class excluding any special Rails provided methods.
+
+Generally it's not a problem to have ActionController#Base.action\_methods list non-actions given Rails no longer uses default routes that would benefit from proper limits on what is and what isn't an action. However there is also no obvious reason to be unable to correct it and possibly be able to use the more accurate metadata somewhere else (such as this tool).
+
+The easiest way to remove non-actions from ActionController#Base.action\_methods is to make them protected or private. If that's not possible the other alternative is to override the action\_methods method itself and remove the relevant methods from the returned action list (this is more complicated and much more effort to keep updated.)
 
-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.
+```sh
+rake actions:list_all
+rake actions:list_all[gems,modules,duplicates,full,metadata] # parameters can be combined in all ways
+```
 
-* 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.
+#### Additional options:
+_(applies to both actions:missing\_route and actions:list\_all)_
+
+``` sh
+ROUTES_DUPLICATES=1 # report actions inherited from parent controllers (can generate a lot of noise)
+ROUTES_GEMS=1       # includes actions that appear to be implemented by gems
+ROUTES_MODULES=1    # includes public controller methods inherited from modules that are listed in action_methods
+ROUTES_FULL_PATH=1  # disables file path shortening
+ROUTES_METADATA=1   # lists collected data per action such as which gem it's from, if it's inherited from a superclass
+```
 
 ## Contributing
 
@@ -62,4 +94,4 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/bear-m
 
 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)
+Copyright (c) 2016 Tarmo Tänav, [Bear Metal OÜ](http://bearmetal.eu), 

data/Rakefile

@@ -7,4 +7,4 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
-task :default => :test
+task default: :test

data/lib/rails_routes_analyzer.rb

@@ -1,7 +1,8 @@
-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"
+require_relative "rails_routes_analyzer/version"
+require_relative "rails_routes_analyzer/railtie"
+require_relative "rails_routes_analyzer/rails_routes_analyzer"
 
+require_relative "rails_routes_analyzer/parameter_handler"
+require_relative "rails_routes_analyzer/action_analysis"
+require_relative "rails_routes_analyzer/route_analysis"
+require_relative "rails_routes_analyzer/route_file_annotator"

data/lib/rails_routes_analyzer/action_analysis.rb

@@ -0,0 +1,276 @@
+require_relative 'gem_manager'
+
+require 'active_support/descendants_tracker'
+require 'active_support/core_ext/class/subclasses'
+require 'active_support/core_ext/string/strip'
+
+module RailsRoutesAnalyzer
+  MAX_ACTION_LENGTH = 30 # Don't align action names longer than this
+
+  class ActionMethod < Hash
+    # is_inherited - action is inherited from a parent controller
+    # from_gem     - action is implemented in a gem
+    # from_module  - action implementation is in a module
+    %i(
+      controller_name
+      action_name
+      route_missing
+      source_location
+      is_inherited
+      from_gem
+      from_module
+      owner
+    ).each do |name|
+      define_method(name) { self[name] }
+    end
+
+    def initialize(opts = {})
+      update(opts)
+    end
+
+    def controller_class
+      @controller_class ||= controller_name.constantize
+    end
+
+    def needs_reporting?(report_duplicates:, report_gems:, report_modules:, report_routed:, **)
+      (route_missing?     || report_routed)     \
+        && (!inherited?   || report_duplicates) \
+        && (!from_gem?    || report_gems)       \
+        && (!from_module? || report_modules)
+    end
+
+    def pretty(max_action_length: MAX_ACTION_LENGTH, metadata: false, **)
+      format("%-#{max_action_length}s @ %s", action_name, source_location).tap do |result|
+        if metadata
+          result << " "
+          result << pretty_metadata
+        end
+      end
+    end
+
+    def pretty_metadata
+      [
+        route_missing? ? "no-route"                : nil,
+        inherited?     ? "inherited:#{owner.name}" : nil,
+        from_gem?      ? "gem:#{from_gem}"         : nil,
+        from_module?   ? "module:#{owner.name}"    : nil,
+      ].compact.join(' ')
+    end
+
+    alias inherited?     is_inherited
+    alias route_missing? route_missing
+    alias from_gem?      from_gem
+    alias from_module?   from_module
+  end
+
+  class ActionAnalysis
+
+    attr_reader :all_action_methods, :unused_controllers, :options
+
+    # Options:
+    #  report_duplicates - report actions which the parent controller also has
+    #  report_gems       - report actions which are implemented by a gem
+    #  report_modules    - report actions inherited from modules
+    #  report_routed     - report all actions including those with a route
+    #  full_path         - skips shortening file paths
+    #  metadata          - include discovered metadata about actions
+    def initialize(route_analysis: RailsRoutesAnalyzer::RouteAnalysis.new,
+                   report_routed:     false,
+                   report_duplicates: false,
+                   report_gems:       false,
+                   report_modules:    false,
+                   full_path:         false,
+                   metadata:          false)
+
+      @options = {
+        report_routed:     report_routed,
+        report_duplicates: report_duplicates,
+        report_gems:       report_gems,
+        report_modules:    report_modules,
+        full_path:         full_path,
+        metadata:          metadata,
+      }
+
+      @all_action_methods = analyze_action_methods(route_analysis: route_analysis)
+
+      @by_controller = @all_action_methods.group_by(&:controller_class)
+      @unused_controllers = find_unused_controllers
+    end
+
+    def print_report
+      print_missing_routes_report_preamble unless options[:report_routed]
+      print_actions_report
+    end
+
+    def print_actions_report
+      @controller_reporting_cache = {}
+
+      report_actions_recursive
+    end
+
+    protected
+
+    def unused_actions_present?
+      @all_action_methods.any? do |action|
+        action.needs_reporting?(**options)
+      end
+    end
+
+    def actions_for(controller)
+      @by_controller[controller] || []
+    end
+
+    def actions_to_report(controller)
+      actions_for(controller).select do |action|
+        action.needs_reporting?(**options)
+      end.sort_by(&:action_name)
+    end
+
+    def report_actions_recursive(controllers = ActionController::Base.subclasses, level = 0)
+      controllers.each do |controller|
+        next unless controller_needs_reporting?(controller)
+
+        puts "#{'  ' * level}#{controller.name}"
+
+        if (actions = actions_to_report(controller)).any?
+          action_level = level + 1
+
+          if controller.subclasses.any? { |subclass| controller_needs_reporting?(subclass) }
+            puts "#{'  ' * action_level}Actions:"
+            action_level += 1
+          end
+
+          max_action_length = [MAX_ACTION_LENGTH, actions.map { |a| a.action_name.size }.max].min
+
+          actions.each do |action|
+            puts "#{'  ' * action_level}#{action.pretty(max_action_length: max_action_length, **options)}"
+          end
+        end
+
+        report_actions_recursive(controller.subclasses.sort_by(&:name), level + 1)
+      end
+    end
+
+    def controller_likely_from_gem?(controller)
+      actions_for(controller).all? { |action| action.from_gem? || action.from_module? || action.inherited? }
+    end
+
+    def controller_needs_reporting?(controller)
+      if @controller_reporting_cache.key?(controller)
+        return @controller_reporting_cache[controller]
+      end
+
+      @controller_reporting_cache[controller] = \
+        actions_to_report(controller).any? \
+        || controller.subclasses.any? { |subclass| controller_needs_reporting?(subclass) }
+    end
+
+    def find_unused_controllers
+      ActionController::Base.descendants.select do |controller|
+        controller_has_no_routes?(controller) \
+          && !default_controller?(controller) \
+          && (options[:report_gems] || !controller_likely_from_gem?(controller))
+      end
+    end
+
+    def default_controller?(controller)
+      defined?(::Rails::ApplicationController) && controller <= ::Rails::ApplicationController
+    end
+
+    def no_direct_routes_to?(controller)
+      actions_for(controller).all?(&:route_missing?)
+    end
+
+    def controller_has_no_routes?(controller)
+      no_direct_routes_to?(controller) \
+        && controller.subclasses.all? { |c| controller_has_no_routes?(c) }
+    end
+
+    def analyze_action_methods(route_analysis:)
+      implemented_routes = Set.new(route_analysis.implemented_routes)
+
+      [].tap do |result|
+        ActionController::Base.descendants.each do |controller|
+          next if default_controller?(controller)
+
+          action_methods = controller.action_methods.to_a.map(&:to_sym)
+
+          if (parent_controller = controller.superclass) == ActionController::Base
+            parent_controller = nil
+            parent_actions    = []
+          else
+            parent_actions    = parent_controller.action_methods.to_a.map(&:to_sym)
+          end
+
+          action_methods.each do |action_name|
+            controller_name = controller.name
+            source_location = get_source_location(controller, action_name)
+
+            owner = controller.instance_method(action_name).owner
+
+            # A very strong likelyhood is that if the method is not defined by a module
+            # it comes directly from any ActionController::Base subclass.
+            #
+            # This knowledge helps us ignore methods which might come for example from
+            # someone (possibly unwisely) including a helper directly into a controller.
+            from_module = owner.class == Module
+
+            is_inherited = parent_actions.include?(action_name) \
+                             && get_source_location(parent_controller, action_name) == source_location
+
+            route_missing = !implemented_routes.include?([controller_name, action_name])
+
+            sanitized_location = RailsRoutesAnalyzer.sanitize_source_location(source_location, options.slice(:full_path))
+
+            result << ActionMethod.new(
+              controller_name: controller_name,
+              action_name:     action_name,
+              is_inherited:    is_inherited,
+              route_missing:   route_missing,
+              source_location: sanitized_location,
+              from_gem:        GemManager.identify_gem(source_location),
+              owner:           owner,
+              from_module:     from_module,
+            )
+          end
+        end
+      end
+    end
+
+    def get_source_location(controller_class_or_name, action_name)
+      controller = controller_class_or_name
+      controller = controller.constantize if controller.is_a?(String)
+
+      controller.instance_method(action_name).source_location.join(':')
+    end
+
+    PREAMBLE_WARNING = <<-EOS.strip_heredoc.freeze
+      NOTE Some gems, such as Devise, are expected to provide actions that have no matching
+           routes in case a particular feature is not enabled, this is normal and expected.
+
+           If any non-action methods are reported please consider making these
+           private/protected or customize #action_methods to exclude them.
+
+      Actions without a route:
+
+    EOS
+
+    def print_missing_routes_report_preamble
+      unless unused_actions_present?
+        puts "There are no actions without a route"
+        return
+      end
+
+      if unused_controllers.present?
+        puts "Controllers with no routes pointing to them:"
+        unused_controllers.sort_by(&:name).each do |controller|
+          puts "  #{controller.name}"
+        end
+        puts ""
+      end
+
+      puts PREAMBLE_WARNING
+    end
+
+  end
+end