rails_routes_analyzer 1.0.4 → 2.0.0

data/lib/rails_routes_analyzer/gem_manager.rb

@@ -0,0 +1,52 @@
+module RailsRoutesAnalyzer
+  module GemManager
+    extend self
+
+    # Replaces gem locations in file paths with the name of the gem.
+    #
+    # @param location [String] full path to a ruby source file.
+    # @return [String] path to ruby source file with gem location replaced.
+    def clean_gem_path(location)
+      location.gsub(gem_path_prefix_cleanup_regex) do |val|
+        gem_path_prefix_replacements[val] || val
+      end
+    end
+
+    # Identifies a gem based on a location from a backtrace.
+    #
+    # @param location [String] full path to a source file possibly in a gem.
+    # @return [String] name of a gem.
+    def identify_gem(location)
+      gem_locations[location[gem_locations_regexp]]
+    end
+
+    private
+
+    # @return { String => String } mapping of gem path prefix to gem name.
+    def gem_path_prefix_replacements
+      @gem_path_prefix_replacements ||=
+        Gem.loaded_specs.values.each_with_object({}) do |spec, sum|
+          path = spec.full_gem_path.sub %r{/?\z}, '/'
+          sum[path] = "#{spec.name} @ "
+        end
+    end
+
+    # @return [Regexp] a regexp that matches all gem paths.
+    def gem_path_prefix_cleanup_regex
+      @gem_path_prefix_cleanup_regex ||=
+        /\A#{Regexp.union(gem_path_prefix_replacements.keys)}/
+    end
+
+    # @return {String=>String} mapping of gem path to gem name.
+    def gem_locations
+      @gem_locations ||= Gem.loaded_specs.values.each_with_object({}) do |spec, sum|
+        sum[spec.full_gem_path] = spec.name
+      end
+    end
+
+    # @return [Regexp] a regexp covering paths of all available gems.
+    def gem_locations_regexp
+      @gem_locations_regexp ||= /\A#{Regexp.union(gem_locations.keys)}/
+    end
+  end
+end

data/lib/rails_routes_analyzer/parameter_handler.rb

@@ -0,0 +1,41 @@
+module RailsRoutesAnalyzer
+  module ParameterHandler
+    def self.params_for_route_analysis(env = ENV)
+      {
+        only_only:   env['ONLY_ONLY'].present?,
+        only_except: env['ONLY_EXCEPT'].present?,
+        verbose:     env['ROUTES_VERBOSE'].present?,
+      }
+    end
+
+    def self.params_for_annotate(env = ENV, extras = [])
+      params_for_route_analysis.merge(
+        try_to_fix:     false,
+        allow_deleting: false,
+        force_overwrite: env['ROUTES_FORCE'].present? || extras.include?('force'),
+      )
+    end
+
+    def self.file_to_annotate(env = ENV)
+      env['ROUTES_FILE']
+    end
+
+    def self.params_for_fix(env = ENV, extras = [])
+      params_for_route_analysis.merge(
+        try_to_fix:     true,
+        allow_deleting: true,
+        force_overwrite: env['ROUTES_FORCE'].present? || extras.include?('force'),
+      )
+    end
+
+    def self.params_for_action_analysis(env = ENV, extras = [])
+      {
+        report_duplicates: env['ROUTES_DUPLICATES'].present? || extras.include?('duplicates'),
+        report_gems:       env['ROUTES_GEMS'].present?       || extras.include?('gems'),
+        report_modules:    env['ROUTES_MODULES'].present?    || extras.include?('modules'),
+        full_path:         env['ROUTES_FULL_PATH'].present?  || extras.include?('full'),
+        metadata:          env['ROUTES_METADATA'].present?   || extras.include?('metadata'),
+      }
+    end
+  end
+end

data/lib/rails_routes_analyzer/rails_routes_analyzer.rb

@@ -1,45 +1,84 @@
-require 'rails/railtie'
+require_relative 'gem_manager'
 
 module RailsRoutesAnalyzer
 
-  class Railtie < ::Rails::Railtie
-    rake_tasks do
-      load File.join(File.dirname(__FILE__), '../tasks/rails_routes_analyzer.rake')
+  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
+
+  class << self
+    # Converts Rails.root-relative filenames to be absolute.
+    def get_full_filename(filename)
+      return filename.to_s if filename.to_s.starts_with?('/')
+      Rails.root.join(filename).to_s
     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
+    # Shortens full file path, replacing Rails.root and gem path with
+    # appropriate short prefixes to make the file names look good.
+    def sanitize_source_location(source_location, full_path: false)
+      source_location.dup.tap do |clean_location|
+        unless full_path
+          clean_location.gsub! "#{Rails.root}/", './'
 
-  def self.get_full_filename(filename)
-    return filename.to_s if filename.to_s.starts_with?('/')
-    Rails.root.join(filename).to_s
-  end
+          clean_location.replace GemManager.clean_gem_path(clean_location)
+        end
+      end
+    end
 
-  RESOURCE_ACTIONS = [:index, :create, :new, :show, :update, :destroy, :edit]
+    def routes_dead(env)
+      params   = RailsRoutesAnalyzer::ParameterHandler.params_for_route_analysis(env)
+      analysis = RailsRoutesAnalyzer::RouteAnalysis.new(params)
 
-  def self.identify_route_issues
-    RouteAnalysis.new
-  end
+      analysis.print_report
+    end
 
-  def self.get_all_defined_routes
-    identify_route_issues[:implemented_routes]
-  end
+    def routes_dead_annotate(env)
+      routes_dead_annotate_common(env)
+    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
+    def routes_dead_annotate_inplace(env, extras)
+      routes_dead_annotate_common(env, extras, inplace: true)
+    end
 
-        if ignore_parent_provided && (super_class_actions = controller_class.superclass.try(:action_methods)).present?
-          action_methods -= super_class_actions
-        end
+    def routes_dead_fix(env)
+      routes_dead_fix_common(env)
+    end
 
-        action_methods.each do |action_method|
-          result << [controller_class.name, action_method.to_sym]
-        end
-      end
+    def routes_dead_fix_inplace(env, extras)
+      routes_dead_fix_common(env, extras, inplace: true)
+    end
+
+    def routes_actions_missing_route(env, extras)
+      routes_actions_common(env, extras, report_routed: false)
+    end
+
+    def routes_actions_list_all(env, extras)
+      routes_actions_common(env, extras, report_routed: true)
+    end
+
+    protected
+
+    def routes_dead_common(env, params, **opts)
+      annotator   = RailsRoutesAnalyzer::RouteFileAnnotator.new(params)
+      routes_file = RailsRoutesAnalyzer::ParameterHandler.file_to_annotate(env)
+
+      annotator.annotate_routes_file(routes_file, **opts)
+    end
+
+    def routes_dead_annotate_common(env, extras = [], **opts)
+      params = RailsRoutesAnalyzer::ParameterHandler.params_for_annotate(env, extras)
+      routes_dead_common(env, params, **opts)
+    end
+
+    def routes_dead_fix_common(env, extras = [], **opts)
+      params = RailsRoutesAnalyzer::ParameterHandler.params_for_fix(env, extras)
+      routes_dead_common(env, params, **opts)
+    end
+
+    def routes_actions_common(env, extras, **opts)
+      params = RailsRoutesAnalyzer::ParameterHandler.params_for_action_analysis(env, extras)
+      analysis = RailsRoutesAnalyzer::ActionAnalysis.new(params.merge(opts))
+      analysis.print_report
     end
   end
 

data/lib/rails_routes_analyzer/railtie.rb

@@ -0,0 +1,11 @@
+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
+
+end

data/lib/rails_routes_analyzer/route_analysis.rb

@@ -1,9 +1,15 @@
+require_relative 'route_line'
+require_relative 'route_call'
+require_relative 'route_issue'
+require_relative 'route_interceptor'
+
 module RailsRoutesAnalyzer
 
+  RESOURCE_ACTIONS = [:index, :create, :new, :show, :update, :destroy, :edit].freeze
+
   class RouteAnalysis
     attr_accessor :app, :verbose, :only_only, :only_except
-    attr_accessor :route_log
-    attr_writer :all_issues
+    attr_accessor :route_log, :route_lines, :route_calls
 
     def initialize(app: Rails.application, verbose: false, only_only: false, only_except: false)
       self.app         = app
@@ -14,7 +20,13 @@ module RailsRoutesAnalyzer
       analyze!
     end
 
-    def analyze!
+    def clear_data
+      self.route_lines = []
+      self.route_calls = []
+      self.route_log   = []
+    end
+
+    def prepare_for_analysis
       app.eager_load! # all controller classes need to be loaded
 
       ::ActionDispatch::Routing::Mapper::Mapping.prepend RouteInterceptor
@@ -22,110 +34,135 @@ module RailsRoutesAnalyzer
       RouteInterceptor.route_log.clear
 
       app.reload_routes!
+    end
 
-      all_issues = []
+    def analyze!
+      clear_data
+      prepare_for_analysis
 
       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 = {
+        analyse_route_call(
           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
+          action_names:          action_names.uniq.sort,
+        )
+      end
 
-        if controller.nil?
-          all_issues << RouteIssue.new(opts.merge(type: :no_controller))
-          next
-        end
+      route_log.concat RouteInterceptor.route_log
+      generate_route_lines
+    end
 
-        present, missing = action_names.partition {|name| controller.action_methods.include?(name.to_s) }
-        extra = action_names - RESOURCE_ACTIONS
+    def generate_route_lines
+      calls_per_line = route_calls.group_by do |record|
+        [record.full_filename, record.line_number]
+      end
 
-        if present.any?
-          all_issues << RouteIssue.new(opts.merge(type: :non_issue, present_actions: present))
-        end
+      calls_per_line.each do |(full_filename, line_number), records|
+        route_lines << RouteLine.new(full_filename: full_filename,
+                                     line_number:   line_number,
+                                     records:       records)
+      end
+    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
+    def analyse_route_call(**kwargs)
+      controller_class_name = "#{kwargs[:controller_name]}_controller".camelize
 
-          next
-        end
+      opts = kwargs.merge(controller_class_name: controller_class_name)
 
-        next if missing.empty? # Everything is perfect
+      route_call = RouteCall.new(opts)
+      route_calls << route_call
 
-        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
+      controller = nil
+      begin
+        controller = Object.const_get(controller_class_name)
+      rescue LoadError, RuntimeError, NameError => e
+        route_call.add_issue RouteIssue::NoController.new(error: e.message)
+        return
+      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 controller.nil?
+        route_call.add_issue RouteIssue::NoController.new(error: "#{controller_class_name} is nil")
+        return
+      end
+
+      analyze_action_availability(controller, route_call, **opts)
+    end
 
-        if verbose
-          verbose_message = "This route currently covers unimplemented actions: [#{missing.sort.map {|x| ":#{x}" }.join(', ')}]"
+    # Checks which if any actions referred to by the route don't exist.
+    def analyze_action_availability(controller, route_call, **opts)
+      present, missing = opts[:action_names].partition { |name| controller.action_methods.include?(name.to_s) }
+
+      route_call[:present_actions] = present if present.any?
+
+      if SINGLE_METHODS.include?(opts[:route_creation_method])
+        # NOTE a single call like 'get' can add multiple actions if called in a loop
+        if missing.present?
+          route_call.add_issue RouteIssue::NoAction.new(missing_actions: missing)
         end
+        return
+      end
 
-        all_issues << RouteIssue.new(opts.merge(type: :resources, suggested_param: suggested_param, verbose_message: verbose_message))
+      return if missing.empty? # Everything is perfect, all routes match an action
+
+      if present.sort == RESOURCE_ACTIONS.sort
+        # Should happen only if RESOURCE_ACTIONS doesn't match which actions rails supports
+        raise "shouldn't get all methods being present and yet some missing at the same time: #{present.inspect} #{missing.inspect}"
       end
 
-      self.route_log = RouteInterceptor.route_log.dup
-      self.all_issues = all_issues
+      suggested_param = resource_route_suggested_param(present)
+
+      route_call.add_issue RouteIssue::Resources.new(suggested_param: suggested_param)
     end
 
-    def all_issues
-      @all_issues || []
+    def resource_route_suggested_param(present)
+      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
     end
 
     def issues
-      all_issues.select(&:issue?)
+      route_calls.select(&:issue?)
     end
 
     def non_issues
-      all_issues.reject(&:issue?)
+      route_calls.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
+      issues.map(&:full_filename).uniq.sort
     end
 
-    def all_issues_for_file_name(full_filename)
-      all_issues.select { |issue| issue.full_filename == full_filename.to_s }
+    def route_calls_for_file_name(full_filename)
+      route_calls.select { |record| record.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]
+        route_calls.each do |route_call|
+          (route_call.present_actions || []).each do |action|
+            implemented_routes << [route_call.controller_class_name, action]
           end
         end
       end
     end
+
+    def route_lines_for_file(full_filename)
+      route_lines.select { |line| line.full_filename == full_filename.to_s }
+    end
+
+    def print_report
+      if issues.empty?
+        puts "No route issues found"
+        return
+      end
+
+      issues.each do |issue|
+        puts issue.human_readable_error(verbose: verbose)
+      end
+    end
   end
 
 end