routes_coverage 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 899581bd48d52230827553a1a8f94428f7c224cc
-  data.tar.gz: debceb6a0e49ef3d7b313c2733fc20ce3b08d428
+SHA256:
+  metadata.gz: 576b62caebf21a9e1448f549a213eaf5770ca8486c1ad94183c1bd8617bb9916
+  data.tar.gz: 9a150fe8e215e92ba00dee273700ebe69f08baca5606cc7980b09fcc854c0969
 SHA512:
-  metadata.gz: 452ab35f957e94c2122f89cb8c85599da67ea5ee8710c5090fe236d7b50a83d135221d42764fdb00d72309ebf85ea29b3e6047e30e1ef1b02dd4bc7e7ffd46f6
-  data.tar.gz: d0288d1afe2888e8118d09f2758acf8847cab1567b88dad93d59cfd5a84423095f2a6a6af4f4dd2206dbbc33f50d1556b40667611e93c491d3f8313fe5e2c924
+  metadata.gz: 1695cd9694f9388c438814a990127af84930e39413694d15fec8a35bb5f12b1217c1c4a4e8d9fd3b1289a0f91543cc11d772142354481907508337c736f2217e
+  data.tar.gz: 4197958e82df3eceee17d222f441cbf7106d4de67d5fafb3bcdb4d16b0e59159c4678f2420c679483379aeb28a3304b246b77a8215026034aca936af7b4cb797

data/README.md

@@ -41,6 +41,7 @@ RSpec.configure do |config|
   config.routes_coverage.exclude_namespaces << 'somenamespace' # excludes /somenamespace/*
 
   config.routes_coverage.groups["Some Route group title"] = %r{^/somespace/}
+  config.routes_coverage.groups["Subdomain"] = { constraints: { subdomain: 'some_subdomain' }, path: '/' }
   config.routes_coverage.groups["Admin"] = Regexp.union([
     %r{^/admin/},
     %r{^/secret_place/},

data/lib/routes_coverage/adapters/atexit.rb

@@ -1,14 +1,17 @@
+# frozen_string_literal: true
+
 module RoutesCoverage
   module Adapters
     class AtExit
-      def self.use coverer=nil
-        #NB: at_exit order is important, for example minitest uses it to run, need to install our handler before it
+      def self.use(_coverer = nil)
+        # NB: at_exit order is important, for example minitest uses it to run, need to install our handler before it
 
         RoutesCoverage.reset!
         at_exit do
           next if RoutesCoverage.pid != Process.pid
+
           RoutesCoverage.perform_report
-          exit
+          exit # rubocop:disable Rails/Exit
         end
       end
     end

data/lib/routes_coverage/adapters/rspec.rb

@@ -1,12 +1,26 @@
+# frozen_string_literal: true
+
+require 'rspec/core'
+
 RSpec.configure do |config|
   config.add_setting :routes_coverage
   config.routes_coverage = RoutesCoverage.settings
+end
 
-  config.before(:suite) do
-    RoutesCoverage.reset!
-  end
+module RoutesCoverage
+  module Adapters
+    class RSpec
+      def self.use
+        ::RSpec.configure do |config|
+          config.before(:suite) do
+            RoutesCoverage.reset!
+          end
 
-  config.after(:suite) do
-    RoutesCoverage.perform_report
+          config.after(:suite) do
+            RoutesCoverage.perform_report
+          end
+        end
+      end
+    end
   end
 end

data/lib/routes_coverage/adapters/simplecov.rb

@@ -1,11 +1,15 @@
+# frozen_string_literal: true
+
 module RoutesCoverage
   module Adapters
     class SimpleCov
       def self.use
         RoutesCoverage.reset!
-        ::SimpleCov.at_exit{
+        prev_block = ::SimpleCov.at_exit
+        ::SimpleCov.at_exit do
           RoutesCoverage.perform_report
-        }
+          prev_block.call
+        end
       end
     end
   end

data/lib/routes_coverage/formatters/base.rb

@@ -1,15 +1,15 @@
+# frozen_string_literal: true
+
 module RoutesCoverage
   module Formatters
     class Base
-      def initialize result, groups, settings
+      def initialize(result, groups, settings)
         @result = result
         @groups = groups
         @settings = settings
       end
 
-      attr_reader :result
-      attr_reader :groups
-      attr_reader :settings
+      attr_reader :result, :groups, :settings
     end
   end
 end

data/lib/routes_coverage/formatters/full_text.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 module RoutesCoverage
   module Formatters
     class FullText < SummaryText
-
       class RouteFormatter
         attr_reader :buffer
 
-        def initialize result=nil, _settings=nil, output_hits=false
+        def initialize(result = nil, _settings = nil, output_hits: false)
           @buffer = []
           @result = result
           @output_hits = output_hits
@@ -28,49 +29,47 @@ module RoutesCoverage
           @buffer << draw_header(routes)
         end
 
-        def no_routes _routes_from_rails5=nil
+        def no_routes(_routes_from_rails5 = nil)
           @buffer << "\tNone"
         end
 
         private
-        HEADER = ['Prefix', 'Verb', 'URI Pattern', 'Controller#Action']
+
+        HEADER = ['Prefix', 'Verb', 'URI Pattern', 'Controller#Action'].freeze
         def draw_section(routes)
           header_lengths = HEADER.map(&:length)
           name_width, verb_width, path_width, reqs_width = widths(routes).zip(header_lengths).map(&:max)
 
-          hits = nil
           routes.map do |r|
-            # puts "route is #{r.inspect}"
-            if @output_hits
-              # hits = " ?"
-              if r[:original].respond_to?(:__getobj__)
-                original_route = r[:original].__getobj__ # SimpleDelegator
-              else
-                original_route = r[:original]
-              end
-              hits = " #{@result.route_hit_counts[original_route]}"
-            end
-            "#{r[:name].rjust(name_width) if @output_prefix} #{r[:verb].ljust(verb_width)} #{r[:path].ljust(path_width)} #{r[:reqs].ljust(reqs_width)}#{hits}"
+            # unwrap SimpleDelegator
+            original_route = r[:original].respond_to?(:__getobj__) ? r[:original].__getobj__ : r[:original]
+
+            "#{r[:name].rjust(name_width) if @output_prefix} "\
+              "#{r[:verb].ljust(verb_width)} #{r[:path].ljust(path_width)} #{r[:reqs].ljust(reqs_width)}"\
+              "#{" #{@result.route_hit_counts[original_route]}" if @output_hits}"
           end
         end
 
         def draw_header(routes)
           name_width, verb_width, path_width, reqs_width = widths(routes)
 
-          "#{"Prefix".rjust(name_width) if @output_prefix} #{"Verb".ljust(verb_width)} #{"URI Pattern".ljust(path_width)} #{"Controller#Action".ljust(reqs_width)}#{' Hits' if @output_hits}"
+          [
+            ('Prefix'.rjust(name_width) if @output_prefix),
+            'Verb'.ljust(verb_width),
+            'URI Pattern'.ljust(path_width),
+            'Controller#Action'.ljust(reqs_width),
+            ('Hits' if @output_hits)
+          ].compact.join(' ')
         end
 
         def widths(routes)
-          [routes.map { |r| r[:name].length }.max || 0,
-           routes.map { |r| r[:verb].length }.max || 0,
-           routes.map { |r| r[:path].length }.max || 0,
-           routes.map { |r| r[:reqs].length }.max || 0,
-         ]
+          %i[name verb path reqs].map do |key|
+            routes.map { |r| r[key].length }.max.to_i
+          end
         end
       end
 
-
-      def routes_section formatter, title, routes
+      def routes_section(formatter, title, routes)
         formatter.buffer << title
 
         if routes.none?
@@ -83,24 +82,27 @@ module RoutesCoverage
         formatter.result
       end
 
-      def hit_routes
-        routes = result.hit_routes
+      def collect_routes(routes)
+        # rails 3
+        return Result::Inspector.new.collect_all_routes(routes) unless Result::Inspector::NEW_RAILS
+
+        Result::Inspector.new(routes).collect_all_routes
+      end
+
+      def hit_routes_details
         # engine routes now are in the same list
-        if Result::Inspector::NEW_RAILS
-          hit_routes = Result::Inspector.new(result.hit_routes).collect_all_routes
-          pending_routes = Result::Inspector.new(result.pending_routes).collect_all_routes
-        else
-          #rails 3
-          hit_routes = Result::Inspector.new.collect_all_routes(result.hit_routes)
-          pending_routes = Result::Inspector.new.collect_all_routes(result.pending_routes)
-        end
+        hit_routes = collect_routes(result.hit_routes)
+        pending_routes = collect_routes(result.pending_routes)
+
+        <<~TXT
+          #{routes_section(RouteFormatter.new(result, settings, output_hits: true), 'Covered routes:', hit_routes)}
 
-        return routes_section(RouteFormatter.new(result, settings, true), "Covered routes:", hit_routes) + "\n\n" +
-        routes_section(RouteFormatter.new(result, settings), "Pending routes:", pending_routes)
+          #{routes_section(RouteFormatter.new(result, settings), 'Pending routes:', pending_routes)}
+        TXT
       end
 
       def format
-        "#{super}\n\n#{hit_routes}"
+        "#{super}\n\n#{hit_routes_details}"
       end
     end
   end

data/lib/routes_coverage/formatters/html.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "erb"
 require "cgi"
 require "fileutils"
@@ -23,24 +25,25 @@ module RoutesCoverage
         ERB.new(File.read(File.join(File.dirname(__FILE__), "html_views", "#{name}.erb")))
       end
 
-
       def root(root = nil)
-        #TODO: config for this
+        # TODO: config for this
         return SimpleCov.root if defined? SimpleCov
         return @root if defined?(@root) && root.nil?
+
         @root = File.expand_path(root || Dir.getwd)
       end
 
       def coverage_dir(dir = nil)
-        #TODO: config for this
+        # TODO: config for this
         return SimpleCov.coverage_dir if defined? SimpleCov
         return @coverage_dir if defined?(@coverage_dir) && dir.nil?
-        @coverage_path = nil # invalidate cache
+
+        @output_path = nil # invalidate cache
         @coverage_dir = (dir || "coverage")
       end
 
       def output_path
-        @coverage_path ||= File.expand_path(coverage_dir, root).tap do |path|
+        @output_path ||= File.expand_path(coverage_dir, root).tap do |path|
           FileUtils.mkdir_p path
         end
       end
@@ -51,8 +54,8 @@ module RoutesCoverage
         @project_name ||= File.basename(root.split("/").last).capitalize.tr("_", " ")
       end
 
-      def asset_content name
-        File.read(File.expand_path("../../../compiled_assets/#{name}", File.dirname(__FILE__)))
+      def asset_content(name)
+        File.read(File.expand_path("../../../compiled_assets/#{name}", __dir__))
       end
 
       def style_asset_link
@@ -83,33 +86,23 @@ module RoutesCoverage
         end
       end
 
-      def hits_css_class hits
-        hits > 0 ? 'cov' : 'uncov'
+      def hits_css_class(hits)
+        hits.positive? ? 'cov' : 'uncov'
       end
 
       def timeago(time)
         "<abbr class=\"timeago\" title=\"#{time.iso8601}\">#{time.iso8601}</abbr>"
       end
 
-
       def all_result_groups
-        return @all_result_groups if @all_result_groups
-        @all_result_groups = [
-          {
-            id: 'all_routes',
-            name: 'All Routes',
-            result: result,
-          }
-        ]
-        @all_result_groups += groups.map do |group_name, group_result|
-          {
-            id: group_name.gsub(/^[^a-zA-Z]+/, "").gsub(/[^a-zA-Z0-9\-\_]/, ""),
-            name: group_name,
-            result: group_result,
-          }
-        end
-
-        @all_result_groups
+        @all_result_groups ||= [{ id: 'all_routes', name: 'All Routes', result: result }] +
+                               groups.map do |group_name, group_result|
+                                 {
+                                   id: group_name.gsub(/^[^a-zA-Z]+/, "").gsub(/[^a-zA-Z0-9\-_]/, ""),
+                                   name: group_name,
+                                   result: group_result
+                                 }
+                               end
       end
     end
   end

data/lib/routes_coverage/formatters/summary_text.rb

@@ -1,15 +1,18 @@
+# frozen_string_literal: true
+
 module RoutesCoverage
   module Formatters
     class SummaryText < Base
-      def hits_count result
-        "#{result.hit_routes_count} of #{result.expected_routes_count}#{"(#{result.total_count} total)" if result.expected_routes_count != result.total_count} routes hit#{ " at #{result.avg_hits} hits average" if result.hit_routes_count > 0}"
+      def hits_count(result)
+        "#{result.hit_routes_count} of #{result.expected_routes_count}"\
+          "#{"(#{result.total_count} total)" if result.expected_routes_count != result.total_count}"\
+          " routes hit#{" at #{result.avg_hits} hits average" if result.hit_routes_count.positive?}"
       end
 
       def status
         return unless settings.minimum_coverage
-        unless result.coverage_pass?
-          "Coverage is too low"
-        end
+
+        "Coverage is too low" unless result.coverage_pass?
       end
 
       def format
@@ -18,9 +21,9 @@ module RoutesCoverage
         ]
 
         if groups.any?
-          buffer += groups.map{|group_name, group_result|
+          buffer += groups.map do |group_name, group_result|
             "  #{group_name}: #{group_result.coverage}% (#{hits_count group_result})"
-          }
+          end
         end
 
         buffer << status

data/lib/routes_coverage/middleware.rb

@@ -1,26 +1,27 @@
+# frozen_string_literal: true
+
 module RoutesCoverage
   class Middleware
-    def initialize app
+    def initialize(app)
       @app = app
     end
 
-    def call env
+    def call(original_env)
       # router changes env/request during recognition so need a copy:
-      req = ::Rails.application.routes.request_class.new env.dup
-      ::Rails.application.routes.router.recognize(req) do |route|
+      env = original_env.dup
+      req = ::Rails.application.routes.request_class.new env
+      ::Rails.application.routes.router.recognize(req) do |route, parameters5, parameters4|
+        parameters = parameters5 || parameters4
         dispatcher = route.app
         if dispatcher.respond_to?(:dispatcher?)
-          unless dispatcher.matches?(req) # && dispatcher.dispatcher?
-            dispatcher = nil
-          end
+          req.path_parameters = parameters
+          dispatcher = nil unless dispatcher.matches?(req) # && dispatcher.dispatcher?
         else # rails < 4.2
           dispatcher = route.app
-          while dispatcher.is_a?(ActionDispatch::Routing::Mapper::Constraints) do
-            if dispatcher.matches?(env)
-              dispatcher = dispatcher.app
-            else
-              dispatcher = nil
-            end
+          req.env['action_dispatch.request.path_parameters'] =
+            (env['action_dispatch.request.path_parameters'] || {}).merge(parameters)
+          while dispatcher.is_a?(ActionDispatch::Routing::Mapper::Constraints)
+            dispatcher = (dispatcher.app if dispatcher.matches?(env))
           end
         end
         next unless dispatcher
@@ -29,8 +30,8 @@ module RoutesCoverage
         # there may be multiple matching routes - we should match only first
         break
       end
-      #TODO: detect 404s? and maybe other route errors?
-      @app.call(env)
+      # TODO: detect 404s? and maybe other route errors?
+      @app.call(original_env)
     end
   end
 end

data/lib/routes_coverage/result.rb

@@ -1,19 +1,20 @@
+# frozen_string_literal: true
+
 require 'active_support/core_ext/string' # needed for rails5 version of inspector
 
 module RoutesCoverage
   class Result
-
     begin
       require 'action_dispatch/routing/inspector'
       class Inspector < ActionDispatch::Routing::RoutesInspector
         NEW_RAILS = true
         def collect_all_routes
           res = collect_routes(@routes)
-          #TODO: test with engines
+          # TODO: test with engines
           @engines.each do |engine_name, engine_routes|
-            res += engine_routes.map{|er|
+            res += engine_routes.map  do |er|
               er.merge({ engine_name: engine_name })
-            }
+            end
           end
           res
         end
@@ -21,39 +22,35 @@ module RoutesCoverage
         def collect_routes(routes)
           routes.collect do |route|
             ActionDispatch::Routing::RouteWrapper.new(route)
-          end.reject do |route|
-            route.internal?
-          end.collect do |route|
+          end.reject(&:internal?).collect do |route| # rubocop:disable Style/MultilineBlockChain
             collect_engine_routes(route)
 
-            { name:   route.name,
-              verb:   route.verb,
-              path:   route.path,
-              reqs:   route.reqs,
+            { name: route.name,
+              verb: route.verb,
+              path: route.path,
+              reqs: route.reqs,
               # regexp: route.json_regexp, # removed, this is not present in rails5
               # added:
-              original: route,
-            }
+              original: route }
           end
         end
       end
-
     rescue LoadError
-      #rails 3
+      # rails 3
       require 'rails/application/route_inspector'
       class Inspector < Rails::Application::RouteInspector
         NEW_RAILS = false
-        def collect_all_routes(routes)
+        def collect_all_routes(routes) # rubocop:disable Lint/DuplicateMethods
           res = collect_routes(routes)
           @engines.each do |engine_name, engine_routes|
-            res += engine_routes.map{|er|
+            res += engine_routes.map  do |er|
               er.merge({ engine_name: engine_name })
-            }
+            end
           end
           res
         end
 
-        def collect_routes(routes)
+        def collect_routes(routes) # rubocop:disable Lint/DuplicateMethods
           routes = routes.collect do |route|
             route_reqs = route.requirements
 
@@ -70,44 +67,40 @@ module RoutesCoverage
 
             collect_engine_routes(reqs, rack_app)
 
-            { name:   route.name.to_s,
-              verb:   route.verb.source.gsub(/[$^]/, ''),
-              path:   route.path.spec.to_s,
-              reqs:   reqs,
+            { name: route.name.to_s,
+              verb: route.verb.source.gsub(/[$^]/, ''),
+              path: route.path.spec.to_s,
+              reqs: reqs,
               # added:
-              original: route,
-            }
+              original: route }
           end
 
           # Skip the route if it's internal info route
           routes.reject { |r| r[:path] =~ %r{/rails/info/properties|^#{Rails.application.config.assets.prefix}} }
         end
       end
-
     end
 
-    def initialize all_routes, hit_routes, settings
+    def initialize(all_routes, hit_routes, settings)
       @all_routes = all_routes
       @route_hit_counts = hit_routes
       @settings = settings
     end
 
-    attr_reader :all_routes
-
-    attr_reader :route_hit_counts
+    attr_reader :all_routes, :route_hit_counts
 
     def expected_routes
       return @expected_routes if @expected_routes
 
       filter_regex = Regexp.union(@settings.exclude_patterns)
-      namespaces_regex = Regexp.union(@settings.exclude_namespaces.map{|n| /^\/#{n}/})
+      namespaces_regex = Regexp.union(@settings.exclude_namespaces.map { |n| %r{^/#{n}} })
 
-      routes_groups = all_routes.group_by{|r|
-        !!(
+      routes_groups = all_routes.group_by do |r|
+        (
           ("#{r.verb.to_s[8..-3]} #{r.path.spec}".strip =~ filter_regex) ||
           (r.path.spec.to_s =~ namespaces_regex)
-        )
-      }
+        ).present?
+      end
 
       @excluded_routes = routes_groups[true] || []
       @expected_routes = routes_groups[false] || []
@@ -123,11 +116,10 @@ module RoutesCoverage
     end
 
     def hit_routes
-      #TODO: sort?
+      # TODO: sort?
       @route_hit_counts.keys
     end
 
-
     def hit_routes_count
       @route_hit_counts.size
     end
@@ -146,6 +138,7 @@ module RoutesCoverage
 
     def coverage
       return 0 unless expected_routes.any?
+
       (hit_routes_count * 100.0 / expected_routes_count).round(@settings.round_precision)
     end
 
@@ -158,16 +151,15 @@ module RoutesCoverage
     end
 
     def all_routes_with_hits
-      if Inspector::NEW_RAILS
-        res = Inspector.new(all_routes).collect_all_routes
-      else
-        res = Inspector.new.collect_all_routes(all_routes)
-      end
-      res.each{|val|
+      res = if Inspector::NEW_RAILS
+              Inspector.new(all_routes).collect_all_routes
+            else
+              Inspector.new.collect_all_routes(all_routes)
+            end
+      res.each do |val|
         val[:hits] = @route_hit_counts[val[:original]] || 0
-      }
+      end
       res
     end
-
   end
 end

data/lib/routes_coverage/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RoutesCoverage
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end