rubocop-canon 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ec9b67b96a586164140535f5e47bae25d02443a7f37094b0dd6fe8c2256d7d57
+  data.tar.gz: 79bebd07f1aec3b30061849a9c0166640eef0728756dc6eb477d47e17c5a9c69
+SHA512:
+  metadata.gz: 49faab8220e3b5c1fe4004566a664c19051848136a628245e7e30da3e5b072fed9b349089681831cd5efac7052e40dd788986e9827ee16569617c26a304b541c
+  data.tar.gz: d01f901f2b9748cf4617eb75a633930dd8c9049c1c45bd4c6379cce308ac1678f5fc41facb34a4d5da664b9ea1dbcfb5fbad15232eb90437921cf79f1fdea79b

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 skiftle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,56 @@
+# rubocop-canon
+
+Deterministic RuboCop cops that reduce Ruby code to canonical form. Given any input, there is exactly one correct output.
+
+## Cops
+
+| Cop | What it does |
+|-----|-------------|
+| `Canon/KeywordShorthand` | `foo(bar: bar)` becomes `foo(bar:)` |
+| `Canon/SortHash` | `{b: 1, a: 2}` becomes `{a: 2, b: 1}` |
+| `Canon/SortKeywords` | `method(z: 1, a: 2)` becomes `method(a: 2, z: 1)` |
+| `Canon/SortMethodArguments` | `attr_reader :z, :a` becomes `attr_reader :a, :z` |
+| `Canon/SortMethodDefinition` | `def foo(z:, a:)` becomes `def foo(a:, z:)` |
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'rubocop-canon', require: false
+```
+
+Add to your `.rubocop.yml`:
+
+```yaml
+plugins:
+  - rubocop-canon
+```
+
+## Configuration
+
+`Canon/SortHash` and the three sort cops accept:
+
+```yaml
+Canon/SortHash:
+  ShorthandsFirst: true     # shorthand pairs sort before expanded
+  ExcludeMethods:           # skip hashes inside these methods
+    - enum
+
+Canon/SortKeywords:
+  ShorthandsFirst: true
+  Methods:                  # only check these methods (required)
+    - attribute
+    - belongs_to
+
+Canon/SortMethodArguments:
+  Methods:                  # only check these methods (required)
+    - attr_reader
+    - delegate
+```
+
+`Canon/SortKeywords` and `Canon/SortMethodArguments` are disabled by default. They require a `Methods` list to function.
+
+## License
+
+MIT

data/config/default.yml

@@ -0,0 +1,29 @@
+Canon/KeywordShorthand:
+  Description: 'Use Ruby 3.1+ keyword shorthand where a local variable matches the key name.'
+  Enabled: true
+  VersionAdded: '0.1'
+
+Canon/SortHash:
+  Description: 'Sort hash keys alphabetically.'
+  Enabled: true
+  VersionAdded: '0.1'
+  ShorthandsFirst: false
+  ExcludeMethods: []
+
+Canon/SortKeywords:
+  Description: 'Sort keyword arguments in method calls alphabetically.'
+  Enabled: false
+  VersionAdded: '0.1'
+  ShorthandsFirst: false
+  Methods: []
+
+Canon/SortMethodArguments:
+  Description: 'Sort symbol arguments in method calls alphabetically.'
+  Enabled: false
+  VersionAdded: '0.1'
+  Methods: []
+
+Canon/SortMethodDefinition:
+  Description: 'Sort keyword arguments in method definitions alphabetically.'
+  Enabled: true
+  VersionAdded: '0.1'

data/lib/rubocop/canon/plugin.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'lint_roller'
+
+module RuboCop
+  module Canon
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(
+          description: 'Deterministic RuboCop cops for canonical Ruby form.',
+          homepage: 'https://github.com/skiftle/rubocop-canon',
+          name: 'rubocop-canon',
+          version: VERSION,
+        )
+      end
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(_context)
+        project_root = Pathname.new(__dir__).join('../../..')
+        LintRoller::Rules.new(
+          config_format: :rubocop,
+          type: :path,
+          value: project_root.join('config', 'default.yml'),
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/canon/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Canon
+    VERSION = '0.1.0'
+  end
+end

data/lib/rubocop/cop/canon/keyword_shorthand.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Canon
+      # Enforces Ruby 3 keyword shorthand (`foo(bar:)`) where a keyword argument
+      # uses a local variable with the same name (`foo(bar: bar)`).
+      #
+      # Safe-by-design: only symbol keys and local variables with matching names
+      # are considered. Comments on the same line are ignored to avoid unintended
+      # changes.
+      #
+      # Requires TargetRubyVersion >= 3.1.
+      #
+      # @example
+      #   # bad
+      #   DomainIssueMapper.call(@record, locale_key: locale_key, root_path: root_path)
+      #   options = { locale_key: locale_key, root_path: root_path }
+      #
+      #   # good
+      #   DomainIssueMapper.call(@record, locale_key:, root_path:)
+      #   options = { locale_key:, root_path: }
+      #
+      class KeywordShorthand < Base
+        extend AutoCorrector
+
+        MSG = 'Use Ruby 3 keyword shorthand `%<name>s:` instead of `%<name>s: %<name>s`.'
+
+        def on_pair(node)
+          return unless shorthand_candidate?(node)
+          return if comment_on_line?(node)
+
+          name = key_name(node)
+          add_offense(node, message: format(MSG, name:)) do |corrector|
+            corrector.replace(node.source_range, "#{name}:")
+          end
+        end
+
+        private
+
+        def shorthand_candidate?(node)
+          return false unless node.colon?
+          return false unless node.key.sym_type?
+          return false unless node.value.lvar_type?
+          return false unless key_name(node) == value_name(node)
+          return false if already_shorthand?(node)
+          return false if last_kwarg_before_modifier?(node)
+          return false if last_kwarg_before_block?(node)
+
+          true
+        end
+
+        def last_kwarg_before_modifier?(node)
+          hash_node = node.parent
+          return false unless hash_node&.hash_type?
+
+          send_node = hash_node.parent
+          return false unless send_node&.send_type? || send_node&.csend_type?
+
+          parent_of_send = send_node.parent
+          return false unless parent_of_send
+          return false unless %i[if while until].include?(parent_of_send.type)
+          return false unless parent_of_send.loc.respond_to?(:keyword) && parent_of_send.loc.keyword.source != 'elsif'
+
+          modifier_form = parent_of_send.loc.respond_to?(:end) && parent_of_send.loc.end.nil?
+          return false unless modifier_form
+
+          node == hash_node.pairs.last
+        end
+
+        def last_kwarg_before_block?(node)
+          hash_node = node.parent
+          return false unless hash_node&.hash_type?
+
+          send_node = hash_node.parent
+          return false unless send_node&.send_type? || send_node&.csend_type?
+
+          parent_of_send = send_node.parent
+          return false unless parent_of_send&.block_type?
+
+          node == hash_node.pairs.last
+        end
+
+        def already_shorthand?(node)
+          node.source.strip.end_with?(':')
+        end
+
+        def key_name(node)
+          node.key.value.to_s
+        end
+
+        def value_name(node)
+          node.value.children.first.to_s
+        end
+
+        def comment_on_line?(node)
+          line = node.loc.line
+          processed_source.comments.any? { |comment| comment.loc.line == line }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/canon/sort_hash.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Canon
+      # Enforces sorted hash literals.
+      #
+      # Sorts hash keys alphabetically without changing structure.
+      # Single-line hashes stay single-line, multiline stay multiline.
+      #
+      # @example
+      #   # bad
+      #   {b: 1, a: 2}
+      #
+      #   # good (sorted)
+      #   {a: 2, b: 1}
+      #
+      #   # bad (unsorted multiline)
+      #   {
+      #     c: 3,
+      #     a: 1,
+      #     b: 2,
+      #   }
+      #
+      #   # good (sorted multiline)
+      #   {
+      #     a: 1,
+      #     b: 2,
+      #     c: 3,
+      #   }
+      class SortHash < Base
+        extend AutoCorrector
+
+        MSG = 'Sort hash keys alphabetically.'
+
+        def on_hash(node)
+          return unless processable?(node)
+
+          pairs = node.pairs
+          return if pairs.size < 2
+
+          sorted_pairs = sort_pairs(pairs)
+          return if pairs == sorted_pairs
+
+          add_offense(node) do |corrector|
+            next if ancestor_unsorted_hash?(node)
+
+            if already_multiline?(node)
+              if implicit_kwargs?(node)
+                corrector.replace(node.loc.expression, rebuild_multiline_implicit(node, sorted_pairs))
+              else
+                corrector.replace(node.loc.expression, rebuild_multiline(node, sorted_pairs))
+              end
+            else
+              corrector.replace(content_range(node), rebuild_single_line(node, sorted_pairs))
+            end
+          end
+        end
+
+        private
+
+        def processable?(node)
+          pairs = node.pairs
+          return false if pairs.empty?
+          return false unless all_symbol_keys?(pairs)
+          return false if kwsplat?(node)
+          return false if duplicate_keys?(pairs)
+          return false if excluded_method?(node)
+
+          true
+        end
+
+        def excluded_method?(node)
+          parent = node.parent
+          return false unless parent&.send_type?
+
+          excluded_methods.include?(parent.method_name.to_s)
+        end
+
+        def excluded_methods
+          cop_config['ExcludeMethods'] || []
+        end
+
+        def all_symbol_keys?(pairs)
+          pairs.all? { |pair| pair.key.sym_type? }
+        end
+
+        def kwsplat?(node)
+          node.children.any? { |child| child.is_a?(Parser::AST::Node) && child.kwsplat_type? }
+        end
+
+        def duplicate_keys?(pairs)
+          keys = pairs.map { |pair| key_name(pair) }
+          keys.size != keys.uniq.size
+        end
+
+        def multiline_value?(pairs)
+          pairs.any? { |pair| pair.value.loc.first_line != pair.value.loc.last_line }
+        end
+
+        def implicit_kwargs?(node)
+          node.loc.begin.nil?
+        end
+
+        def single_line?(node)
+          node.loc.expression.first_line == node.loc.expression.last_line
+        end
+
+        def already_multiline?(node)
+          !single_line?(node)
+        end
+
+        def key_name(pair)
+          pair.key.value.to_s
+        end
+
+        def sort_pairs(pairs)
+          if shorthands_first?
+            pairs.sort_by { |pair| [shorthand?(pair) ? 0 : 1, key_name(pair)] }
+          else
+            pairs.sort_by { |pair| key_name(pair) }
+          end
+        end
+
+        def shorthands_first?
+          cop_config['ShorthandsFirst'] == true
+        end
+
+        def shorthand?(pair)
+          pair.source.match?(/\A\w+:\z/)
+        end
+
+        def content_range(node)
+          if node.loc.begin
+            Parser::Source::Range.new(
+              node.loc.expression.source_buffer,
+              node.loc.begin.end_pos,
+              node.loc.end.begin_pos,
+            )
+          else
+            node.loc.expression
+          end
+        end
+
+        def rebuild_single_line(node, sorted_pairs)
+          content = sorted_pairs.map(&:source).join(', ')
+          return content unless node.loc.begin
+
+          original_content = content_range(node).source
+          has_leading_space = original_content.start_with?(' ')
+          has_trailing_space = original_content.end_with?(' ')
+
+          result = content
+          result = " #{result}" if has_leading_space
+          result = "#{result} " if has_trailing_space
+          result
+        end
+
+        def rebuild_multiline(node, sorted_pairs)
+          indent = base_indentation(node)
+          pair_indent = pair_indentation(node)
+
+          lines = ["{\n"]
+          sorted_pairs.each_with_index do |pair, index|
+            trailing_comma = index < sorted_pairs.size - 1 || trailing_comma?(node)
+            lines << "#{pair_indent}#{pair.source}#{trailing_comma ? ',' : ''}\n"
+          end
+          lines << "#{indent}}"
+
+          lines.join
+        end
+
+        def rebuild_multiline_implicit(node, sorted_pairs)
+          first_pair = node.pairs.first
+          indent = ' ' * first_pair.loc.column
+
+          sorted_pairs.map.with_index do |pair, index|
+            if index.zero?
+              pair.source
+            else
+              "#{indent}#{pair.source}"
+            end
+          end.join(",\n")
+        end
+
+        def base_indentation(node)
+          source_line = node.loc.expression.source_buffer.source_line(node.loc.line)
+          source_line[/\A\s*/]
+        end
+
+        def pair_indentation(node)
+          first_pair = node.pairs.first
+          source_line = first_pair.loc.expression.source_buffer.source_line(first_pair.loc.line)
+          source_line[/\A\s*/]
+        end
+
+        def trailing_comma?(node)
+          last_pair = node.pairs.last
+          source_after_last = node.loc.expression.source[last_pair.loc.expression.end_pos - node.loc.expression.begin_pos..]
+          source_after_last&.match?(/\A\s*,/)
+        end
+
+        def ancestor_unsorted_hash?(node)
+          node.ancestors.any? do |ancestor|
+            next false unless ancestor.hash_type?
+
+            pairs = ancestor.pairs
+            next false if pairs.size < 2
+            next false unless all_symbol_keys?(pairs)
+            next false if kwsplat?(ancestor)
+            next false if duplicate_keys?(pairs)
+
+            sort_pairs(pairs) != pairs
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/canon/sort_keywords.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Canon
+      # Enforces sorted keyword arguments in method calls.
+      #
+      # Sorts keyword arguments alphabetically without changing structure.
+      # Single-line calls stay single-line, multiline stay multiline.
+      #
+      # @example
+      #   # bad
+      #   attribute :name, zebra: true, alpha: false
+      #
+      #   # good (sorted)
+      #   attribute :name, alpha: false, zebra: true
+      #
+      #   # bad (unsorted multiline)
+      #   attribute :name,
+      #             zebra: true,
+      #             alpha: false
+      #
+      #   # good (sorted multiline)
+      #   attribute :name,
+      #             alpha: false,
+      #             zebra: true
+      class SortKeywords < Base
+        extend AutoCorrector
+
+        MSG = 'Sort keyword arguments alphabetically.'
+
+        def on_send(node)
+          return unless dsl_method?(node)
+          return if node.receiver
+
+          kwargs = extract_kwargs(node)
+          return if kwargs.nil? || kwargs.size < 2
+
+          sorted_kwargs = sort_pairs(kwargs)
+          return if kwargs == sorted_kwargs
+
+          add_offense(node) do |corrector|
+            corrector.replace(kwargs_range(kwargs), rebuild(kwargs, sorted_kwargs))
+          end
+        end
+
+        private
+
+        def dsl_method?(node)
+          methods.include?(node.method_name.to_s)
+        end
+
+        def methods
+          cop_config['Methods'] || []
+        end
+
+        def extract_kwargs(node)
+          return nil if node.arguments.empty?
+
+          last_arg = node.arguments.last
+          return last_arg.pairs if last_arg.hash_type? && last_arg.pairs.any?
+
+          nil
+        end
+
+        def key_name(pair)
+          pair.key.value.to_s
+        end
+
+        def sort_pairs(pairs)
+          if shorthands_first?
+            pairs.sort_by { |pair| [shorthand?(pair) ? 0 : 1, key_name(pair)] }
+          else
+            pairs.sort_by { |pair| key_name(pair) }
+          end
+        end
+
+        def shorthands_first?
+          cop_config['ShorthandsFirst'] == true
+        end
+
+        def shorthand?(pair)
+          pair.source.match?(/\A\w+:\z/)
+        end
+
+        def kwargs_range(kwargs)
+          Parser::Source::Range.new(
+            kwargs.first.loc.expression.source_buffer,
+            kwargs.first.loc.expression.begin_pos,
+            kwargs.last.loc.expression.end_pos,
+          )
+        end
+
+        def rebuild(original_kwargs, sorted_kwargs)
+          if multiline?(original_kwargs)
+            rebuild_multiline(original_kwargs, sorted_kwargs)
+          else
+            rebuild_single_line(sorted_kwargs)
+          end
+        end
+
+        def multiline?(kwargs)
+          kwargs.first.loc.line != kwargs.last.loc.line
+        end
+
+        def rebuild_single_line(sorted_kwargs)
+          sorted_kwargs.map(&:source).join(', ')
+        end
+
+        def rebuild_multiline(original_kwargs, sorted_kwargs)
+          first_pair = original_kwargs.first
+          indent = ' ' * first_pair.loc.column
+
+          sorted_kwargs.map.with_index do |pair, index|
+            if index.zero?
+              pair.source
+            else
+              "#{indent}#{pair.source}"
+            end
+          end.join(",\n")
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/canon/sort_method_arguments.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Canon
+      # Enforces sorted symbol arguments in method calls.
+      #
+      # Applies to methods like attr_reader, attr_accessor, delegate.
+      # Sorts symbol arguments alphabetically without changing structure.
+      # Single-line calls stay single-line, multiline stay multiline.
+      #
+      # @example
+      #   # bad
+      #   attr_reader :zebra, :alpha
+      #
+      #   # good (sorted)
+      #   attr_reader :alpha, :zebra
+      #
+      #   # bad (unsorted multiline)
+      #   attr_reader :zebra,
+      #               :alpha
+      #
+      #   # good (sorted multiline)
+      #   attr_reader :alpha,
+      #               :zebra
+      class SortMethodArguments < Base
+        extend AutoCorrector
+
+        MSG = 'Sort symbol arguments alphabetically.'
+
+        def on_send(node)
+          return unless methods.include?(node.method_name.to_s)
+          return if node.receiver
+
+          symbol_args = node.arguments.select(&:sym_type?)
+          return unless symbol_args.size > 1
+
+          sorted_names = symbol_args.map { |arg| arg.value.to_s }.sort
+          actual_names = symbol_args.map { |arg| arg.value.to_s }
+
+          return if actual_names == sorted_names
+
+          add_offense(node.loc.selector) do |corrector|
+            corrector.replace(node.loc.expression, build_replacement(node, sorted_names))
+          end
+        end
+
+        private
+
+        def methods
+          cop_config['Methods'] || []
+        end
+
+        def single_line?(node)
+          expr = node.loc.expression
+          expr.first_line == expr.last_line
+        end
+
+        def build_replacement(node, sorted_names)
+          if single_line?(node)
+            build_single_line(node, sorted_names)
+          else
+            build_multiline(node, sorted_names)
+          end
+        end
+
+        def build_single_line(node, sorted_names)
+          trailing_kwargs = node.arguments.reject(&:sym_type?)
+          symbols = sorted_names.map { |name| ":#{name}" }.join(', ')
+
+          if trailing_kwargs.empty?
+            "#{node.method_name} #{symbols}"
+          else
+            kwargs = trailing_kwargs.map(&:source).join(', ')
+            "#{node.method_name} #{symbols}, #{kwargs}"
+          end
+        end
+
+        def build_multiline(node, sorted_names)
+          method_name = node.method_name.to_s
+          first_line_prefix = "#{method_name} "
+          cont_indent = ' ' * (node.loc.column + first_line_prefix.length)
+
+          lines = sorted_names.map.with_index do |name, index|
+            prefix = index.zero? ? first_line_prefix : cont_indent
+            comma = index < sorted_names.size - 1 ? ',' : ''
+            "#{prefix}:#{name}#{comma}"
+          end
+
+          trailing_kwargs = node.arguments.reject(&:sym_type?)
+          if trailing_kwargs.any?
+            lines[-1] += ','
+            trailing_kwargs.each do |kwarg|
+              lines << "#{cont_indent}#{kwarg.source}"
+            end
+          end
+
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/canon/sort_method_definition.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Canon
+      # Enforces sorted keyword arguments in method definitions.
+      #
+      # Only applies to single-line kwargs. Multiline kwargs are ignored
+      # to preserve intentional formatting.
+      #
+      # @example
+      #   # bad
+      #   def foo(zebra:, alpha:)
+      #
+      #   # good (sorted)
+      #   def foo(alpha:, zebra:)
+      class SortMethodDefinition < Base
+        extend AutoCorrector
+
+        MSG = 'Sort keyword arguments alphabetically.'
+
+        def on_def(node)
+          check_method_definition(node)
+        end
+
+        def on_defs(node)
+          check_method_definition(node)
+        end
+
+        private
+
+        def check_method_definition(node)
+          kwargs = extract_kwargs(node.arguments)
+          return if kwargs.size < 2
+          return if kwrestarg?(node.arguments)
+          return unless single_line?(kwargs)
+
+          sorted_names = kwargs.map { |arg| arg.name.to_s }.sort
+          actual_names = kwargs.map { |arg| arg.name.to_s }
+
+          return if sorted_names == actual_names
+
+          add_offense(node.loc.keyword) do |corrector|
+            replace_range = kwargs_range(kwargs)
+            corrector.replace(replace_range, rebuild_kwargs(node.arguments, sorted_names))
+          end
+        end
+
+        def extract_kwargs(args)
+          args.select { |arg| arg.kwoptarg_type? || arg.kwarg_type? }
+        end
+
+        def kwrestarg?(args)
+          args.any?(&:kwrestarg_type?)
+        end
+
+        def single_line?(items)
+          return true if items.empty?
+
+          items.first.loc.line == items.last.loc.line
+        end
+
+        def kwargs_range(kwargs)
+          Parser::Source::Range.new(
+            kwargs.first.loc.expression.source_buffer,
+            kwargs.first.loc.expression.begin_pos,
+            kwargs.last.loc.expression.end_pos,
+          )
+        end
+
+        def rebuild_kwargs(args, sorted_names)
+          kwargs_hash = {}
+
+          args.each do |arg|
+            next unless arg.kwoptarg_type? || arg.kwarg_type?
+
+            kwargs_hash[arg.name.to_s] = arg.source
+          end
+
+          sorted_names.map { |name| kwargs_hash[name] }.join(', ')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop-canon.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+require_relative 'rubocop/canon/version'
+require_relative 'rubocop/canon/plugin'
+require_relative 'rubocop/cop/canon/keyword_shorthand'
+require_relative 'rubocop/cop/canon/sort_hash'
+require_relative 'rubocop/cop/canon/sort_keywords'
+require_relative 'rubocop/cop/canon/sort_method_arguments'
+require_relative 'rubocop/cop/canon/sort_method_definition'

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-canon
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- skiftle
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lint_roller
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.75.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.75.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- config/default.yml
+- lib/rubocop-canon.rb
+- lib/rubocop/canon/plugin.rb
+- lib/rubocop/canon/version.rb
+- lib/rubocop/cop/canon/keyword_shorthand.rb
+- lib/rubocop/cop/canon/sort_hash.rb
+- lib/rubocop/cop/canon/sort_keywords.rb
+- lib/rubocop/cop/canon/sort_method_arguments.rb
+- lib/rubocop/cop/canon/sort_method_definition.rb
+homepage: https://github.com/skiftle/rubocop-canon
+licenses:
+- MIT
+metadata:
+  default_lint_roller_plugin: RuboCop::Canon::Plugin
+  homepage_uri: https://github.com/skiftle/rubocop-canon
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/skiftle/rubocop-canon
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.1
+signing_key:
+specification_version: 4
+summary: Deterministic RuboCop cops for canonical Ruby form
+test_files: []