archspec 0.4.0 → 1.0.0.rc1

data/lib/archspec/architectures.rb

@@ -11,30 +11,30 @@ module ArchSpec
   # Every preset accepts overrides for its directories, so you can keep the
   # shape while pointing at your own paths. The presets are:
   #
-  # +:rails+ (aliases +:rails_mvc+, +:rails_way+):: Conventional MVC. Keeps
-  #   controller APIs out of models and services. Options: +components:+,
-  #   +controller_api:+, +share_helpers:+.
-  # +:rails_strict+:: +:rails+ plus Zeitwerk name checks, a cycle check, and a
-  #   concern independence check. Options add +concerns:+.
-  # +:vanilla_rails+:: +:rails+ plus empty-directory rules for the 37signals
-  #   style, forbidding +app/services+, +app/forms+, +app/policies+, and more,
-  #   and the concern independence check. Options: +components:+, +empty:+,
+  # - +:rails+: conventional MVC that keeps controller APIs out of models and
+  #   services. Options +components:+, +controller_api:+, +share_helpers:+.
+  # - +:rails_strict+: +:rails+ plus a cycle check and a concern independence
+  #   check. Adds option +concerns:+.
+  # - +:vanilla_rails+: +:rails+ plus empty-directory rules for the 37signals
+  #   style (forbidding +app/services+, +app/forms+, +app/policies+, and more)
+  #   and the concern independence check. Options +components:+, +empty:+,
   #   +controller_api:+, +share_helpers:+, +concerns:+.
-  # +:layered+ (alias +:rails_layered+):: Ordered layers that may only depend
-  #   inward, with a cycle check. Option: +layers:+ (order matters).
-  # +:hexagonal+ (alias +:rails_hexagonal+):: Ports and adapters, keeping the
-  #   domain away from adapters. Options: +application:+, +domain:+, +ports:+,
-  #   +adapters:+.
-  # +:clean+ (alias +:rails_clean+):: Clean architecture layers. Options:
-  #   +frameworks:+, +interface_adapters:+, +use_cases:+, +entities:+.
-  # +:modular_monolith+ (alias +:bounded_contexts+):: Named packages with
-  #   per-package allowlists and optional public APIs. Options: +components:+
-  #   (required), +allow:+, +public:+.
-  # +:cqrs+ (alias +:rails_cqrs+):: Separates commands from queries and keeps
-  #   writes out of queries. Options: +commands:+, +queries:+, +read_models:+,
-  #   +mutating_methods:+.
-  # +:event_driven+ (alias +:rails_event_driven+):: Events, publishers, and
-  #   subscribers. Options: +events:+, +publishers:+, +subscribers:+.
+  # - +:layered+: ordered layers that may only depend inward, with a cycle
+  #   check. Option +layers:+ (order matters).
+  # - +:hexagonal+: ports and adapters, keeping the domain away from adapters.
+  #   Options +application:+, +domain:+, +ports:+, +adapters:+.
+  # - +:clean+: clean architecture layers. Options +frameworks:+,
+  #   +interface_adapters:+, +use_cases:+, +entities:+.
+  # - +:modular_monolith+: named packages with per-package allowlists and
+  #   optional public APIs. Options +components:+ (required), +allow:+,
+  #   +public:+.
+  # - +:cqrs+: separates commands from queries and keeps writes out of queries.
+  #   Options +commands:+, +queries:+, +read_models:+, +mutating_methods:+.
+  # - +:event_driven+: events, publishers, and subscribers. Options +events:+,
+  #   +publishers:+, +subscribers:+.
+  # - +:ruby_conventions+: generic Ruby naming idioms (no +get_+/+set_+, no +is_+
+  #   prefix), applied project-wide. Adds no components, so it composes with any
+  #   other architecture. No options.
   #
   # See the guides at https://archspecrb.dev/architectures/ for each in depth.
   module Architectures
@@ -103,83 +103,77 @@ module ArchSpec
       upsert upsert!
     ].freeze
 
+    # Every option each architecture accepts, with its default. The single
+    # source of truth for #apply: option validation checks these keys, and the
+    # architecture methods receive these values merged with the caller's.
+    DEFAULTS = {
+      rails: {
+        components: DEFAULT_RAILS_MVC,
+        controller_api: CONTROLLER_METHODS,
+        share_helpers: false
+      },
+      rails_strict: {
+        components: DEFAULT_RAILS_MVC,
+        controller_api: CONTROLLER_METHODS,
+        share_helpers: false,
+        concerns: DEFAULT_CONCERNS
+      },
+      vanilla_rails: {
+        components: DEFAULT_RAILS_MVC,
+        empty: VANILLA_RAILS_EMPTY,
+        controller_api: CONTROLLER_METHODS,
+        share_helpers: false,
+        concerns: DEFAULT_CONCERNS
+      },
+      layered: { layers: DEFAULT_LAYERED },
+      hexagonal: DEFAULT_HEXAGONAL,
+      clean: DEFAULT_CLEAN,
+      modular_monolith: { components: nil, allow: {}, public: {} },
+      cqrs: DEFAULT_CQRS.merge(mutating_methods: MUTATING_METHODS),
+      event_driven: DEFAULT_EVENT_DRIVEN,
+      ruby_conventions: {}
+    }.freeze
+
     # Applies the named preset to +dsl+, forwarding +options+ to it. Raises
     # ArchSpec::Error for an unknown name. Called by
     # ArchSpec::DSL::Context#architecture, so you rarely call it directly.
     def apply(name, dsl, **options)
-      case name.to_sym
-      when :rails, :rails_mvc, :rails_way
-        rails_mvc(
-          dsl,
-          components: options.fetch(:components, DEFAULT_RAILS_MVC),
-          controller_api: options.fetch(:controller_api, CONTROLLER_METHODS),
-          share_helpers: options.fetch(:share_helpers, false)
-        )
-      when :rails_strict
-        rails_strict(
-          dsl,
-          components: options.fetch(:components, DEFAULT_RAILS_MVC),
-          controller_api: options.fetch(:controller_api, CONTROLLER_METHODS),
-          share_helpers: options.fetch(:share_helpers, false),
-          concerns: options.fetch(:concerns, DEFAULT_CONCERNS)
-        )
-      when :vanilla_rails
-        vanilla_rails(
-          dsl,
-          components: options.fetch(:components, DEFAULT_RAILS_MVC),
-          empty: options.fetch(:empty, VANILLA_RAILS_EMPTY),
-          controller_api: options.fetch(:controller_api, CONTROLLER_METHODS),
-          share_helpers: options.fetch(:share_helpers, false),
-          concerns: options.fetch(:concerns, DEFAULT_CONCERNS)
-        )
-      when :layered, :rails_layered
-        layered(dsl, layers: options.fetch(:layers, DEFAULT_LAYERED))
-      when :hexagonal, :rails_hexagonal
-        hexagonal(dsl, **with_defaults(DEFAULT_HEXAGONAL, options))
-      when :clean, :rails_clean
-        clean(dsl, **with_defaults(DEFAULT_CLEAN, options))
-      when :modular_monolith, :bounded_contexts
-        modular_monolith(
-          dsl,
-          components: options.fetch(:components),
-          allow: options.fetch(:allow, {}),
-          public: options.fetch(:public, {})
-        )
-      when :cqrs, :rails_cqrs
-        cqrs(dsl, **with_defaults(DEFAULT_CQRS, options))
-      when :event_driven, :rails_event_driven
-        event_driven(dsl, **with_defaults(DEFAULT_EVENT_DRIVEN, options))
-      else
-        raise Error, "Unknown ArchSpec architecture: #{name.inspect}"
-      end
+      name = architecture_name(name)
+      defaults = DEFAULTS[name]
+      raise Error, "unknown architecture: #{name.inspect}" unless defaults
+
+      validate_options!(name, defaults, options)
+      send(name, dsl, **defaults.merge(options))
     end
 
-    def rails_mvc(dsl, components:, controller_api: CONTROLLER_METHODS, share_helpers: false)
+    def rails(dsl, components:, controller_api:, share_helpers:)
       components = normalize_map(components)
-      define_components(dsl, components)
+      missing = %i[controllers models] - components.keys
+      if missing.any?
+        raise Error, "the rails architectures need controllers and models components, missing: #{missing.join(', ')}"
+      end
 
-      forbidden = share_helpers ? %i[controllers] : %i[controllers helpers]
-      proxy_for(dsl, :controllers).can_use(*components.keys & %i[models services helpers mailers jobs])
-      proxy_for(dsl, :models).cannot_use(*components.keys & forbidden)
-      proxy_for(dsl, :services).cannot_use(*components.keys & forbidden)
+      define_components(dsl, components)
 
-      return if controller_api.empty?
+      forbidden = (share_helpers ? %i[controllers] : %i[controllers helpers]) & components.keys
+      proxy_for(dsl, :controllers).can_only_use(*components.keys & %i[models services helpers mailers jobs])
 
-      proxy_for(dsl, :models).cannot_call(*controller_api, receiver: :none)
-      proxy_for(dsl, :services).cannot_call(*controller_api, receiver: :none)
+      (%i[models services] & components.keys).each do |name|
+        proxy = proxy_for(dsl, name)
+        proxy.cannot_use(*forbidden)
+        proxy.cannot_call(*controller_api, receiver: :none) unless controller_api.empty?
+      end
     end
 
-    def rails_strict(dsl, components:, controller_api: CONTROLLER_METHODS, share_helpers: false, concerns: DEFAULT_CONCERNS)
+    def rails_strict(dsl, components:, controller_api:, share_helpers:, concerns:)
       components = normalize_map(components)
-      rails_mvc(dsl, components: components, controller_api: controller_api, share_helpers: share_helpers)
-      dsl.verify_zeitwerk_names!
-      dsl.no_cycles!(among: components.keys)
+      rails(dsl, components: components, controller_api: controller_api, share_helpers: share_helpers)
+      dsl.no_cycles(among: components.keys)
       independent_concerns(dsl, concerns)
     end
 
-    def vanilla_rails(dsl, components:, empty:, controller_api: CONTROLLER_METHODS, share_helpers: false,
-                      concerns: DEFAULT_CONCERNS)
-      rails_mvc(dsl, components: components, controller_api: controller_api, share_helpers: share_helpers)
+    def vanilla_rails(dsl, components:, empty:, controller_api:, share_helpers:, concerns:)
+      rails(dsl, components: components, controller_api: controller_api, share_helpers: share_helpers)
 
       empty.each do |name, (pattern, reason)|
         dsl.component(name, in: pattern).must_be_empty(because: reason)
@@ -195,10 +189,10 @@ module ArchSpec
 
       names.each_with_index do |name, index|
         allowed = names[(index + 1)..] || []
-        proxy_for(dsl, name).can_use(*allowed)
+        proxy_for(dsl, name).can_only_use(*allowed)
       end
 
-      dsl.no_cycles!(among: names)
+      dsl.no_cycles(among: names)
     end
 
     def hexagonal(dsl, application:, domain:, ports:, adapters:)
@@ -210,11 +204,11 @@ module ArchSpec
       )
       define_components(dsl, roles)
 
-      proxy_for(dsl, :application).can_use :domain, :ports
+      proxy_for(dsl, :application).can_only_use :domain, :ports
       proxy_for(dsl, :domain).cannot_use :adapters
       proxy_for(dsl, :ports).cannot_use :adapters
-      proxy_for(dsl, :adapters).can_use :application, :domain, :ports
-      dsl.no_cycles!(among: roles.keys)
+      proxy_for(dsl, :adapters).can_only_use :application, :domain, :ports
+      dsl.no_cycles(among: roles.keys)
     end
 
     def clean(dsl, frameworks:, interface_adapters:, use_cases:, entities:)
@@ -230,21 +224,23 @@ module ArchSpec
     end
 
     def modular_monolith(dsl, components:, allow: {}, public: {})
+      raise Error, 'architecture :modular_monolith requires the components: option' unless components
+
       components = normalize_map(components)
       define_components(dsl, components)
 
       components.each_key do |name|
         allowed = Array(allow[name] || allow[name.to_s])
-        proxy_for(dsl, name).can_use(*allowed)
+        proxy_for(dsl, name).can_only_use(*allowed)
 
         patterns = Array(public[name] || public[name.to_s])
         proxy_for(dsl, name).public_api(*patterns) if patterns.any?
       end
 
-      dsl.no_cycles!(among: components.keys)
+      dsl.no_cycles(among: components.keys)
     end
 
-    def cqrs(dsl, commands:, queries:, read_models: nil, mutating_methods: MUTATING_METHODS)
+    def cqrs(dsl, commands:, queries:, read_models:, mutating_methods:)
       components = normalize_map(commands: commands, queries: queries)
       components[:read_models] = read_models if read_models
       define_components(dsl, components)
@@ -252,7 +248,7 @@ module ArchSpec
       proxy_for(dsl, :commands).cannot_use :queries
       proxy_for(dsl, :queries).cannot_use :commands
       proxy_for(dsl, :queries).cannot_call(*mutating_methods)
-      dsl.no_cycles!(among: components.keys)
+      dsl.no_cycles(among: components.keys)
     end
 
     def event_driven(dsl, events:, publishers:, subscribers:)
@@ -260,15 +256,49 @@ module ArchSpec
       define_components(dsl, roles)
 
       proxy_for(dsl, :events).cannot_use :publishers, :subscribers
-      proxy_for(dsl, :publishers).can_use :events
-      proxy_for(dsl, :subscribers).can_use :events
-      dsl.no_cycles!(among: roles.keys)
+      proxy_for(dsl, :publishers).can_only_use :events
+      proxy_for(dsl, :subscribers).can_only_use :events
+      dsl.no_cycles(among: roles.keys)
+    end
+
+    # Applies the generic Ruby naming idioms project-wide: no +get_+/+set_+
+    # accessors and no +is_+ predicate prefix. Adds no components, so it composes
+    # with any other architecture. Project-specific conventions (the +with_x+ /
+    # +without_x+ pairing, the +supports_*?+ ban) stay opt-in through the
+    # +method_names.matching(...)+ primitives.
+    def ruby_conventions(dsl)
+      %i[instance class].each do |scope|
+        forbid_name(dsl, /\A(get|set)_/, 'use attr_ readers and writers or plain names, not get_/set_', scope: scope)
+        forbid_name(dsl, /\Ais_/, 'name predicates with a trailing ? and no is_ prefix (has_ is fine)', scope: scope)
+      end
     end
 
     private
 
-    def with_defaults(defaults, options)
-      defaults.merge(options)
+    def architecture_name(name)
+      name.to_sym
+    rescue NoMethodError
+      raise Error, "unknown architecture: #{name.inspect}"
+    end
+
+    def validate_options!(name, defaults, options)
+      unknown = options.keys - defaults.keys
+      return if unknown.empty?
+
+      label = unknown.length == 1 ? 'option' : 'options'
+      names = unknown.map { |option| "#{option}:" }.sort.join(', ')
+      raise Error, "unknown #{label} for architecture :#{name}: #{names}"
+    end
+
+    def forbid_name(dsl, regex, reason, scope:)
+      dsl.rule(
+        Rules::NamingRule.new(
+          source: nil,
+          selector: Rules::Naming::NameSelector.new(regex),
+          constraint: Rules::Naming::Forbidden.new(because: reason),
+          scope: scope
+        )
+      )
     end
 
     def normalize_map(map)
@@ -302,6 +332,8 @@ module ArchSpec
       return unless pattern
 
       dsl.component(:concerns, in: pattern).cannot_reference_includers
+      # Controllers carry an allowlist, so let them include concerns too.
+      proxy_for(dsl, :controllers).can_only_use(:concerns)
     end
   end
 end

data/lib/archspec/cli.rb

@@ -16,15 +16,20 @@ module ArchSpec
     extend self
 
     CONFIG_FILE = 'Archspec.rb'
+    USAGE_ERROR_STATUS = 64
     TEMPLATE = <<~RUBY
       architecture :rails
     RUBY
 
+    class UsageError < Error; end
+
     def run(argv, output: $stdout, error: $stderr)
       argv = argv.dup
       command = argv.shift || 'check'
 
       case command
+      when 'help', '--help', '-h'
+        help(argv, output)
       when 'init'
         init(argv, output)
       when 'check'
@@ -32,47 +37,91 @@ module ArchSpec
       when 'explain'
         explain(argv, output)
       when 'version', '--version', '-v'
+        raise UsageError, "unexpected argument: #{argv.first}" if argv.any?
+
         output.puts ArchSpec::VERSION
         0
       else
-        error.puts "Unknown command: #{command}"
-        error.puts usage
-        64
+        raise UsageError, "unknown command: #{command}"
       end
+    rescue OptionParser::ParseError, UsageError => e
+      error.puts "archspec: error: #{e.message}"
+      error.puts usage(command)
+      USAGE_ERROR_STATUS
     rescue Error => e
-      error.puts e.message
+      error.puts "archspec: error: #{e.message}"
       1
     end
 
     private
 
+    def help(argv, output)
+      subject = argv.shift
+      raise UsageError, "unexpected argument: #{argv.first}" if argv.any?
+      if subject && !%w[init check explain version].include?(subject)
+        raise UsageError, "unknown command: #{subject}"
+      end
+
+      output.puts usage(subject)
+      0
+    end
+
     def init(argv, output)
-      force = argv.delete('--force')
+      options = { force: false, help: false }
+      parser = OptionParser.new do |opts|
+        opts.banner = usage('init').strip
+        opts.on('--force', 'Overwrite an existing file') { options[:force] = true }
+        opts.on('-h', '--help', 'Show this help') { options[:help] = true }
+      end
+      parser.parse!(argv)
+
+      if options[:help]
+        output.puts parser
+        return 0
+      end
+
+      raise UsageError, "unexpected argument: #{argv[1]}" if argv.length > 1
+
       path = argv.shift || CONFIG_FILE
 
-      raise Error, "#{path} already exists. Use --force to overwrite it." if File.exist?(path) && !force
+      if File.exist?(path) && !options[:force]
+        raise Error, "#{path} already exists (use --force to overwrite)"
+      end
 
       File.write(path, TEMPLATE)
       output.puts "Created #{path}"
       0
+    rescue SystemCallError => e
+      raise Error, "could not create #{path}: #{e.message}"
     end
 
     def check(argv, output)
       options = {
         config: CONFIG_FILE,
         format: 'text',
-        update_todo: false
+        update_todo: false,
+        help: false
       }
 
       parser = OptionParser.new do |opts|
-        opts.on('--config PATH') { |value| options[:config] = value }
-        opts.on('--format FORMAT') { |value| options[:format] = value }
-        opts.on('--update-todo') { options[:update_todo] = true }
+        opts.banner = usage('check').strip
+        opts.on('--config PATH', 'Use a different architecture file') { |value| options[:config] = value }
+        opts.on('--format FORMAT', 'Output text or json') { |value| options[:format] = value }
+        opts.on('--update-todo', 'Replace the configured todo with current violations') do
+          options[:update_todo] = true
+        end
+        opts.on('-h', '--help', 'Show this help') { options[:help] = true }
       end
       parser.parse!(argv)
 
-      raise Error, 'Cannot combine --update-todo with path arguments.' if options[:update_todo] && argv.any?
+      if options[:help]
+        output.puts parser
+        return 0
+      end
+
+      raise Error, 'cannot combine --update-todo with path arguments' if options[:update_todo] && argv.any?
 
+      formatter = formatter_for(options[:format])
       definition, root = load_definition(options[:config])
       graph = Analyzer.analyze(definition, root: root)
       todo_path = todo_path_for(definition, root)
@@ -83,48 +132,65 @@ module ArchSpec
       if options[:update_todo]
         unless todo_path
           raise Error,
-                "No todo configured. Add `todo \"archspec_todo.yml\"` to #{options[:config]}."
+                "no todo configured; add `todo \"archspec_todo.yml\"` to #{options[:config]}"
         end
 
-        Todo.write(todo_path, diagnostics, root: root)
-        output.puts "Updated #{Pathname(todo_path).relative_path_from(Pathname(root))} with #{diagnostics.size} violations."
+        # Syntax errors are never an accepted baseline; they must be fixed.
+        accepted = diagnostics.reject { |diagnostic| diagnostic.rule == 'parser.syntax' }
+        Todo.write(todo_path, accepted, root: root)
+        label = accepted.size == 1 ? 'violation' : 'violations'
+        output.puts "Updated #{Pathname(todo_path).relative_path_from(Pathname(root))} with #{accepted.size} #{label}."
         return 0
       end
 
-      formatter_for(options[:format]).print(output, graph: graph, diagnostics: diagnostics)
+      formatter.print(output, graph: graph, diagnostics: diagnostics)
       diagnostics.empty? ? 0 : 1
     end
 
     def explain(argv, output)
-      options = { config: CONFIG_FILE }
+      options = { config: CONFIG_FILE, help: false }
       parser = OptionParser.new do |opts|
-        opts.on('--config PATH') { |value| options[:config] = value }
+        opts.banner = usage('explain').strip
+        opts.on('--config PATH', 'Use a different architecture file') { |value| options[:config] = value }
+        opts.on('-h', '--help', 'Show this help') { options[:help] = true }
       end
       parser.parse!(argv)
 
+      if options[:help]
+        output.puts parser
+        return 0
+      end
+
       subject = argv.shift
-      raise Error, 'Usage: archspec explain PATH_OR_CONSTANT' unless subject
+      raise UsageError, 'missing PATH_OR_CONSTANT' unless subject
+      raise UsageError, "unexpected argument: #{argv.first}" if argv.any?
 
       definition, root = load_definition(options[:config])
       graph = Analyzer.analyze(definition, root: root)
-      explain_subject(output, graph, subject)
+      Formatters::Explanation.print(output, graph: graph, subject: subject)
       0
     end
 
     def load_definition(config_path)
-      raise Error, "Missing #{config_path}. Run `archspec init` first." unless File.exist?(config_path)
+      raise Error, "no #{config_path} found; run `archspec init` first" unless File.exist?(config_path)
 
-      ArchSpec.last_definition = nil
       absolute_config = File.expand_path(config_path)
-      config_dir = File.dirname(absolute_config)
       definition = Definition.new
-      definition.base_dir = config_dir
+      definition.base_dir = File.dirname(absolute_config)
       definition.extend(DSL::Context)
       definition.instance_eval(File.read(absolute_config), absolute_config)
-      definition = ArchSpec.last_definition || definition
-      definition.base_dir ||= config_dir
 
-      [definition, definition.absolute_root(config_dir)]
+      if definition.component_specs.empty? && definition.rules.empty?
+        raise Error, "#{config_path} declared no components or rules; the file's top level is already " \
+                     'the DSL, so do not wrap declarations in ArchSpec.define'
+      end
+
+      [definition, definition.absolute_root]
+    rescue Error
+      raise
+    rescue SyntaxError, LoadError, StandardError => e
+      detail = e.message.lines.first&.strip || e.class.name
+      raise Error, "could not load #{config_path}: #{detail}"
     end
 
     def scope_to_paths(diagnostics, paths, root)
@@ -151,90 +217,32 @@ module ArchSpec
       when 'json'
         Formatters::JSON
       else
-        raise Error, "Unknown format: #{name.inspect}"
+        raise UsageError, "unknown format: #{name.inspect}"
       end
     end
 
-    def explain_subject(output, graph, subject)
-      path = File.expand_path(subject, graph.root)
-
-      if graph.files.key?(path)
-        file = graph.files.fetch(path)
-        output.puts file.relative_path
-        output.puts "  expected constant: #{file.expected_constant || '(none)'}"
-        output.puts "  defined constants: #{graph.constants_for_path(path).map(&:name).join(', ')}"
-        output_parse_errors(output, file)
-        output_component_reasons(output, graph.component_assignment_reasons_for_path(path))
-        output_suppressions(output, file)
-        output.puts '  outgoing facts:'
-
-        graph.edges.select { |edge| edge.from_path == path }.each do |edge|
-          output.puts "    #{edge.type} #{edge.to} at #{edge.location.line}:#{edge.location.column}"
-        end
+    def usage(command = nil)
+      case command.to_s
+      when 'init'
+        'Usage: archspec init [PATH] [--force]'
+      when 'check'
+        'Usage: archspec check [PATHS...] [--config PATH] [--format text|json] [--update-todo]'
+      when 'explain'
+        'Usage: archspec explain PATH_OR_CONSTANT [--config PATH]'
+      when 'version'
+        'Usage: archspec version'
+      when ''
+        <<~TEXT
+          Usage:
+            archspec init [PATH] [--force]
+            archspec check [PATHS...] [--config PATH] [--format text|json] [--update-todo]
+            archspec explain PATH_OR_CONSTANT [--config PATH]
+            archspec version
+            archspec help [COMMAND]
+        TEXT
       else
-        constants = graph.constants_named(subject)
-        raise Error, "No file or constant found for #{subject.inspect}" if constants.empty?
-
-        constants.each do |constant|
-          output.puts constant.name
-          output.puts "  kind: #{constant.kind}"
-          output.puts "  file: #{constant.location.relative_path(graph.root)}:#{constant.location.line}"
-          output_component_reasons(output, graph.component_assignment_reasons_for_constant(constant.name))
-          output.puts "  superclass: #{constant.superclass || '(none)'}"
-          output.puts "  instance methods: #{constant.instance_methods.to_a.sort.join(', ')}"
-          output.puts "  class methods: #{constant.class_methods.to_a.sort.join(', ')}"
-        end
-      end
-    end
-
-    def output_component_reasons(output, assignments)
-      if assignments.empty?
-        output.puts '  components: (none)'
-        return
+        usage
       end
-
-      output.puts '  components:'
-      assignments.sort_by { |name, _reasons| name.to_s }.each do |name, reasons|
-        output.puts "    #{name}: #{reasons.empty? ? '(no recorded reason)' : reasons.join('; ')}"
-      end
-    end
-
-    def output_suppressions(output, file)
-      return if file.suppressions.empty?
-
-      output.puts '  suppressions:'
-      file.suppressions.each do |suppression|
-        line_range =
-          if suppression.end_line == Float::INFINITY
-            "#{suppression.start_line}-EOF"
-          elsif suppression.start_line == suppression.end_line
-            suppression.start_line
-          else
-            "#{suppression.start_line}-#{suppression.end_line}"
-          end
-        rule = suppression.rule || '*'
-        reason = suppression.reason ? " -- #{suppression.reason}" : ''
-        output.puts "    #{rule} on line #{line_range}#{reason}"
-      end
-    end
-
-    def output_parse_errors(output, file)
-      return if file.parse_errors.empty?
-
-      output.puts '  parse errors:'
-      file.parse_errors.each do |parse_error|
-        output.puts "    #{parse_error.location.line}:#{parse_error.location.column} #{parse_error.message}"
-      end
-    end
-
-    def usage
-      <<~TEXT
-        Usage:
-          archspec init [PATH] [--force]
-          archspec check [PATHS...] [--config PATH] [--format text|json] [--update-todo]
-          archspec explain PATH_OR_CONSTANT [--config PATH]
-          archspec version
-      TEXT
     end
   end
 end

data/lib/archspec/definition.rb

@@ -22,7 +22,7 @@ module ArchSpec
     ].freeze
 
     attr_accessor :name, :root_path, :todo_path, :base_dir
-    attr_reader :source_patterns, :ignore_patterns, :component_specs, :rules, :inflections
+    attr_reader :source_patterns, :ignore_patterns, :component_specs, :rules
 
     def initialize(name = nil)
       @name = name
@@ -33,11 +33,6 @@ module ArchSpec
       @ignore_patterns = DEFAULT_IGNORE_PATTERNS.dup
       @component_specs = {}
       @rules = []
-      @inflections = {}
-    end
-
-    def add_inflections(map)
-      @inflections.merge!(map.to_h.transform_keys(&:to_s).transform_values(&:to_s))
     end
 
     def add_source_patterns(patterns)

data/lib/archspec/diagnostic.rb

@@ -36,6 +36,8 @@ module ArchSpec
         path: location.relative_path(root),
         line: location.line,
         column: location.column,
+        end_line: location.end_line,
+        end_column: location.end_column,
         evidence: evidence,
         confidence: confidence.to_s
       }