Add --grep option to marten routes (#378)

Author: treagod

docs/docs/development/reference/management-commands.md

@@ -235,6 +235,10 @@ marten resetmigrations foo # Resets the migrations of the "foo" application
 
 Displays all the routes of the application.
 
+### Options
+
+* `-g PATTERN, --grep=PATTERN` - Only display routes whose path or name contains the given substring (case-insensitive)
+
 ## `seed`
 
 **Usage:** `marten seed [options]`

spec/marten/cli/manage/command/routes_spec.cr

@@ -73,4 +73,89 @@ describe Marten::CLI::Manage::Command::Routes do
       output.includes?("/<locale>/nested-1-localized/nested-2/dummy/<id:int>").should be_true
     end
   end
+
+  describe "#handle" do
+    it "only displays routes whose path matches the --grep option" do
+      stdout = IO::Memory.new
+      stderr = IO::Memory.new
+
+      command = Marten::CLI::Manage::Command::Routes.new(
+        options: ["--grep=nested-2"],
+        stdout: stdout,
+        stderr: stderr
+      )
+
+      command.handle
+
+      output = stdout.rewind.gets_to_end
+      output.includes?("/nested-1/nested-2/dummy/<id:int>").should be_true
+      output.includes?("/dummy/<id:int>/and/<scope:slug>").should be_false
+    end
+
+    it "supports the -g short option" do
+      stdout = IO::Memory.new
+      stderr = IO::Memory.new
+
+      command = Marten::CLI::Manage::Command::Routes.new(
+        options: ["-g", "nested-2"],
+        stdout: stdout,
+        stderr: stderr
+      )
+
+      command.handle
+
+      output = stdout.rewind.gets_to_end
+      output.includes?("/nested-1/nested-2/dummy/<id:int>").should be_true
+      output.includes?("/dummy/<id:int>/and/<scope:slug>").should be_false
+    end
+
+    it "matches the grep option in a case-insensitive way" do
+      stdout = IO::Memory.new
+      stderr = IO::Memory.new
+
+      command = Marten::CLI::Manage::Command::Routes.new(
+        options: ["--grep=NESTED-2"],
+        stdout: stdout,
+        stderr: stderr
+      )
+
+      command.handle
+
+      output = stdout.rewind.gets_to_end
+      output.includes?("/nested-1/nested-2/dummy/<id:int>").should be_true
+    end
+
+    it "also matches the grep option against the route name" do
+      stdout = IO::Memory.new
+      stderr = IO::Memory.new
+
+      command = Marten::CLI::Manage::Command::Routes.new(
+        options: ["--grep=dummy_with_id_and_scope"],
+        stdout: stdout,
+        stderr: stderr
+      )
+
+      command.handle
+
+      output = stdout.rewind.gets_to_end
+      output.includes?("[dummy_with_id_and_scope]").should be_true
+      output.includes?("/nested-1/dummy/<id:int>").should be_false
+    end
+
+    it "prints a notice when no route matches the grep option" do
+      stdout = IO::Memory.new
+      stderr = IO::Memory.new
+
+      command = Marten::CLI::Manage::Command::Routes.new(
+        options: ["--grep=totally-missing-route"],
+        stdout: stdout,
+        stderr: stderr
+      )
+
+      command.handle
+
+      output = stdout.rewind.gets_to_end
+      output.includes?(%{No routes found matching "totally-missing-route".}).should be_true
+    end
+  end
 end

src/marten/cli/manage/command/routes.cr

@@ -5,40 +5,69 @@ module Marten
         class Routes < Base
           help "Display all the routes of the application."
 
+          private getter! filter : String
+
+          def setup
+            on_option_with_arg(
+              :g,
+              :grep,
+              :pattern,
+              "Only display routes whose path or name contains the given substring (case-insensitive)"
+            ) do |v|
+              @filter = v
+            end
+          end
+
           def run
-            process_routes_map(Marten.routes)
+            printed = process_routes_map(Marten.routes)
+
+            if filter? && printed.zero?
+              print("No routes found matching #{filter.inspect}.")
+            end
           end
 
-          private def process_routes_map(map, parent_path = "", parent_name = nil)
+          # Walks the routes map (recursing into nested and localized maps) and prints every matching route.
+          # Returns the number of routes that were actually printed.
+          private def process_routes_map(map, parent_path = "", parent_name = nil) : Int32
+            printed = 0
+
             map.rules.each do |rule|
               case rule
               when Marten::Routing::Rule::Path
-                print_path(rule, parent_path, parent_name)
+                printed += 1 if print_path(rule, parent_path, parent_name)
               when Marten::Routing::Rule::Map
                 rule_name = parent_name ? "#{parent_name}:#{rule.name}" : rule.name
                 rule_path = parent_path + resolve_path(rule.path)
-                process_routes_map(rule.map, parent_path: rule_path, parent_name: rule_name)
+                printed += process_routes_map(rule.map, parent_path: rule_path, parent_name: rule_name)
               when Marten::Routing::Rule::Localized
                 rule.rules.each do |localized_rule|
                   case localized_rule
                   when Marten::Routing::Rule::Path
-                    print_path(localized_rule, "/<locale>", nil)
+                    printed += 1 if print_path(localized_rule, "/<locale>", nil)
                   when Marten::Routing::Rule::Map
                     rule_name = parent_name ? "#{parent_name}:#{localized_rule.name}" : localized_rule.name
                     rule_path = "/<locale>" + parent_path + resolve_path(localized_rule.path)
-                    process_routes_map(localized_rule.map, parent_path: rule_path, parent_name: rule_name)
+                    printed += process_routes_map(localized_rule.map, parent_path: rule_path, parent_name: rule_name)
                   end
                 end
               end
             end
+
+            printed
           end
 
-          private def print_path(rule, parent_path, parent_name)
-            parts = [] of String
+          # Prints the given route unless it is filtered out. Returns `true` when the route was printed.
+          private def print_path(rule, parent_path, parent_name) : Bool
             empty_parent_name = parent_name.nil? || parent_name.empty?
 
-            parts << style(parent_path + resolve_path(rule.path), fore: :light_blue)
-            parts << style("[#{empty_parent_name ? rule.name : "#{parent_name}:#{rule.name}"}]", fore: :light_yellow)
+            full_path = parent_path + resolve_path(rule.path)
+            full_name = empty_parent_name ? rule.name : "#{parent_name}:#{rule.name}"
+
+            return false unless matches_filter?(full_path, full_name)
+
+            parts = [] of String
+            parts << style(full_path, fore: :light_blue)
+            parts << style("[#{full_name}]", fore: :light_yellow)
             parts << "›"
             parts << style(rule.handler.name, fore: :light_green)
 
@@ -47,6 +76,15 @@ module Marten
             end
 
             print(parts.join(" "))
+
+            true
+          end
+
+          private def matches_filter?(path : String, name : String) : Bool
+            return true unless filter?
+
+            pattern = filter.downcase
+            path.downcase.includes?(pattern) || name.downcase.includes?(pattern)
           end
 
           private def resolve_path(path) : String