chusaku 0.2.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be8c03a0fe70a6b717b8fb204ae3d2d1b9eaaa89597c7ada8c169cb49919d2ef
-  data.tar.gz: 28736b04b639cba7eed34695691433a0cf4defd3f48eaf7a15faced2e04540e8
+  metadata.gz: ed6577989b6ceef5334bd9217f5128b9178792f9b633c7ec7f284263f64cd415
+  data.tar.gz: a50d72e4e772fc7848606ef5d6772ce434c881d71fe6dc3a4cff928cceb188db
 SHA512:
-  metadata.gz: 178db8776a7bfeaccbe2eea70346753cf203531c7836f706988a65c3527ac6de733580ed6e324f93658fbbeec4812fff9196f460985abdab140eea99e794ab61
-  data.tar.gz: f8307518e4df5d74a3c5703efed73f167138c04ae2a0d2a1f314c16bc0b1e6d101c64355d994349dc238be2a486745dbea4703389bf485dbb681412e03ae21f8
+  metadata.gz: da939ea2a2d76601994dee78c46ece98f2b03d2f7740f93b0d990972693a97a2125910c8a3b9bd035410088fd29ad13f65010afb7b37c1bafc48329601812294
+  data.tar.gz: c73cbde3d26058fb72795513d081159e5d5e43beecd8903ebf2c19b40b71b06b76ac3c381ab26485ae08d7ac9fca30f4246c51ee9d3b0cc445baa54d08511403

data/.codeclimate.yml

@@ -0,0 +1,4 @@
+plugins:
+  rubocop:
+    enabled: true
+    channel: rubocop-0-77

data/.rubocop.yml

@@ -1,27 +1,27 @@
+require:
+  - rubocop-performance
+
 AllCops:
   Exclude:
     - 'bin/**/*'
+    - 'test/mock/app/**/*'
+    - 'test/mock/examples/**/*'
 
-Layout/IndentationConsistency:
-  EnforcedStyle: rails
+Layout/LineLength:
+  Max: 120
 
 Metrics/AbcSize:
-  Enabled: false
+  Exclude:
+    - 'test/**/*'
 
 Metrics/MethodLength:
-  Enabled: false
-
-Metrics/PerceivedComplexity:
-  Enabled: false
-
-Style/ClassVars:
-  Enabled: false
-
-Style/CommentedKeyword:
-  Enabled: false
+  Max: 25
+  Exclude:
+    - 'test/**/*'
 
-Style/Documentation:
-  Enabled: false
+Metrics/ModuleLength:
+  Max: 250
 
-Style/RegexpLiteral:
-  Enabled: false
+Style/ClassAndModuleChildren:
+  Exclude:
+    - 'test/**/*'

data/README.md

@@ -1,8 +1,8 @@
 # Chusaku
 
-| Build | Gem |
-|-------|-----|
-|[![CircleCI](https://circleci.com/gh/nshki/chusaku.svg?style=svg&circle-token=e1917972632f242932171de0ca5443148e83151c)](https://circleci.com/gh/nshki/chusaku)|[![Gem Version](https://badge.fury.io/rb/chusaku.svg)](https://badge.fury.io/rb/chusaku)|
+| Gem | CI | Quality |
+|-----|----|---------|
+|[![Gem Version](https://badge.fury.io/rb/chusaku.svg)](https://badge.fury.io/rb/chusaku)|[![CircleCI](https://circleci.com/gh/nshki/chusaku.svg?style=svg&circle-token=e1917972632f242932171de0ca5443148e83151c)](https://circleci.com/gh/nshki/chusaku)|[![Maintainability](https://api.codeclimate.com/v1/badges/e21235bd513aadf0407b/maintainability)](https://codeclimate.com/github/nshki/chusaku/maintainability)
 
 Add comments above your Rails actions that look like:
 
@@ -61,8 +61,20 @@ Usage: chusaku [options]
     -h, --help                       Show this help message and quit
 ```
 
-If you'd like to use Chusaku as a Git hook, take a look at
-[Lefthook](https://github.com/Arkweid/lefthook).
+
+## Pre-commit Hook
+
+Here's an example setup that you could use for automating Chusaku as a Git hook
+with the [Lefthook](https://github.com/Arkweid/lefthook) gem.
+
+```yaml
+pre-commit:
+  commands:
+    chusaku:
+      run: eval "! git diff --staged --name-only | grep -q 'routes.rb' && exit 0 || bundle exec chusaku --exit-with-error-on-annotation"
+```
+
+This example config only runs Chusaku if `routes.rb` was modified.
 
 
 ## Development

data/chusaku.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.name = 'chusaku'
   spec.version = Chusaku::VERSION
   spec.authors = ['Nishiki Liu']
-  spec.email = ['nishiki.liu@gmail.com']
+  spec.email = ['nishiki@hey.com']
 
   spec.summary = 'Annotate your Rails controllers with route info.'
   spec.description = 'Annotate your Rails controllers with route info.'
@@ -37,13 +37,15 @@ Gem::Specification.new do |spec|
       f.match(%r{^(test|spec|features)/})
     end
   end
-  spec.bindir        = 'bin'
-  spec.executables   = 'chusaku'
+  spec.bindir = 'bin'
+  spec.executables = 'chusaku'
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 2.0'
-  spec.add_development_dependency 'minitest', '~> 5.0'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'bundler', '~> 2.2'
+  spec.add_development_dependency 'minitest', '~> 5.14'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rubocop', '~> 1.7'
+  spec.add_development_dependency 'rubocop-performance', '~> 1.9'
 
-  spec.add_dependency 'rails', '> 2.0'
+  spec.add_dependency 'railties', '>= 3.0'
 end

data/lib/chusaku.rb

@@ -4,106 +4,163 @@ require 'chusaku/version'
 require 'chusaku/parser'
 require 'chusaku/routes'
 
+# Handles core functionality of annotating projects.
 module Chusaku
-  # The main method to run Chusaku. Annotate all actions in your Rails project
-  # as follows:
-  #
-  #   # @route GET /waterlilies/:id (waterlilies)
-  #   def show
-  #     # ...
-  #   end
-  #
-  # @param {Array<String>} args - CLI flags
-  # @return {Integer} 0 on success, 1 on error
-  def self.call(args = [])
-    routes = Chusaku::Routes.call
-    controller_pattern = 'app/controllers/**/*_controller.rb'
-    controller_paths = Dir.glob(Rails.root.join(controller_pattern))
-    annotated_paths = []
-
-    # Loop over all controller file paths.
-    controller_paths.each do |path|
-      controller = /controllers\/(.*)_controller\.rb/.match(path)[1]
-      actions = routes[controller]
-      next if actions.nil?
-
-      # Parse the file and iterate over the parsed content, two entries at a
-      # time.
-      parsed_file = Chusaku::Parser.call(path: path, actions: actions.keys)
-      parsed_file[:groups].each_cons(2) do |prev, curr|
-        # Remove all @route comments in the previous group.
-        if prev[:type] == :comment
-          prev[:body] = prev[:body].gsub(/^\s*#\s*@route.*$\n/, '')
-        end
+  class << self
+    # The main method to run Chusaku. Annotate all actions in a Rails project as
+    # follows:
+    #
+    #   # @route GET /waterlilies/:id (waterlilies)
+    #   def show
+    #     # ...
+    #   end
+    #
+    # @param flags [Hash] CLI flags
+    # @return [Integer] 0 on success, 1 on error
+    def call(flags = {})
+      @flags = flags
+      @routes = Chusaku::Routes.call
+      @annotated_paths = []
+      controllers_pattern = 'app/controllers/**/*_controller.rb'
+
+      Dir.glob(Rails.root.join(controllers_pattern)).each do |path|
+        controller = %r{controllers\/(.*)_controller\.rb}.match(path)[1]
+        actions = @routes[controller]
+        next if actions.nil?
+
+        annotate_file(path: path, controller: controller, actions: actions.keys)
+      end
 
-        # Only proceed if we are currently looking at an action.
+      output_results
+    end
+
+    private
+
+    # Adds annotations to the given file.
+    #
+    # @param path [String] Path to file
+    # @param controller [String] Controller name
+    # @param actions [Array<String>] List of valid actions for the controller
+    # @return [void]
+    def annotate_file(path:, controller:, actions:)
+      parsed_file = Chusaku::Parser.call(path: path, actions: actions)
+      parsed_file[:groups].each_cons(2) do |prev, curr|
+        clean_group(prev)
         next unless curr[:type] == :action
 
-        # Fetch current action in routes.
-        action = curr[:action]
-        data = routes[controller][action]
-        next unless data.any?
-
-        # Add annotations.
-        whitespace = /^(\s*).*$/.match(curr[:body])[1]
-        data.reverse.each do |datum|
-          annotation = annotate(datum)
-          comment = "#{whitespace}# #{annotation}\n"
-          curr[:body] = comment + curr[:body]
-        end
+        route_data = @routes[controller][curr[:action]]
+        next unless route_data.any?
+
+        annotate_group(group: curr, route_data: route_data)
       end
 
-      # Write to file.
-      parsed_content = parsed_file[:groups].map { |pf| pf[:body] }
-      new_content = parsed_content.join
-      if parsed_file[:content] != new_content
-        write(path, new_content) unless args.include?(:dry)
-        annotated_paths << path
+      write_to_file(path: path, parsed_file: parsed_file)
+    end
+
+    # Given a parsed group, clean out its contents.
+    #
+    # @param group [Hash] { type => Symbol, body => String }
+    # @return {void}
+    def clean_group(group)
+      return unless group[:type] == :comment
+
+      group[:body] = group[:body].gsub(/^\s*#\s*@route.*$\n/, '')
+      group[:body] =
+        group[:body].gsub(%r{^\s*# (GET|POST|PATCH\/PUT|DELETE) \/\S+$\n}, '')
+    end
+
+    # Add an annotation to the given group given by Chusaku::Parser that looks
+    # like:
+    #
+    #   @route GET /waterlilies/:id (waterlilies)
+    #
+    # @param group [Hash] Parsed content given by Chusaku::Parser
+    # @param route_data [Hash] Individual route data given by Chusaku::Routes
+    # @return [void]
+    def annotate_group(group:, route_data:)
+      whitespace = /^(\s*).*$/.match(group[:body])[1]
+      route_data.reverse_each do |datum|
+        comment = "#{whitespace}# #{annotate_route(**datum)}\n"
+        group[:body] = comment + group[:body]
       end
     end
 
-    # Output results to user.
-    if annotated_paths.any?
-      puts "Annotated #{annotated_paths.join(', ')}"
-      if args.include?(:error_on_annotation)
-        1
-      else
-        0
+    # Generate route annotation.
+    #
+    # @param verb [String] HTTP verb for route
+    # @param path [String] Rails path for route
+    # @param name [String] Name used in route helpers
+    # @param defaults [Hash] Default parameters for route
+    # @return [String] "@route <verb> <path> {<defaults>} (<name>)"
+    def annotate_route(verb:, path:, name:, defaults:)
+      annotation = "@route #{verb} #{path}"
+      if defaults&.any?
+        defaults_str =
+          defaults
+          .map { |key, value| "#{key}: #{value.inspect}" }
+          .join(', ')
+        annotation += " {#{defaults_str}}"
       end
-    else
-      puts "Nothing to annotate"
-      0
+      annotation += " (#{name})" unless name.nil?
+      annotation
     end
-  end
 
-  # Write given content to a file. If we're using an overridden version of File,
-  # then use its method instead for testing purposes.
-  #
-  # @param {String} path - File path to write to
-  # @param {String} content - Contents of the file
-  # @return {void}
-  def self.write(path, content)
-    File.open(path, 'r+') do |file|
-      if file.respond_to?(:test_write)
-        file.test_write(content, path)
-      else
-        file.write(content)
+    # Write annotated content to a file if it differs from the original.
+    #
+    # @param path [String] File path to write to
+    # @param parsed_file [Hash] Hash mutated by {#annotate_group}
+    # @return [void]
+    def write_to_file(path:, parsed_file:)
+      new_content = new_content_for(parsed_file)
+      return unless parsed_file[:content] != new_content
+
+      !@flags.include?(:dry) && perform_write(path: path, content: new_content)
+      @annotated_paths.push(path)
+    end
+
+    # Extracts the new file content for the given parsed file.
+    #
+    # @param parsed_file [Hash] { groups => Array<Hash> }
+    # @return [String] New file content
+    def new_content_for(parsed_file)
+      parsed_file[:groups].map { |pf| pf[:body] }.join
+    end
+
+    # Wraps the write operation. Needed to clearly distinguish whether it's a
+    # write in the test suite or a write in actual use.
+    #
+    # @param path [String] File path
+    # @param content [String] File content
+    # @return [void]
+    def perform_write(path:, content:)
+      File.open(path, file_mode) do |file|
+        if file.respond_to?(:test_write)
+          file.test_write(content, path)
+        else
+          file.write(content)
+        end
       end
     end
-  end
 
-  # Given a hash describing an action, generate an annotation in the form:
-  #
-  #   @route GET /waterlilies/:id (waterlilies)
-  #
-  # @param {Hash} action_info - Parsed line given by Chusaku::Parser
-  # @return {String} Annotation for given parsed line
-  def self.annotate(action_info)
-    verb = action_info[:verb]
-    path = action_info[:path]
-    name = action_info[:name]
-    annotation = "@route #{verb} #{path}"
-    annotation += " (#{name})" unless name.nil?
-    annotation
+    # When running the test suite, we want to make sure we're not overwriting
+    # any files. `r` mode ensures that, and `w` is used for actual usage.
+    #
+    # @return [String] 'r' or 'w'
+    def file_mode
+      File.instance_methods.include?(:test_write) ? 'r' : 'w'
+    end
+
+    # Output results to user.
+    #
+    # @return [Integer] 0 for success, 1 for error
+    def output_results
+      if @annotated_paths.any?
+        puts("Annotated #{@annotated_paths.join(', ')}")
+        @flags.include?(:error_on_annotation) ? 1 : 0
+      else
+        puts('Nothing to annotate')
+        0
+      end
+    end
   end
 end

data/lib/chusaku/cli.rb

@@ -4,26 +4,27 @@ require 'optparse'
 require 'chusaku'
 
 module Chusaku
+  # Enables flags for the `chusaku` executable.
   class CLI
+    attr_reader :options
+
     STATUS_SUCCESS = 0
     STATUS_ERROR = 1
 
-    attr_reader :options
-
     Finished = Class.new(RuntimeError)
     NotARailsProject = Class.new(RuntimeError)
 
-    # Initializes a new instance of Chusaku::CLI.
+    # Initializes a new instance of `Chusaku::CLI`.
     #
-    # @return {Chusaku::CLI} Instance of this class
+    # @return [Chusaku::CLI] Instance of this class
     def initialize
       @options = {}
     end
 
     # Parse CLI flags, if any, and handle applicable behaviors.
     #
-    # @param {Array<String>} args - CLI arguments
-    # @return {Integer} 0 on success, 1 on error
+    # @param args [Array<String>] CLI arguments
+    # @return [Integer] 0 on success, 1 on error
     def call(args = ARGV)
       optparser.parse!(args)
       check_for_rails_project
@@ -37,55 +38,83 @@ module Chusaku
 
     private
 
-      # Raises exception if Rails project cannot be detected.
-      #
-      # @raise {Chusaku::CLI::NotARailsProject} Exception if not Rails project
-      # @return {void}
-      def check_for_rails_project
-        unless File.directory?('./app/controllers') && File.exist?('./Rakefile')
-          raise NotARailsProject
-        end
-      end
+    # Raises exception if Rails project cannot be detected.
+    #
+    # @raise [Chusaku::CLI::NotARailsProject] Exception if not Rails project
+    # @return [void]
+    def check_for_rails_project
+      has_controllers = File.directory?('./app/controllers')
+      has_rakefile = File.exist?('./Rakefile')
+      raise NotARailsProject unless has_controllers && has_rakefile
+    end
 
-      # Returns an instance of OptionParser with supported flags.
-      #
-      # @return {OptionParser} Preconfigured OptionParser instance
-      def optparser
-        OptionParser.new do |opts|
-          opts.banner = 'Usage: chusaku [options]'
+    # Returns an instance of OptionParser with supported flags.
+    #
+    # @return [OptionParser] Preconfigured OptionParser instance
+    def optparser
+      OptionParser.new do |opts|
+        opts.banner = 'Usage: chusaku [options]'
+        add_error_on_annotation_flag(opts)
+        add_dry_run_flag(opts)
+        add_version_flag(opts)
+        add_help_flag(opts)
+      end
+    end
 
-          opts.on(
-            '--exit-with-error-on-annotation',
-            'Fail if any file was annotated'
-          ) do
-            @options[:error_on_annotation] = true
-          end
+    # Adds `--exit-with-error-on-annotation` flag.
+    #
+    # @param opts [OptionParser] OptionParser instance
+    # @return [void]
+    def add_error_on_annotation_flag(opts)
+      opts.on(
+        '--exit-with-error-on-annotation',
+        'Fail if any file was annotated'
+      ) do
+        @options[:error_on_annotation] = true
+      end
+    end
 
-          opts.on(
-            '--dry-run',
-            'Run without file modifications'
-          ) do
-            @options[:dry] = true
-          end
+    # Adds `--dry-run` flag.
+    #
+    # @param opts [OptionParser] OptionParser instance
+    # @return [void]
+    def add_dry_run_flag(opts)
+      opts.on(
+        '--dry-run',
+        'Run without file modifications'
+      ) do
+        @options[:dry] = true
+      end
+    end
 
-          opts.on(
-            '-v',
-            '--version',
-            'Show Chusaku version number and quit'
-          ) do
-            puts(Chusaku::VERSION)
-            raise Finished
-          end
+    # Adds `--version` flag.
+    #
+    # @param opts [OptionParser] OptionParser instance
+    # @return [void]
+    def add_version_flag(opts)
+      opts.on(
+        '-v',
+        '--version',
+        'Show Chusaku version number and quit'
+      ) do
+        puts(Chusaku::VERSION)
+        raise Finished
+      end
+    end
 
-          opts.on(
-            '-h',
-            '--help',
-            'Show this help message and quit'
-          ) do
-            puts(opts)
-            raise Finished
-          end
-        end
+    # Adds `--help` flag.
+    #
+    # @param opts [OptionParser] OptionParser instance
+    # @return [void]
+    def add_help_flag(opts)
+      opts.on(
+        '-h',
+        '--help',
+        'Show this help message and quit'
+      ) do
+        puts(opts)
+        raise Finished
       end
+    end
   end
 end

data/lib/chusaku/parser.rb

@@ -1,27 +1,41 @@
 # frozen_string_literal: true
 
 module Chusaku
+  # Handles parsing a file and groups its lines into categories.
   module Parser
-    # Parses a file and groups its lines into categories:
+    # Primary method to call.
     #
     # Example output:
     #
-    #   [ { type: :code,
-    #       body: 'class Foo\n',
-    #       action: nil },
-    #     { type: :comment,
-    #       body: '  # Bar\n  # Baz\n',
-    #       action: nil },
-    #     { type: :action,
-    #       body: '  def action_name; end\n',
-    #       action: 'action_name' }
-    #     { type: :code,
-    #       body: 'end # vanilla is the best flavor\n',
-    #       action: nil } ]
+    #   {
+    #     content: <Original file content>,
+    #     groups: [
+    #       {
+    #         type: :code,
+    #         body: 'class Foo\n',
+    #         action: nil
+    #       },
+    #       {
+    #         type: :comment,
+    #         body: '  # Bar\n  # Baz\n',
+    #         action: nil
+    #       },
+    #       {
+    #         type: :action,
+    #         body: '  def action_name; end\n',
+    #         action: 'action_name'
+    #       }
+    #       {
+    #         type: :code,
+    #         body: 'end # vanilla is the best flavor\n',
+    #         action: nil
+    #       }
+    #     ]
+    #   }
     #
-    # @param {String} path - File path to parse
-    # @param {Array<String>} actions - List of valid actions for this route
-    # @return {Hash} Parsed groups of the file and original content
+    # @param path [String] File path to parse
+    # @param actions [Array<String>] List of valid actions for this route
+    # @return [Hash] { content => String, groups => Array<Hash> }
     def self.call(path:, actions:)
       groups = []
       group = {}
@@ -43,26 +57,25 @@ module Chusaku
 
       # Push the last group onto the array and return.
       groups.push(group)
-      {
-        content: content,
-        groups: groups
-      }
+      { content: content, groups: groups }
     end
 
-    # Given a line and actions, returns the line's type:
+    # Given a line and actions, returns the line's type.
+    #
+    # A type can be one of:
     #
     #   1. comment - A line that is entirely commented. Lines that have trailing
     #                comments do not fall under this category.
     #   2. action  - A line that contains an action definition.
     #   3. code    - Anything else.
     #
-    # And give back a Hash in the form:
+    # Returns a Hash in the form:
     #
     #   { type: :action, body: 'def foo', action: 'foo' }
     #
-    # @param {String} line - A line of a file
-    # @param {Array<String>} actions - List of valid actions for this route
-    # @return {Hash} Parsed line
+    # @param line [String] A line of a file
+    # @param actions [Array<String>] List of valid actions for this route
+    # @return [Hash] { type => Symbol, body => String, action => String }
     def self.parse_line(line:, actions:)
       comment_match = /^\s*#.*$/.match(line)
       def_match = /^\s*def\s+(\w*)\s*\w*.*$/.match(line)

data/lib/chusaku/routes.rb

@@ -1,62 +1,103 @@
 # frozen_string_literal: true
 
 module Chusaku
-  module Routes
-    # Extract information about the Rails project's routes.
-    #
-    # Example output:
-    #
-    #   {
-    #     'users' => {
-    #       'edit' => [
-    #         { verb: 'GET', path: '/users/:id', name: 'edit_user' }],
-    #       'update' => [
-    #         { verb: 'PATCH', path: '/users', name: 'edit_user' },
-    #         { verb: 'PUT', path: '/users', name: 'edit_user' }]
-    #     },
-    #     'empanadas' => {
-    #       'create' => [
-    #         { verb: 'POST', path: '/empanadas', name: nil }]
-    #     }
-    #   }
-    #
-    # @return {Hash} Routes hash
-    def self.call
-      routes = {}
+  # Handles extracting information about the Rails project's routes.
+  class Routes
+    class << self
+      # Primary method to call.
+      #
+      # Example output:
+      #
+      #   {
+      #     'users' => {
+      #       'edit' => [
+      #         { verb: 'GET', path: '/users/:id', name: 'edit_user' }
+      #       ],
+      #       'update' => [
+      #         { verb: 'PATCH', path: '/users', name: 'edit_user' },
+      #         { verb: 'PUT', path: '/users', name: 'edit_user' }
+      #       ]
+      #     },
+      #     'empanadas' => {
+      #       'create' => [
+      #         { verb: 'POST', path: '/empanadas', name: nil }
+      #       ]
+      #     }
+      #   }
+      #
+      # @return [Hash] Routes hash
+      def call
+        routes = {}
 
-      Rails.application.routes.routes.each do |route|
-        defaults = route.defaults
-        controller = defaults[:controller]
-        action = defaults[:action]
+        Rails.application.routes.routes.each do |route|
+          controller, action, defaults = extract_data_from(route)
+          routes[controller] ||= {}
+          routes[controller][action] ||= []
+
+          add_info_for \
+            route: route,
+            routes: routes,
+            controller: controller,
+            action: action,
+            defaults: defaults
+        end
 
-        routes[controller] ||= {}
-        routes[controller][action] ||= []
-        routes[controller][action].push(format_route(route))
+        backfill_routes(routes)
       end
 
-      backfill_routes(routes)
-    end
+      private
 
-    private
+      # Adds formatted route info for the given param combination.
+      #
+      # @param route [Hash] Route info
+      # @param routes [Hash] Collection of all route info
+      # @param controller [String] Controller key
+      # @param action [String] Action key
+      # @param defaults [Hash] Default parameters for route
+      # @return [void]
+      def add_info_for(route:, routes:, controller:, action:, defaults:)
+        verbs_for(route).each do |verb|
+          routes[controller][action]
+            .push(format(route: route, verb: verb, defaults: defaults))
+          routes[controller][action].uniq!
+        end
+      end
 
-      # Extract information of a given route.
+      # Extract the HTTP verbs for a Rails route. Required for older versions of
+      # Rails that return regular expressions for a route verb which sometimes
+      # contains multiple verbs.
       #
-      # @param {ActionDispatch::Journey::Route} route - Route given by Rails
-      # @return {Hash} Formatted hash for given route
-      def self.format_route(route)
+      # @param route [ActionDispatch::Journey::Route] Route given by Rails
+      # @return [Array<String>] List of HTTP verbs for the given route
+      def verbs_for(route)
+        route_verb = route.verb.to_s
+
+        %w[GET POST PUT PATCH DELETE].select do |verb|
+          route_verb.include?(verb)
+        end
+      end
+
+      # Formats information for a given route.
+      #
+      # @param route [ActionDispatch::Journey::Route] Route given by Rails
+      # @param verb [String] HTTP verb
+      # @param defaults [Hash] Default parameters for route
+      # @return [Hash] { verb => String, path => String, name => String }
+      def format(route:, verb:, defaults:)
         {
-          verb: route.verb,
+          verb: verb,
           path: route.path.spec.to_s.gsub('(.:format)', ''),
-          name: route.name
+          name: route.name,
+          defaults: defaults
         }
       end
 
       # Given a routes hash, backfill entries that aren't already filled by
       # `Rails.application.routes`.
       #
-      # @param {Hash} routes - Routes hash generated by this class
-      # @return {Hash} Backfilled routes
-      def self.backfill_routes(routes)
+      # @param routes [Hash] Routes hash generated by this class
+      # @return [Hash] Backfilled routes hash
+      def backfill_routes(routes)
         paths = {}
 
         routes.each do |_controller, actions|
@@ -70,5 +111,18 @@ module Chusaku
 
         routes
       end
+
+      # Given a route, extract the controller and action strings.
+      #
+      # @param route [ActionDispatch::Journey::Route] Route instance
+      # @return [Array<Object>] (String, String, Hash)
+      def extract_data_from(route)
+        defaults = route.defaults.dup
+        controller = defaults.delete(:controller)
+        action = defaults.delete(:action)
+
+        [controller, action, defaults]
+      end
+    end
   end
 end

data/lib/chusaku/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Chusaku
-  VERSION = '0.2.0'
+  VERSION = '0.4.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chusaku
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Nishiki Liu
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-10-27 00:00:00.000000000 Z
+date: 2021-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,65 +16,94 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '5.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '5.14'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
 description: Annotate your Rails controllers with route info.
 email:
-- nishiki.liu@gmail.com
+- nishiki@hey.com
 executables:
 - chusaku
 extensions: []
 extra_rdoc_files: []
 files:
 - ".circleci/config.yml"
+- ".codeclimate.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - Gemfile
@@ -98,7 +127,7 @@ metadata:
   homepage_uri: https://github.com/nshki/chusaku
   source_code_uri: https://github.com/nshki/chusaku
   changelog_uri: https://github.com/nshki/chusaku
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -113,8 +142,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: Annotate your Rails controllers with route info.
 test_files: []