archspec 0.5.0 → 1.0.0

data/lib/archspec/model.rb

@@ -29,14 +29,16 @@ module ArchSpec
   end
 
   class ConstantNode
-    attr_reader :name, :kind, :path, :location, :instance_methods, :class_methods, :method_definitions, :mixins
+    attr_reader :name, :kind, :path, :location, :instance_methods, :class_methods, :method_definitions, :mixins,
+                :nesting
     attr_accessor :superclass
 
-    def initialize(name:, kind:, path:, location:)
+    def initialize(name:, kind:, path:, location:, nesting: [])
       @name = name
       @kind = kind
       @path = path
       @location = location
+      @nesting = Array(nesting).dup.freeze
       @instance_methods = Set.new
       @class_methods = Set.new
       @method_definitions = []
@@ -79,7 +81,34 @@ module ArchSpec
     end
   end
 
-  Edge = ValueObject.define(:type, :from_path, :from_constant, :to, :location, :confidence, :receiver)
+  Edge = ValueObject.define(
+    :type,
+    :from_path,
+    :from_constant,
+    :to,
+    :location,
+    :confidence,
+    :receiver,
+    :lexical_nesting
+  ) do
+    VERBS = {
+      references_constant: 'references',
+      inherits_from: 'inherits from',
+      includes: 'includes',
+      prepends: 'prepends',
+      extends: 'extends',
+      calls_named_method: 'calls',
+      instantiates_and_invokes: 'instantiates and invokes',
+      requires: 'requires',
+      requires_relative: 'requires',
+      dynamic_feature: 'uses dynamic feature'
+    }.freeze
+
+    # The edge type as prose, for diagnostics and explain output.
+    def verb
+      VERBS.fetch(type, type.to_s.tr('_', ' '))
+    end
+  end
 
   class Component
     attr_reader :name, :files, :constants, :file_reasons, :constant_reasons
@@ -88,6 +117,7 @@ module ArchSpec
       @name = name.to_sym
       @files = Set.new
       @constants = Set.new
+      @constant_occurrences = Set.new
       @file_reasons = Hash.new { |hash, key| hash[key] = Set.new }
       @constant_reasons = Hash.new { |hash, key| hash[key] = Set.new }
     end
@@ -97,10 +127,17 @@ module ArchSpec
       file_reasons[path].add(reason) if reason
     end
 
-    def add_constant(name, reason: nil)
+    def add_constant(name, path:, reason: nil)
       constants.add(name)
+      @constant_occurrences.add([name, path])
       constant_reasons[name].add(reason) if reason
     end
+
+    def includes_constant?(name, path: nil)
+      return constants.include?(name) unless path
+
+      @constant_occurrences.include?([name, path])
+    end
   end
 
   class Graph
@@ -134,19 +171,21 @@ module ArchSpec
       )
     end
 
-    def add_constant(name:, kind:, path:, location:)
+    def add_constant(name:, kind:, path:, location:, nesting: [])
       normalized = normalize_constant(name)
       existing = @constants_by_name[normalized].find { |constant| constant.path == path && constant.kind == kind }
       return existing if existing
 
-      constant = ConstantNode.new(name: normalized, kind: kind, path: path, location: location)
+      constant = ConstantNode.new(name: normalized, kind: kind, path: path, location: location, nesting: nesting)
       constants << constant
       @constants_by_name[normalized] << constant
       constant
     end
 
-    def add_edge(type:, from_path:, from_constant:, to:, location:, confidence: :high, receiver: nil)
-      edges << Edge.new(type, from_path, from_constant, normalize_constant(to), location, confidence, receiver)
+    def add_edge(type:, from_path:, from_constant:, to:, location:, confidence: :high, receiver: nil,
+                 lexical_nesting: nil)
+      nesting = lexical_nesting&.map { |name| normalize_constant(name) }&.freeze
+      edges << Edge.new(type, from_path, from_constant, to.to_s, location, confidence, receiver, nesting)
     end
 
     def constants_named(name)
@@ -161,7 +200,7 @@ module ArchSpec
       component = components[name.to_sym]
       return [] unless component
 
-      component.constants.flat_map { |constant_name| constants_named(constant_name) }.flat_map(&:method_definitions)
+      constants_for_component(name).flat_map(&:method_definitions)
     end
 
     # Every method definition in the graph, across all constants. Used by
@@ -175,18 +214,22 @@ module ArchSpec
 
       component_specs.each do |spec|
         component = Component.new(spec.name)
+        files_matched_by_pattern = Set.new
 
         spec.file_patterns.each do |pattern|
-          each_matching_file(pattern) { |path| component.add_file(path, reason: "matched file pattern #{pattern}") }
+          each_matching_file(pattern) do |path|
+            files_matched_by_pattern.add(path)
+            component.add_file(path, reason: "matched file pattern #{pattern}")
+          end
         end
 
         constants.each do |constant|
-          matched_file = component.files.include?(constant.path)
+          matched_file = files_matched_by_pattern.include?(constant.path)
           matched_constant = spec.matches_constant?(constant.name)
           next unless matched_file || matched_constant
 
           component.add_file(constant.path, reason: "defines #{constant.name}") if matched_constant
-          component.add_constant(constant.name,
+          component.add_constant(constant.name, path: constant.path,
                                  reason: matched_file ? 'defined in matched file' : 'matched namespace/constant selector')
         end
 
@@ -200,14 +243,31 @@ module ArchSpec
       end
     end
 
-    def component_names_for_constant(name)
+    def component_names_for_constant(name, path: nil)
       normalized = normalize_constant(name)
 
       components.values.each_with_object(Set.new) do |component, names|
-        names.add(component.name) if component.constants.include?(normalized)
+        names.add(component.name) if component.includes_constant?(normalized, path: path)
       end
     end
 
+    # The edge's source as prose: its constant when known, otherwise the
+    # root-relative path of the file. Diagnostics use this so evidence never
+    # embeds an absolute path, which would make todo fingerprints
+    # machine-specific.
+    def edge_source_name(edge)
+      edge.from_constant || files[edge.from_path]&.relative_path || edge.from_path
+    end
+
+    # Components that own the source of an edge. Constant and namespace
+    # selectors stay precise when a file also defines unrelated constants;
+    # top-level edges fall back to the file assignment.
+    def source_components_for(edge)
+      return component_names_for_path(edge.from_path) unless edge.from_constant
+
+      component_names_for_constant(edge.from_constant, path: edge.from_path)
+    end
+
     def dependency_edges
       edges.select { |edge| DEPENDENCY_EDGE_TYPES.include?(edge.type) }
     end
@@ -215,31 +275,30 @@ module ArchSpec
     def target_components_for(edge)
       return Set.new unless DEPENDENCY_EDGE_TYPES.include?(edge.type)
 
-      resolved = resolve_constant_reference(edge.to, edge.from_constant)
+      resolved = resolve_edge_constant(edge)
       constants_named(resolved).each_with_object(Set.new) do |constant, names|
-        names.merge(component_names_for_path(constant.path))
-        names.merge(component_names_for_constant(constant.name))
+        names.merge(component_names_for_constant(resolved, path: constant.path))
       end
     end
 
-    def resolve_constant_reference(name, from_constant)
+    def resolve_constant_reference(name, from_constant = nil, lexical_nesting: nil)
+      absolute = name.to_s.start_with?('::')
       normalized = normalize_constant(name)
-      candidates = []
-
-      if from_constant
-        namespace = normalize_constant(from_constant).split('::')
-        namespace.pop
-
-        until namespace.empty?
-          candidates << "#{namespace.join('::')}::#{normalized}"
-          namespace.pop
-        end
-      end
+      return normalized if absolute
 
+      scopes = lexical_nesting || inferred_nesting(from_constant)
+      candidates = scopes.map { |scope| "#{normalize_constant(scope)}::#{normalized}" }
       candidates << normalized
       candidates.find { |candidate| constants_named(candidate).any? } || normalized
     end
 
+    # Resolves an edge with the lexical nesting captured where the reference
+    # appeared. This matters for compact class declarations and superclass
+    # expressions, where inferring scope from the finished class name is wrong.
+    def resolve_edge_constant(edge)
+      resolve_constant_reference(edge.to, edge.from_constant, lexical_nesting: edge.lexical_nesting)
+    end
+
     # Instance methods a constant responds to, walking resolvable superclasses
     # and include/prepend mixins. Returns [methods, unresolved ancestor names];
     # a non-empty second element means the answer is incomplete.
@@ -259,11 +318,21 @@ module ArchSpec
       nodes.each do |node|
         methods.merge(node.instance_methods)
 
-        ancestors = node.mixins[:include].to_a + node.mixins[:prepend].to_a
-        ancestors << node.superclass if node.superclass
+        mixins = node.mixins[:include].to_a + node.mixins[:prepend].to_a
+
+        mixins.each do |ancestor|
+          resolved_name = resolve_constant_reference(
+            ancestor,
+            node.name,
+            lexical_nesting: [node.name] + node.nesting
+          )
+          ancestor_methods, ancestor_unresolved = effective_instance_methods(resolved_name, visited)
+          methods.merge(ancestor_methods)
+          unresolved.merge(ancestor_unresolved)
+        end
 
-        ancestors.each do |ancestor|
-          resolved_name = resolve_constant_reference(ancestor, node.name)
+        if node.superclass
+          resolved_name = resolve_constant_reference(node.superclass, node.name, lexical_nesting: node.nesting)
           ancestor_methods, ancestor_unresolved = effective_instance_methods(resolved_name, visited)
           methods.merge(ancestor_methods)
           unresolved.merge(ancestor_unresolved)
@@ -278,7 +347,7 @@ module ArchSpec
       pairs = Set.new
 
       dependency_edges.each do |edge|
-        source_components = component_names_for_path(edge.from_path)
+        source_components = source_components_for(edge)
         source_components &= allowed_sources unless allowed_sources.empty?
         next if source_components.empty?
 
@@ -300,16 +369,23 @@ module ArchSpec
       end
     end
 
-    def component_assignment_reasons_for_constant(name)
+    def component_assignment_reasons_for_constant(name, path: nil)
       normalized = normalize_constant(name)
 
       components.values.each_with_object({}) do |component, reasons|
-        next unless component.constants.include?(normalized)
+        next unless component.includes_constant?(normalized, path: path)
 
         reasons[component.name] = component.constant_reasons[normalized].to_a.sort
       end
     end
 
+    def constants_for_component(name)
+      component = components[name.to_sym]
+      return [] unless component
+
+      constants.select { |constant| component.includes_constant?(constant.name, path: constant.path) }
+    end
+
     def suppressed?(diagnostic)
       files[diagnostic.location.path]&.suppressions&.any? { |suppression| suppression.matches?(diagnostic) }
     end
@@ -327,5 +403,12 @@ module ArchSpec
     def normalize_constant(value)
       value.to_s.sub(/\A::/, '')
     end
+
+    def inferred_nesting(from_constant)
+      return [] unless from_constant
+
+      parts = normalize_constant(from_constant).split('::')
+      parts.length.downto(1).map { |length| parts.first(length).join('::') }
+    end
   end
 end

data/lib/archspec/rules/component_rules.rb

@@ -30,7 +30,7 @@ module ArchSpec
           Diagnostic.new(
             rule: id,
             message: because ? "#{source} must stay empty: #{because}" : "#{source} must stay empty",
-            location: SourceLocation.new(path, 1, 1),
+            location: SourceLocation.point(path, 1, 1),
             evidence: "#{relative} belongs to #{source}"
           )
         end

data/lib/archspec/rules/concern_rules.rb

@@ -34,7 +34,7 @@ module ArchSpec
           consumers = includers[edge.from_constant]
           next if consumers.empty?
 
-          target = graph.resolve_constant_reference(edge.to, edge.from_constant)
+          target = graph.resolve_edge_constant(edge)
           includer = consumers.find { |name| target == name || target.start_with?("#{name}::") }
           next unless includer
 
@@ -42,7 +42,7 @@ module ArchSpec
             rule: id,
             message: "#{edge.from_constant} must not reference its includer #{includer}",
             location: edge.location,
-            evidence: "#{edge.from_constant} #{edge.type} #{target}"
+            evidence: "#{edge.from_constant} #{edge.verb} #{target}"
           )
         end
       end
@@ -56,7 +56,7 @@ module ArchSpec
         graph.edges.each do |edge|
           next unless MIXIN_TYPES.include?(edge.type) && edge.from_constant
 
-          mod = graph.resolve_constant_reference(edge.to, edge.from_constant)
+          mod = graph.resolve_edge_constant(edge)
           map[mod].add(edge.from_constant) unless mod == edge.from_constant
         end
 

data/lib/archspec/rules/cycle_rule.rb

@@ -17,7 +17,7 @@ module ArchSpec
 
       def evaluate(graph)
         cycles(graph).map do |cycle|
-          location = first_location_for_cycle(graph, cycle) || SourceLocation.new(graph.root, 1, 1)
+          location = first_location_for_cycle(graph, cycle) || SourceLocation.point(graph.root, 1, 1)
           Diagnostic.new(
             rule: id,
             message: "component dependency cycle: #{cycle.join(' -> ')}",
@@ -74,7 +74,7 @@ module ArchSpec
       def first_location_for_cycle(graph, cycle)
         source, target = cycle
         graph.dependency_edges.find do |edge|
-          graph.component_names_for_path(edge.from_path).include?(source) &&
+          graph.source_components_for(edge).include?(source) &&
             graph.target_components_for(edge).include?(target)
         end&.location
       end

data/lib/archspec/rules/dependency_rules.rb

@@ -29,15 +29,7 @@ module ArchSpec
       private
 
       def relevant_edges(graph)
-        graph.dependency_edges.select { |edge| graph.component_names_for_path(edge.from_path).include?(source) }
-      end
-
-      def target_components(graph, edge)
-        graph.target_components_for(edge)
-      end
-
-      def edge_target(edge)
-        edge.to
+        graph.dependency_edges.select { |edge| graph.source_components_for(edge).include?(source) }
       end
     end
 
@@ -50,14 +42,14 @@ module ArchSpec
 
       def evaluate(graph)
         relevant_edges(graph).flat_map do |edge|
-          target_components(graph, edge).filter_map do |target|
+          graph.target_components_for(edge).filter_map do |target|
             next if target == source || targets.include?(target)
 
             Diagnostic.new(
               rule: id,
               message: "#{source} may not depend on #{target}",
               location: edge.location,
-              evidence: "#{edge.from_constant || edge.from_path} #{edge.type} #{edge_target(edge)}"
+              evidence: "#{graph.edge_source_name(edge)} #{edge.verb} #{edge.to}"
             )
           end
         end
@@ -73,14 +65,14 @@ module ArchSpec
 
       def evaluate(graph)
         relevant_edges(graph).flat_map do |edge|
-          forbidden = target_components(graph, edge) & targets
+          forbidden = graph.target_components_for(edge) & targets
 
           forbidden.map do |target|
             Diagnostic.new(
               rule: id,
               message: "#{source} must not depend on #{target}",
               location: edge.location,
-              evidence: "#{edge.from_constant || edge.from_path} #{edge.type} #{edge_target(edge)}"
+              evidence: "#{graph.edge_source_name(edge)} #{edge.verb} #{edge.to}"
             )
           end
         end
@@ -115,7 +107,7 @@ module ArchSpec
         graph.dependency_edges.flat_map do |edge|
           next [] unless graph.target_components_for(edge).include?(source)
 
-          offenders = graph.component_names_for_path(edge.from_path).reject do |component|
+          offenders = graph.source_components_for(edge).reject do |component|
             component == source || consumers.include?(component)
           end
 
@@ -124,7 +116,7 @@ module ArchSpec
               rule: id,
               message: message_for(offender),
               location: edge.location,
-              evidence: "#{edge.from_constant || edge.from_path} #{edge.type} #{edge.to}"
+              evidence: "#{graph.edge_source_name(edge)} #{edge.verb} #{edge.to}"
             )
           end
         end
@@ -164,16 +156,16 @@ module ArchSpec
 
       def evaluate(graph)
         graph.dependency_edges.filter_map do |edge|
-          next unless graph.component_names_for_path(edge.from_path).include?(source)
+          next unless graph.source_components_for(edge).include?(source)
 
-          referenced = graph.resolve_constant_reference(edge.to, edge.from_constant)
+          referenced = graph.resolve_edge_constant(edge)
           next unless constants.any? { |constant| referenced == constant || referenced.start_with?("#{constant}::") }
 
           Diagnostic.new(
             rule: id,
             message: "#{source} must not reference #{referenced}",
             location: edge.location,
-            evidence: "#{edge.from_constant || edge.from_path} #{edge.type} #{edge.to}"
+            evidence: "#{graph.edge_source_name(edge)} #{edge.verb} #{edge.to}"
           )
         end
       end

data/lib/archspec/rules/naming_rules.rb

@@ -4,15 +4,21 @@ require 'set'
 
 module ArchSpec
   module Rules
-    # Backs the +methods.matching(...)+ DSL. One rule pairs a selector (which
+    # Backs the +method_names.matching(...)+ DSL. One rule pairs a selector (which
     # methods it judges) with a constraint (what must hold of them). It judges a
     # component's defined, public methods in the requested scope, or every such
     # method in the project when +source+ is nil. Every finding is name-based and
     # exact, so confidence is always +:high+.
     class NamingRule
+      VALID_SCOPES = %i[instance class].freeze
+
       attr_reader :source, :selector, :scope, :except
 
       def initialize(source:, selector:, constraint:, scope: :instance, except: [])
+        unless VALID_SCOPES.include?(scope)
+          raise Error, "method_names scope: must be :instance or :class, got #{scope.inspect}"
+        end
+
         @source = source&.to_sym
         @selector = selector
         @constraint = constraint
@@ -52,6 +58,8 @@ module ArchSpec
         attr_reader :regex
 
         def initialize(regex)
+          raise Error, "method_names matching expects a Regexp, got #{regex.inspect}" unless regex.is_a?(Regexp)
+
           @regex = regex
         end
 
@@ -99,6 +107,11 @@ module ArchSpec
       # <tt>requires("without_%{base}")</tt>. Rule id +naming.requires+.
       class Requires
         def initialize(template, on: nil, scope: :instance, because: nil)
+          unless NamingRule::VALID_SCOPES.include?(scope)
+            raise Error, "requires scope: must be :instance or :class, got #{scope.inspect}"
+          end
+          raise Error, "requires expects a String template, got #{template.inspect}" unless template.is_a?(String)
+
           @template = template
           @on = on
           @target_scope = scope
@@ -155,7 +168,7 @@ module ArchSpec
         end
       end
 
-      # Returned by ArchSpec::DSL::ComponentProxy#methods. Starts a selector.
+      # Returned by ArchSpec::DSL::ComponentProxy#method_names. Starts a selector.
       class Builder
         def initialize(component, scope: :instance)
           @component = component
@@ -181,6 +194,7 @@ module ArchSpec
         end
 
         def requires(template, on: nil, scope: :instance, except: [], because: nil)
+          validate_template!(template)
           add(Requires.new(template, on: component_name(on), scope: scope, because: because), except)
         end
 
@@ -201,7 +215,21 @@ module ArchSpec
         def component_name(target)
           return if target.nil?
 
-          target.respond_to?(:name) ? target.name : target.to_sym
+          name = target.respond_to?(:name) ? target.name : target.to_sym
+          unless @component.definition.component?(name)
+            raise Error, "#{@component.name}.method_names.requires references unknown component: #{name}"
+          end
+
+          name
+        end
+
+        def validate_template!(template)
+          return unless template.is_a?(String)
+
+          captures = @selector.regex.names.to_h { |name| [name.to_sym, name] }
+          template % captures
+        rescue KeyError, ArgumentError => e
+          raise Error, "invalid requires template #{template.inspect}: #{e.message}"
         end
       end
     end

data/lib/archspec/rules/privacy_rule.rb

@@ -36,9 +36,9 @@ module ArchSpec
         public_names = public_constant_names(graph)
 
         graph.dependency_edges.filter_map do |edge|
-          next if component.files.include?(edge.from_path)
+          next if graph.source_components_for(edge).include?(source)
 
-          resolved = graph.resolve_constant_reference(edge.to, edge.from_constant)
+          resolved = graph.resolve_edge_constant(edge)
           next unless graph.component_names_for_constant(resolved).include?(source)
           next if public?(resolved, public_names)
 
@@ -46,7 +46,7 @@ module ArchSpec
             rule: id,
             message: "#{resolved} is private to #{source}",
             location: edge.location,
-            evidence: "#{edge.from_constant || edge.from_path} #{edge.type} #{resolved}"
+            evidence: "#{graph.edge_source_name(edge)} #{edge.verb} #{resolved}"
           )
         end
       end

data/lib/archspec/rules/protocol_rules.rb

@@ -35,14 +35,14 @@ module ArchSpec
           next unless edge.type == :calls_named_method
           next unless method_names.include?(edge.to.to_sym)
           next if receiver == :none && edge.receiver != :none
-          next unless graph.component_names_for_path(edge.from_path).include?(source)
+          next unless graph.source_components_for(edge).include?(source)
           next if own_method_call?(graph, edge)
 
           Diagnostic.new(
             rule: id,
             message: "#{source} must not call ##{edge.to}",
             location: edge.location,
-            evidence: "#{edge.from_constant || edge.from_path} calls #{edge.to}"
+            evidence: "#{graph.edge_source_name(edge)} calls #{edge.to}"
           )
         end
       end
@@ -107,7 +107,10 @@ module ArchSpec
 
       def initialize(source, method_names)
         @source = source.to_sym
-        @method_names = Array(method_names).flatten.map(&:to_sym)
+        names = Array(method_names).flatten.compact
+        raise Error, 'must_implement_one_of requires at least one method' if names.empty?
+
+        @method_names = names.map(&:to_sym)
       end
 
       def merge_key
@@ -154,7 +157,7 @@ module ArchSpec
         component = graph.components[source]
         return [] unless component
 
-        component.constants.flat_map { |name| graph.constants_named(name) }.select(&:class?).uniq(&:name)
+        graph.constants_for_component(source).select(&:class?).uniq(&:name)
       end
 
       def for(constant, methods, unresolved)
@@ -222,13 +225,13 @@ module ArchSpec
       def evaluate(graph)
         graph.edges.filter_map do |edge|
           next unless edge.type == :instantiates_and_invokes
-          next unless graph.component_names_for_path(edge.from_path).include?(source)
+          next unless graph.source_components_for(edge).include?(source)
 
           Diagnostic.new(
             rule: id,
             message: "#{source} must not instantiate and immediately invoke #{edge.to}",
             location: edge.location,
-            evidence: "#{edge.from_constant || edge.from_path} uses #{edge.to}"
+            evidence: "#{graph.edge_source_name(edge)} uses #{edge.to}"
           )
         end
       end

data/lib/archspec/source_location.rb

@@ -5,9 +5,15 @@ require 'pathname'
 require_relative 'value_object'
 
 module ArchSpec
-  SourceLocation = ValueObject.define(:path, :line, :column) do
+  SourceLocation = ValueObject.define(:path, :line, :column, :end_line, :end_column) do
     def self.from_prism(path, location)
-      new(path, location.start_line, location.start_column + 1)
+      new(path, location.start_line, location.start_column + 1, location.end_line, location.end_column + 1)
+    end
+
+    # A zero-width location for diagnostics that point at a file rather than a
+    # span of code.
+    def self.point(path, line, column)
+      new(path, line, column, line, column)
     end
 
     def relative_path(root)

data/lib/archspec/todo.rb

@@ -16,11 +16,24 @@ module ArchSpec
       return empty(root: root) unless path && File.exist?(path)
 
       document = YAML.safe_load_file(path, permitted_classes: [], aliases: false) || {}
-      ids = Array(document['violations']).filter_map do |entry|
-        entry.is_a?(Hash) ? entry['id'] : entry
+      unless document.is_a?(Hash) && (document['violations'].nil? || document['violations'].is_a?(Array))
+        raise Error, "invalid todo file #{path}: expected a violations list"
+      end
+
+      ids = Array(document['violations']).map.with_index do |entry, index|
+        id = entry.is_a?(Hash) ? entry['id'] : entry
+        unless id.is_a?(String) && !id.empty?
+          raise Error, "invalid todo file #{path}: violation #{index + 1} has no id"
+        end
+
+        id
       end
 
       new(ids.to_set, root: root)
+    rescue Error
+      raise
+    rescue Psych::Exception, SystemCallError => e
+      raise Error, "could not load todo file #{path}: #{e.message}"
     end
 
     def self.write(path, diagnostics, root:)
@@ -37,6 +50,8 @@ module ArchSpec
       }
 
       File.write(path, payload.to_yaml)
+    rescue SystemCallError => e
+      raise Error, "could not write todo file #{path}: #{e.message}"
     end
 
     def initialize(ids, root:)

data/lib/archspec/value_object.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 module ArchSpec
+  # A frozen value type with positional or keyword construction and #with,
+  # mirroring Ruby 3.2's Data.define. Deliberately hand-rolled: the gem
+  # supports Ruby 3.1, where Data does not exist. Do not replace this with
+  # Data until the required Ruby version reaches 3.2.
   module ValueObject
     def self.define(*members, &block)
       klass = Struct.new(*members) do

data/lib/archspec/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ArchSpec
-  VERSION = '0.5.0'
+  VERSION = '1.0.0'
 end