rails-route-checker 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ea424b37eac8e092071553a987c58ee05c0fae83
+  data.tar.gz: 935ad9981a24ff5f65ac447c44dcaacb54d98d32
+SHA512:
+  metadata.gz: f8ffc446b5200c1f96c2f1b658ea132ad8aca579b6a2b30a9480c1a49e98504acd10791559aec379b19accf0f88789af7df8d3d2bd5121081289d1c54f3bcd43
+  data.tar.gz: 49a04e76dde512d40127684c8c0127a216755f32e8240b68de4799b3cc1c6e334b240e850507846500a1840ae76fab419ec71ff5606ae783d777e608d1c2efa2

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/exe/rails-route-checker

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require 'rails-route-checker'
+require 'optparse'
+
+options = {}
+OptionParser.new do |parser|
+  parser.banner = 'Usage: rails-route-checker [options]'
+
+  parser.on('-c', '--config CONFIG_FILE', 'Path to config file') do |path|
+    unless File.exist?(path)
+      puts 'Config file does not exist'
+      exit 1
+    end
+
+    options[:config_file] = path
+  end
+
+  parser.on('-h', '--help', 'Prints this help') do
+    puts parser
+    exit
+  end
+end.parse!
+
+options[:config_file] = '.rails-route-checker.yml' if File.exist?('.rails-route-checker.yml') && !options[:config_file]
+
+rrc = RailsRouteChecker::Runner.new(options)
+puts rrc.output
+exit rrc.issues? ? 1 : 0

data/lib/rails-route-checker.rb

@@ -0,0 +1,7 @@
+require 'rails-route-checker/app_interface'
+require 'rails-route-checker/config_file'
+require 'rails-route-checker/loaded_app'
+require 'rails-route-checker/runner'
+require 'rails-route-checker/version'
+
+module RailsRouteChecker; end

data/lib/rails-route-checker/app_interface.rb

@@ -0,0 +1,134 @@
+module RailsRouteChecker
+  class AppInterface
+    def initialize(**opts)
+      @options = opts
+    end
+
+    def routes_without_actions
+      loaded_app.routes.map do |r|
+        controller = r.requirements[:controller]
+        action = r.requirements[:action]
+
+        next if options[:ignored_controllers].include?(controller)
+        next if controller_information.key?(controller) && controller_information[controller][:actions].include?(action)
+
+        {
+          controller: controller,
+          action: action
+        }
+      end.compact
+    end
+
+    def undefined_path_method_calls
+      generate_undef_view_path_calls + generate_undef_controller_path_calls
+    end
+
+    private
+
+    attr_reader :options
+
+    def loaded_app
+      @loaded_app ||= RailsRouteChecker::LoadedApp.new
+    end
+
+    def controller_information
+      @controller_information ||= loaded_app.controller_information.reject do |path, _|
+        options[:ignored_controllers].include?(path)
+      end
+    end
+
+    def generate_undef_view_path_calls
+      files = `find app -type f -iregex '.*\\.haml' -or -iregex '.*\\.erb' -or -iregex '.*\\.html'`.split("\n")
+      files.map do |filename|
+        controller = controller_from_view_file(filename)
+
+        defined_variables = []
+
+        File.read(filename).each_line.each_with_index.map do |line, line_num|
+          next if line =~ /^\s*-\s*#/
+          skip_first = false
+          if line =~ /^\s*-/
+            line_match = line.match(/^\s*-\s*([a-zA-Z0-9_]+_(?:path|url))\s*=/)
+            defined_variables << line_match[1] if line_match
+            skip_first = true
+          end
+
+          matches = line.scan(/(([a-zA-Z][a-zA-Z0-9_]*)_(?:path|url))[^a-z0-9_]/)
+          matches.shift if skip_first
+          ignores = line.scan(/(([a-zA-Z][a-zA-Z0-9_]*)_(?:path|url))(?: =|[!:])/).map(&:first)
+          ignores += line.scan(/[.@:_'"]([a-zA-Z][a-zA-Z0-9_]+_(?:path|url))[^a-z0-9_]/).map(&:first)
+
+          matches.reject! { |match| ignores.include?(match[0]) }
+
+          matches.map do |match|
+            next if match_in_whitelist?(filename, match)
+            next if match_defined_in_view?(controller, defined_variables, match)
+            { file: filename, line: line_num + 1, method: match[0] }
+          end
+        end
+      end.flatten.compact
+    end
+
+    def generate_undef_controller_path_calls
+      `find app/controllers -type f -iregex '.*\\.rb'`.split("\n").map do |filename|
+        controller = controller_from_ruby_file(filename)
+
+        File.read(filename).each_line.each_with_index.map do |line, line_num|
+          next if line =~ /^\s*#/
+          next if line =~ /^\s*def\s/
+
+          matches = line.scan(/(([a-zA-Z][a-zA-Z0-9_]*)_(?:path|url))[^a-z0-9_]/)
+          ignores = line.scan(/(([a-zA-Z][a-zA-Z0-9_]*)_(?:path|url))(?: =|[!:])/).map(&:first)
+          ignores += line.scan(/[.@:_'"]([a-zA-Z][a-zA-Z0-9_]+_(?:path|url))[^a-z0-9_]/).map(&:first)
+
+          matches.reject! { |match| ignores.include?(match[0]) }
+
+          matches.map do |match|
+            next if match_in_whitelist?(filename, match)
+            next if match_defined_in_ruby?(controller, match)
+            { file: filename, line: line_num + 1, method: match[0] }
+          end
+        end
+      end.flatten.compact
+    end
+
+    def match_in_whitelist?(filename, match)
+      full_match, possible_route_name = match
+      return true if options[:ignored_paths].include?(possible_route_name)
+      (options[:ignored_path_whitelist][filename] || []).include?(full_match)
+    end
+
+    def match_defined_in_view?(controller, defined_variables, match)
+      full_match, possible_route_name = match
+      return true if loaded_app.all_route_names.include?(possible_route_name)
+      return true if defined_variables.include?(full_match)
+      controller && controller[:helpers].include?(full_match)
+    end
+
+    def match_defined_in_ruby?(controller, match)
+      full_match, possible_route_name = match
+      return true if loaded_app.all_route_names.include?(possible_route_name)
+      controller && controller[:instance_methods].include?(full_match)
+    end
+
+    def controller_from_view_file(filename)
+      split_path = filename.split('/')
+      possible_controller_path = split_path[(split_path.index('app') + 2)..-2]
+
+      controller = nil
+      while controller.nil? && possible_controller_path.any?
+        if controller_information.include?(possible_controller_path.join('/'))
+          controller = controller_information[possible_controller_path.join('/')]
+        else
+          possible_controller_path = possible_controller_path[0..-2]
+        end
+      end
+      controller || controller_information['application']
+    end
+
+    def controller_from_ruby_file(filename)
+      controller_name = (filename.match(%r{app/controllers/(.*)_controller.rb}) || [])[1] || 'application'
+      controller_information[controller_name]
+    end
+  end
+end

data/lib/rails-route-checker/config_file.rb

@@ -0,0 +1,27 @@
+module RailsRouteChecker
+  class ConfigFile
+    def initialize(filename)
+      @filename = filename
+    end
+
+    def config
+      @config ||= begin
+        hash = load_yaml_file
+        {
+          ignored_controllers: hash['ignored_controllers'] || [],
+          ignored_paths: hash['ignored_paths'] || [],
+          ignored_path_whitelist: hash['ignored_path_whitelist'] || []
+        }
+      end
+    end
+
+    private
+
+    attr_reader :filename
+
+    def load_yaml_file
+      require 'yaml'
+      YAML.safe_load(File.read(filename))
+    end
+  end
+end

data/lib/rails-route-checker/loaded_app.rb

@@ -0,0 +1,108 @@
+module RailsRouteChecker
+  class LoadedApp
+    def initialize
+      @app = suppress_output do
+        app_base_path = Dir.pwd
+        require_relative "#{app_base_path}/config/boot"
+        require_relative "#{Dir.pwd}/config/environment"
+
+        a = Rails.application
+        a.eager_load!
+        attempt_to_load_default_controllers
+        a.reload_routes!
+        Rails::Engine.subclasses.each(&:eager_load!)
+
+        a
+      end
+    end
+
+    def routes
+      return @routes if defined?(@routes)
+
+      @routes = app.routes.routes.reject do |r|
+        reject_route?(r)
+      end.uniq
+
+      return @routes unless @app.config.respond_to?(:assets)
+
+      use_spec = defined?(ActionDispatch::Journey::Route) || defined?(Journey::Route)
+      @routes.reject do |route|
+        path = use_spec ? route.path.spec.to_s : route.path
+        path =~ /^#{app.config.assets.prefix}/
+      end
+    end
+
+    def all_route_names
+      @all_route_names ||= app.routes.routes.map(&:name).compact
+    end
+
+    def controller_information
+      @controller_information ||= ActionController::Base.descendants.map do |controller|
+        next if controller.controller_path.start_with?('rails/')
+
+        instance_methods = (controller.instance_methods.map(&:to_s) + controller.private_instance_methods.map(&:to_s))
+
+        [
+          controller.controller_path,
+          {
+            helpers: controller.helpers.methods.map(&:to_s),
+            actions: controller.action_methods.to_a,
+            instance_methods: instance_methods.compact.uniq
+          }
+        ]
+      end.compact.to_h
+    end
+
+    private
+
+    attr_reader :app
+
+    def suppress_output
+      begin
+        original_stderr = $stderr.clone
+        original_stdout = $stdout.clone
+        $stderr.reopen(File.new('/dev/null', 'w'))
+        $stdout.reopen(File.new('/dev/null', 'w'))
+        retval = yield
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        $stdout.reopen(original_stdout)
+        $stderr.reopen(original_stderr)
+        raise e
+      ensure
+        $stdout.reopen(original_stdout)
+        $stderr.reopen(original_stderr)
+      end
+      retval
+    end
+
+    def attempt_to_load_default_controllers
+      # rubocop:disable Lint/HandleExceptions
+      begin
+        ::Rails::InfoController
+      rescue NameError # ignored
+      end
+      begin
+        ::Rails::WelcomeController
+      rescue NameError # ignored
+      end
+      begin
+        ::Rails::MailersController
+      rescue NameError # ignored
+      end
+      # rubocop:enable Lint/HandleExceptions
+    end
+
+    def reject_route?(route)
+      return true if route.name.nil? && route.requirements.blank?
+      return true if route.app.is_a?(ActionDispatch::Routing::Mapper::Constraints) &&
+                     route.app.app.respond_to?(:call)
+      return true if route.app.is_a?(ActionDispatch::Routing::Redirect)
+
+      controller = route.requirements[:controller]
+      action = route.requirements[:action]
+      return true unless controller && action
+      return true if controller.start_with?('rails/')
+      false
+    end
+  end
+end

data/lib/rails-route-checker/runner.rb

@@ -0,0 +1,54 @@
+module RailsRouteChecker
+  class Runner
+    def initialize(**opts)
+      @options = { ignored_controllers: [], ignored_paths: [], ignored_path_whitelist: {} }
+      @options.merge!(RailsRouteChecker::ConfigFile.new(opts[:config_file]).config) if opts[:config_file]
+      @options.merge!(opts)
+    end
+
+    def issues
+      @issues ||= {
+        missing_actions: app_interface.routes_without_actions,
+        missing_routes: app_interface.undefined_path_method_calls
+      }
+    end
+
+    def issues?
+      issues.values.flatten(1).count > 1
+    end
+
+    def output
+      output_lines = []
+      output_lines += missing_actions_output if issues[:missing_actions].any?
+      if issues[:missing_routes].any?
+        output_lines << "\n" if output_lines.any?
+        output_lines += missing_routes_output
+      end
+      output_lines = ['All good in the hood'] if output_lines.empty?
+      output_lines.join("\n")
+    end
+
+    private
+
+    def app_interface
+      @app_interface ||= RailsRouteChecker::AppInterface.new(@options)
+    end
+
+    def missing_actions_output
+      [
+        "The following #{issues[:missing_actions].count} routes are defined, " \
+        'but have no corresponding controller action.',
+        'If you have recently added a route to routes.rb, make sure a matching action exists in the controller.',
+        'If you have recently removed a controller action, also remove the route in routes.rb.',
+        *issues[:missing_actions].map { |r| " - #{r[:controller]}##{r[:action]}" }
+      ]
+    end
+
+    def missing_routes_output
+      [
+        "The following #{issues[:missing_routes].count} url and path methods don't correspond to any route.",
+        *issues[:missing_routes].map { |line| " - #{line[:file]}:L#{line[:line]} - call to #{line[:method]}" }
+      ]
+    end
+  end
+end

data/lib/rails-route-checker/version.rb

@@ -0,0 +1,3 @@
+module RailsRouteChecker
+  VERSION = '0.1.0'.freeze
+end

data/rails-route-checker.gemspec

@@ -0,0 +1,30 @@
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rails-route-checker/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rails-route-checker'
+  spec.version       = RailsRouteChecker::VERSION
+  spec.authors       = ['Dave Allie']
+  spec.email         = ['dave@daveallie.com']
+
+  spec.summary       = 'Blah'
+  spec.description   = 'Blah'
+  spec.homepage      = 'https://github.com/daveallie/rails-route-checker'
+  spec.license       = 'MIT'
+
+  spec.files         = Dir['exe/*'] + Dir['lib/**/*'] +
+                       ['Gemfile', 'rails-route-checker.gemspec']
+
+  #   `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.15'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rubocop', '~> 0.51'
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: rails-route-checker
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dave Allie
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-10-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !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: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.51'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.51'
+description: Blah
+email:
+- dave@daveallie.com
+executables:
+- rails-route-checker
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- exe/rails-route-checker
+- lib/rails-route-checker.rb
+- lib/rails-route-checker/app_interface.rb
+- lib/rails-route-checker/config_file.rb
+- lib/rails-route-checker/loaded_app.rb
+- lib/rails-route-checker/runner.rb
+- lib/rails-route-checker/version.rb
+- rails-route-checker.gemspec
+homepage: https://github.com/daveallie/rails-route-checker
+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.6.12
+signing_key: 
+specification_version: 4
+summary: Blah
+test_files: []