rigortype 0.1.3 → 0.1.4

data/lib/rigor/sig_gen/path_mapper.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Rigor
+  module SigGen
+    # Maps a source `.rb` file to its target `.rbs` sig file
+    # under the project's signature tree.
+    #
+    # ADR-14 § "Output layout":
+    # - `--write` MUST NOT touch files outside
+    #   `configuration.signature_paths` (default `sig/`).
+    # - The first slice supports one source file → one RBS
+    #   file; multi-class files emit one RBS containing both
+    #   classes (handled by the {Writer}, not here).
+    #
+    # The mapping convention mirrors the Ruby community
+    # default: strip the source root prefix (the first entry
+    # of `configuration.paths`, typically `"lib"`), swap the
+    # extension, and place the result under the first entry of
+    # `configuration.signature_paths` (typically `"sig"`).
+    #
+    # ADR-14 follow-up: when a class is already declared in
+    # an existing consolidated sig file (e.g. `sig/rigor/type.rbs`
+    # holds all `Rigor::Type::*` classes), the optional
+    # `LayoutIndex` re-routes the target to that file so the
+    # writer updates the consolidated declaration instead of
+    # creating a duplicate at the 1:1 mirror path.
+    #
+    # When the source path is not under any configured source
+    # root (e.g. files supplied directly on the CLI from
+    # outside `lib/`), the full relative path is preserved
+    # under the sig root.
+    class PathMapper
+      # @param configuration [Rigor::Configuration]
+      # @param project_root [String, Pathname] (defaults to `Dir.pwd`)
+      # @param layout_index [LayoutIndex, nil] optional class
+      #   → existing sig file index; routes the target to the
+      #   consolidated file when the class is already declared.
+      def initialize(configuration:, project_root: Dir.pwd, layout_index: nil)
+        @configuration = configuration
+        @project_root = Pathname(project_root)
+        @layout_index = layout_index
+      end
+
+      # @param source_path [String]
+      # @param class_name [String, nil] fully-qualified Ruby
+      #   class name. When supplied and matched by the
+      #   `LayoutIndex`, the consolidated sig file's path is
+      #   returned instead of the 1:1 mirror.
+      # @return [Pathname] absolute path of the target `.rbs`
+      #   file for the candidate.
+      def target_for(source_path, class_name: nil)
+        existing = existing_target_for(class_name)
+        return existing if existing
+
+        rel_to_root = source_relative_to_root(source_path)
+        stripped = strip_source_root(rel_to_root)
+        sig_root_dir / "#{stripped.sub_ext('')}.rbs"
+      end
+
+      def existing_target_for(class_name)
+        return nil if class_name.nil? || @layout_index.nil?
+
+        @layout_index.file_for(class_name)
+      end
+
+      # The directory `--write` is allowed to create / modify.
+      # Used by callers to assert the target stays inside the
+      # configured signature tree before touching the disk.
+      def sig_root_dir
+        @sig_root_dir ||= @project_root / sig_root_name
+      end
+
+      private
+
+      def source_relative_to_root(source_path)
+        path = Pathname(source_path)
+        return path unless path.absolute?
+
+        # Both sides go through realpath so macOS `/tmp` vs
+        # `/private/tmp` (and any other symlinked project
+        # root) compare cleanly.
+        path.realpath.relative_path_from(@project_root.realpath)
+      rescue ArgumentError, Errno::ENOENT
+        path
+      end
+
+      def strip_source_root(rel_path)
+        source_root = source_root_name
+        return rel_path if source_root.nil?
+
+        first = rel_path.each_filename.first
+        return rel_path unless first == source_root
+
+        components = rel_path.each_filename.drop(1)
+        components.empty? ? Pathname("") : Pathname(components.join(File::SEPARATOR))
+      end
+
+      # `Configuration` resolves `paths:` and `signature_paths:`
+      # to absolute Strings. We only need the trailing basename
+      # for the mapping (`/abs/lib` → `lib`, `/abs/app` → `app`).
+      def source_root_name
+        @source_root_name ||= begin
+          path = @configuration.paths.first
+          path.nil? || path.empty? ? nil : Pathname(path).basename.to_s
+        end
+      end
+
+      def sig_root_name
+        @sig_root_name ||= begin
+          first_sig = Array(@configuration.signature_paths).first
+          first_sig.nil? ? "sig" : Pathname(first_sig).basename.to_s
+        end
+      end
+    end
+  end
+end

data/lib/rigor/sig_gen/renderer.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "classification"
+
+module Rigor
+  module SigGen
+    # Output formatter for `rigor sig-gen`.
+    #
+    # Supports three modes:
+    # - `:print` (default) — RBS skeletons grouped by source
+    #   file and class declaration, ready for the user to
+    #   paste into `sig/<path>.rbs`.
+    # - `:diff` — a unified-style diff comparing the existing
+    #   RBS spelling (if any) against the inferred spelling.
+    #   The MVP renders a minimal "- declared / + inferred"
+    #   block; full per-file diffing arrives with slice 2's
+    #   `--write` merge.
+    # - `:json` — machine-readable payload with the same
+    #   classification table as `:print`.
+    class Renderer
+      def initialize(out:)
+        @out = out
+      end
+
+      # @param candidates [Array<MethodCandidate>]
+      # @param mode [:print, :diff]
+      # @param format [String] "text" or "json"
+      # @param selection [Array<Symbol>] subset of
+      #   {Classification} constants to include; an empty
+      #   array means "all emittable classifications".
+      def render(candidates:, mode:, format:, selection:)
+        filtered = filter(candidates, selection)
+
+        case format
+        when "json" then render_json(filtered)
+        when "text"
+          mode == :diff ? render_diff(filtered) : render_print(filtered)
+        else
+          raise ArgumentError, "unsupported format: #{format}"
+        end
+      end
+
+      private
+
+      EMITTABLE = [Classification::NEW_FILE,
+                   Classification::NEW_METHOD,
+                   Classification::TIGHTER_RETURN].freeze
+      private_constant :EMITTABLE
+
+      def filter(candidates, selection)
+        active = selection.empty? ? EMITTABLE : selection
+        candidates.select { |c| active.include?(c.classification) }
+      end
+
+      def render_print(candidates)
+        if candidates.empty?
+          @out.puts("No candidates")
+          return
+        end
+
+        grouped = candidates.group_by(&:path)
+        grouped.each do |path, items|
+          @out.puts("# #{path}")
+          render_classes(items)
+          @out.puts
+        end
+      end
+
+      def render_classes(items)
+        items.group_by(&:class_name).each do |class_name, methods|
+          @out.puts("class #{class_name}")
+          methods.each do |candidate|
+            tag = case candidate.classification
+                  when Classification::NEW_METHOD then "[new]"
+                  when Classification::NEW_FILE then "[new-file]"
+                  when Classification::TIGHTER_RETURN
+                    "[tighter, was: #{candidate.declared_return_rbs}]"
+                  end
+            @out.puts("  # #{tag}")
+            @out.puts("  #{candidate.rbs}")
+          end
+          @out.puts("end")
+        end
+      end
+
+      def render_diff(candidates)
+        if candidates.empty?
+          @out.puts("No candidates")
+          return
+        end
+
+        candidates.each do |candidate|
+          @out.puts("--- #{candidate.path}: #{candidate.class_name}##{candidate.method_name}")
+          declared = candidate.declared_return_rbs
+          @out.puts("- def #{candidate.method_name}: () -> #{declared}") if declared
+          @out.puts("+ #{candidate.rbs}")
+          @out.puts
+        end
+      end
+
+      def render_json(candidates)
+        payload = { candidates: candidates.map(&:to_h) }
+        @out.puts(JSON.pretty_generate(payload))
+      end
+
+      public
+
+      # Renders the per-source-file outcomes of a `--write`
+      # run. Distinct from {#render} because the write
+      # path's reporting surface is action-oriented (created
+      # / updated / skipped) rather than candidate-oriented.
+      def render_write(results:, format:)
+        case format
+        when "json" then render_write_json(results)
+        when "text" then render_write_text(results)
+        else raise ArgumentError, "unsupported format: #{format}"
+        end
+      end
+
+      private
+
+      def render_write_text(results)
+        if results.all? { |r| r.action == :noop }
+          @out.puts("No changes")
+          return
+        end
+
+        results.each do |result|
+          case result.action
+          when :created then render_write_created(result)
+          when :updated then render_write_updated(result)
+          when :skipped_outside_sig_root then render_write_skipped(result)
+          end
+        end
+      end
+
+      def render_write_created(result)
+        @out.puts("created #{result.target_path} (#{result.applied.size} method(s))")
+      end
+
+      def render_write_updated(result)
+        @out.puts("updated #{result.target_path} (+#{result.applied.size}, " \
+                  "skipped #{result.skipped.size} user-authored)")
+      end
+
+      def render_write_skipped(result)
+        @out.puts("skipped #{result.source_path} -> #{result.target_path} (outside sig root)")
+      end
+
+      def render_write_json(results)
+        @out.puts(JSON.pretty_generate({ results: results.map(&:to_h) }))
+      end
+    end
+  end
+end

data/lib/rigor/sig_gen/type_elaborator.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative "../reflection"
+require_relative "../type"
+
+module Rigor
+  module SigGen
+    # ADR-14 follow-up to the dogfood findings: when the
+    # inference engine produces a `Type::Nominal` for a class
+    # that requires type parameters (`Array`, `Hash`, `Set`,
+    # `Range`, `Enumerable`, `Enumerator`, ...) with an empty
+    # `type_args` array, the carrier is structurally valid but
+    # `erase_to_rbs` renders just `Array` / `Hash` / etc. While
+    # RBS itself accepts the bare form, downstream consumers
+    # (Steep, IDE plugins, gem-published `sig/` trees) expect
+    # the elaborated `Array[untyped]` / `Hash[untyped, untyped]`
+    # spelling.
+    #
+    # This module walks a `Rigor::Type` tree and rebuilds every
+    # raw `Nominal[C]` for a generic `C` into `Nominal[C, [Dynamic, ...]]`
+    # where the arity comes from
+    # `Reflection.class_type_param_names`. The transformation is
+    # purely cosmetic — the resulting carrier is structurally
+    # distinct from the raw form, but `accepts(other) == accepts(other)`
+    # holds because the gradual mode treats `Dynamic[top]`
+    # arguments as covering anything.
+    #
+    # The module is sig-gen-local; the broader question of
+    # whether the inference engine itself should always
+    # construct generics with explicit type_args is queued as
+    # an ADR-14 follow-up.
+    module TypeElaborator
+      # @param type [Rigor::Type]
+      # @param environment [Rigor::Environment]
+      # @return [Rigor::Type] same shape with bare generic
+      #   nominals filled in.
+      def self.elaborate(type, environment:)
+        arity_cache = {}
+        walk(type, environment, arity_cache)
+      end
+
+      def self.walk(type, environment, arity_cache)
+        case type
+        when Type::Nominal then elaborate_nominal(type, environment, arity_cache)
+        when Type::Union   then elaborate_union(type, environment, arity_cache)
+        when Type::Tuple   then elaborate_tuple(type, environment, arity_cache)
+        when Type::HashShape then elaborate_hash_shape(type, environment, arity_cache)
+        else type
+        end
+      end
+
+      def self.elaborate_nominal(type, environment, arity_cache)
+        elaborated_args = type.type_args.map { |arg| walk(arg, environment, arity_cache) }
+        return Type::Combinator.nominal_of(type.class_name, type_args: elaborated_args) if elaborated_args.any?
+
+        arity = generic_arity_for(type.class_name, environment, arity_cache)
+        return type if arity.zero?
+
+        filled = Array.new(arity) { Type::Combinator.untyped }
+        Type::Combinator.nominal_of(type.class_name, type_args: filled)
+      end
+
+      def self.elaborate_union(type, environment, arity_cache)
+        Type::Combinator.union(*type.members.map { |m| walk(m, environment, arity_cache) })
+      end
+
+      def self.elaborate_tuple(type, environment, arity_cache)
+        elements = type.elements.map { |e| walk(e, environment, arity_cache) }
+        Type::Tuple.new(elements)
+      end
+
+      def self.elaborate_hash_shape(type, _environment, _arity_cache)
+        # HashShape's element types are read-only on the carrier;
+        # rebuilding them would need going through the per-pair
+        # required/optional/read-only machinery. Sig-gen only
+        # routes top-level returns through here for now —
+        # nested HashShape elaboration ships as a follow-up if
+        # the need surfaces.
+        type
+      end
+
+      def self.generic_arity_for(class_name, environment, cache)
+        return cache[class_name] if cache.key?(class_name)
+
+        names = Reflection.class_type_param_names(class_name, environment: environment)
+        cache[class_name] = names.size
+      rescue StandardError
+        cache[class_name] = 0
+      end
+    end
+  end
+end

data/lib/rigor/sig_gen/write_result.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Rigor
+  module SigGen
+    # Per-source-file outcome of a `rigor sig-gen --write` run.
+    #
+    # The writer reports back what it did so the renderer (and
+    # the CLI's exit-status logic) can summarise actions and
+    # surface user-authored-skip decisions without having to
+    # re-parse the produced files.
+    #
+    # - `source_path` — original `.rb` file.
+    # - `target_path` — `.rbs` file the writer was responsible
+    #   for (`nil` when the source path falls outside the
+    #   project signature tree, in which case `action` is
+    #   `:skipped_outside_sig_root`).
+    # - `action` — one of `:created` / `:updated` / `:noop` /
+    #   `:skipped_outside_sig_root`.
+    # - `applied` — the {MethodCandidate}s that actually
+    #   landed on disk.
+    # - `skipped` — the {MethodCandidate}s the writer
+    #   declined (e.g. tighter-return without `--overwrite`).
+    #   Each entry pairs the candidate with a skip reason
+    #   keyword (`:user_authored`).
+    class WriteResult
+      attr_reader :source_path, :target_path, :action, :applied, :skipped
+
+      def initialize(source_path:, target_path:, action:, applied: [], skipped: [])
+        @source_path = source_path
+        @target_path = target_path
+        @action = action
+        @applied = applied.freeze
+        @skipped = skipped.freeze
+        freeze
+      end
+
+      def to_h
+        {
+          source: source_path,
+          target: target_path&.to_s,
+          action: action.to_s,
+          applied: applied.map(&:to_h),
+          skipped: skipped.map { |c, reason| c.to_h.merge(write_skip_reason: reason.to_s) }
+        }
+      end
+    end
+  end
+end