rails_routes_analyzer 1.0.4 → 2.0.0

data/lib/rails_routes_analyzer/route_call.rb

@@ -0,0 +1,65 @@
+module RailsRoutesAnalyzer
+
+  # Represents both positive and negative information collected
+  # about a specific call that generated Rails routes.
+  #
+  # If called in a loop each iteration generates a new record.
+  class RouteCall < Hash
+    def self.fields(*names)
+      names.each { |name| define_method(name) { self[name] } }
+    end
+
+    fields \
+      :action,
+      :action_names,
+      :controller_class_name,
+      :controller_name,
+      :file_location,
+      :route_creation_method,
+      :present_actions
+
+    def initialize(**kwargs)
+      update(kwargs)
+    end
+
+    def issues
+      self[:issues] ||= []
+    end
+
+    def add_issue(issue)
+      issue.route_call = self
+      issues << issue
+    end
+
+    def issue?
+      issues.any?
+    end
+
+    def present_actions?
+      present_actions.present?
+    end
+
+    def full_filename
+      @full_filename ||= RailsRoutesAnalyzer.get_full_filename(file_location.sub(/:[0-9]*\z/, ''))
+    end
+
+    def line_number
+      @line_number ||= file_location[/:([0-9]+)\z/, 1].to_i
+    end
+
+    def suggestion(**kwargs)
+      issues.map { |issue| issue.suggestion(**kwargs) }.join('; ')
+    end
+
+    def human_readable_error(**kwargs)
+      issues.map { |issue| issue.human_readable_error(**kwargs) }.join('; ')
+    end
+
+    def try_to_fix_line(line)
+      return if issues.size != 1
+
+      issues[0].try_to_fix_line(line)
+    end
+  end
+
+end

data/lib/rails_routes_analyzer/route_file_annotator.rb

@@ -1,73 +1,153 @@
 module RailsRoutesAnalyzer
 
   class RouteFileAnnotator
-    def initialize(analysis: RailsRoutesAnalyzer::RouteAnalysis.new)
-      @analysis = analysis
+    # @param try_to_fix [Boolean] should automatic fixes be attempted
+    # @param allow_deleting [Boolean] should route lines be deleted when they match no actions
+    # @param force_overwrite [Boolean] allow overwriting routes file even if it has uncommited changes or is outside Rails.root
+    def initialize(try_to_fix: false, allow_deleting: false, force_overwrite: false, analysis: nil, **kwargs)
+      @analysis = analysis || RailsRoutesAnalyzer::RouteAnalysis.new(**kwargs)
+      @try_to_fix = try_to_fix
+      @allow_deleting = allow_deleting
+      @force_overwrite = force_overwrite
     end
 
     def annotated_file_content(route_filename)
-      relevant_issues = @analysis.all_issues_for_file_name(route_filename)
+      route_lines = @analysis.route_lines_for_file(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(', ')}" }
+      if route_lines.none?(&:issues?)
+        log_notice { "Didn't find any route issues for file: #{route_filename}, only found issues in files: #{@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 }
+      route_lines_map = route_lines.index_by(&:line_number)
 
       "".tap do |output|
         File.readlines(route_filename).each_with_index do |line, index|
-          suggestion = combined_suggestion_for(issue_map[index + 1])
+          route_line = route_lines_map[index + 1]
+
+          output <<
+            if route_line
+              route_line.annotate(line,
+                                  try_to_fix:     @try_to_fix,
+                                  allow_deleting: @allow_deleting)
+            else
+              line
+            end
+        end
+      end
+    end
+
+    def annotate_routes_file(route_filename, inplace: false, do_exit: true)
+      filenames = files_to_work_on(route_filename, inplace: inplace)
+      if filenames.is_a?(Integer)
+        exit filenames if do_exit
+        return filenames
+      end
+
+      filenames.map! { |file| RailsRoutesAnalyzer.get_full_filename(file) }
 
-          if suggestion.present?
-            output << line.sub(/( # SUGGESTION.*)?$/, " # SUGGESTION #{suggestion}")
-          else
-            output << line
+      filenames.each do |filename|
+        unless File.exist?(filename)
+          $stderr.puts "Can't find routes file: #{filename}"
+          exit 1
+        end
+      end
+
+      if filenames.size != 1 && !inplace
+        raise ArgumentError, "got #{filenames.size} files but can annotate only one at a time to stdout"
+      end
+
+      filenames.each do |filename|
+        if inplace
+          if @force_overwrite || self.class.check_file_is_modifiable(filename, report: true)
+            content = annotated_file_content(filename)
+            File.open(filename, 'w') { |f| f.write content }
           end
+        else
+          puts annotated_file_content(filename)
         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?
+    protected
+
+    def log_notice(*args, &block)
+      self.class.log_notice(*args, &block)
     end
 
-    def combined_suggestion_for(all_issues)
-      return if all_issues.nil? || all_issues.none?(&:issue?)
+    class << self
+      def log_notice(message = nil)
+        return if ENV['RAILS_ENV'] == 'test'
+        message ||= yield if block_given?
+        $stderr.puts "# #{message}" if message.present?
+      end
 
-      issues, non_issues = all_issues.partition(&:issue?)
+      def check_file_is_modifiable(filename, report: false, **kwargs)
+        unless filename.to_s.starts_with?(Rails.root.to_s)
+          log_notice "Refusing to modify files outside Rails root: #{Rails.root}" if report
+          return false
+        end
 
-      context = {
-        non_issues: non_issues.present?,
-        num_controllers: all_issues.map(&:controller_class_name).uniq.count,
-      }
+        check_file_git_status(filename, report: report, **kwargs)
+      end
 
-      issues.map { |issue| issue.suggestion(**context) }.join(', ')
-    end
+      def check_file_git_status(filename, report: false, skip_git: false, repo_root: Rails.root.to_s)
+        return skip_git if skip_git
 
-    def annotate_routes_file(filename)
-      filenames = @analysis.unique_issues_file_names
+        git = nil
+        begin
+          require 'git'
+          git = Git.open(repo_root)
+        rescue => e
+          log_notice "Couldn't access git repository at Rails root #{repo_root}. #{e.message}" if report
+          return false
+        end
 
-      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
+        repo_relative_filename = filename.to_s.sub("#{repo_root}/", '')
+
+        # This seems to be required to force some kind of git status
+        # refresh because without it tests would randomly detect a file
+        # as modified by git-status when the file in fact has no changes.
+        #
+        # Currently randomly causes a NoMethodError exception but can still help.
+        begin
+          git.diff.each { |file| }
+        rescue NoMethodError # rubocop:disable Lint/HandleExceptions
+        end
+
+        if git.status.changed.key?(repo_relative_filename)
+          log_notice "Refusing to modify '#{repo_relative_filename}' as it has uncommited changes" if report
+          return false
         end
-        filename = filenames.first
+
+        true
       end
+    end
 
-      filename = RailsRoutesAnalyzer.get_full_filename(filename)
+    def annotatable_routes_files(inplace:)
+      filenames = @analysis.all_unique_issues_file_names
 
-      unless File.exists?(filename)
-        STDERR.puts "Can't routes find file: #{filename}"
-        exit 1
+      if inplace && !@force_overwrite
+        filenames.select! { |filename| self.class.check_file_is_modifiable(filename) }
       end
 
-      puts annotated_file_content(filename)
+      filenames
+    end
+
+    def files_to_work_on(filename, inplace:)
+      return [filename] if filename.present?
+
+      filenames = annotatable_routes_files(inplace: inplace)
+
+      if filenames.empty?
+        $stderr.puts "All routes are good, nothing to annotate"
+        return 0
+      elsif filenames.size > 1 && !inplace
+        $stderr.puts "Please specify routes file with ROUTES_FILE='path/routes.rb' as you have more than one file with problems:\n  #{filenames.join("\n  ")}"
+        return 1
+      end
+      filenames
     end
   end
 

data/lib/rails_routes_analyzer/route_interceptor.rb

@@ -1,15 +1,15 @@
-require 'rails'
+require 'rails/version'
 
 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/
+    ROUTE_METHOD_REGEX = %r{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)|
+        route_log.each do |(location, _controller_name, action, _request_methods)|
           (result[location] ||= []) << action
         end
       end
@@ -20,36 +20,35 @@ module RailsRoutesAnalyzer
     end
 
     # Finds the most interesting Rails.root file from the backtrace that called a method in mapper.rb
-    def get_routes_rb_location
+    def routes_rb_location
       bt = caller
       base = 0
-      while true
-        index = bt[base..-1].index {|l| l =~ ROUTE_METHOD_REGEX }
+      loop do
+        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/
+        if next_line =~ %r{action_dispatch/routing/mapper.rb}
           base += index + 1
           next
         else
-          file_location = next_line[/:?\A#{Rails.root}\/(.*:[0-9]+)/, 1] || next_line
+          file_location = next_line[%r{:?\A#{Rails.root}\/(.*:[0-9]+)}, 1] || next_line
 
-          bt[base + index] =~ ROUTE_METHOD_REGEX
-          route_creation_method = $1
+          route_creation_method = bt[base + index][ROUTE_METHOD_REGEX, 1]
 
           return [file_location, route_creation_method]
         end
       end
     end
 
-    if Rails.version =~ /\A3[.]/
+    if Rails::VERSION::MAJOR == 3
       def initialize(*args)
         super.tap do
           record_route(@options[:controller], @options[:action], conditions[:request_method])
         end
       end
-    elsif Rails.version =~ /\A4\./
+    elsif Rails::VERSION::MAJOR == 4
       def initialize(*args)
         super.tap do
           record_route(@defaults[:controller], @defaults[:action], conditions[:request_method])
@@ -66,7 +65,7 @@ module RailsRoutesAnalyzer
     def record_route(controller_name, action, request_methods)
       return unless controller_name && action
 
-      location = get_routes_rb_location + [controller_name]
+      location = routes_rb_location + [controller_name]
 
       if location[0].nil?
         puts "Failed to find call location for: #{controller_name}/#{action}"

data/lib/rails_routes_analyzer/route_issue.rb

@@ -1,109 +1,4 @@
-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
+require_relative 'route_issue/base'
+require_relative 'route_issue/no_action'
+require_relative 'route_issue/no_controller'
+require_relative 'route_issue/resources'

data/lib/rails_routes_analyzer/route_issue/base.rb

@@ -0,0 +1,68 @@
+require_relative '../route_call'
+
+module RailsRoutesAnalyzer
+  module RouteIssue
+
+    class Base < Hash
+      def self.fields(*names)
+        names.each do |name|
+          define_method(name) { self[name] }
+          define_method("#{name}=") { |val| self[name] = val }
+        end
+      end
+
+      fields :route_call
+
+      delegate \
+        :action,
+        :action_names,
+        :controller_class_name,
+        :controller_name,
+        :file_location,
+        :route_creation_method,
+        :present_actions,
+        to: :route_call
+
+      def initialize(opts = {})
+        update(opts)
+      end
+
+      def human_readable_error(verbose: false)
+        human_readable_error_message.tap do |message|
+          append_verbose_message(message) if verbose
+        end
+      end
+
+      def verbose_message
+      end
+
+      def suggestion(verbose: false, **kwargs)
+        error_suggestion(**kwargs).tap do |message|
+          append_verbose_message(message) if verbose
+        end
+      end
+
+      def append_verbose_message(message)
+        verbose = verbose_message
+        message << "| #{verbose}" if verbose.present?
+      end
+
+      def try_to_fix_line(_line)
+        raise NotImplementedError, 'should be provided by subclasses'
+      end
+
+      def format_actions(actions)
+        case actions.size
+        when 0
+          nil
+        when 1
+          ":#{actions.first}"
+        else
+          list = actions.map { |action| ":#{action}" }.sort.join(', ')
+          "[#{list}]"
+        end
+      end
+    end
+
+  end
+end