henitai 0.1.0

data/lib/henitai/subject_resolver.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require_relative "source_parser"
+require_relative "subject"
+
+module Henitai
+  # Resolves AST subjects from Ruby source files.
+  #
+  # The resolver walks Prism-translated ASTs and extracts method definitions
+  # with the namespace context established by surrounding module/class nodes.
+  class SubjectResolver
+    def resolve_from_files(paths)
+      Array(paths).flat_map do |path|
+        resolve_from_file(path)
+      end
+    end
+
+    def apply_pattern(subjects, pattern)
+      pattern_subject = Subject.parse(pattern)
+
+      Array(subjects).select do |subject|
+        match_subject?(subject, pattern_subject)
+      end
+    end
+
+    private
+
+    def resolve_from_file(path)
+      subjects = []
+      walk(
+        SourceParser.parse_file(path),
+        namespace: nil,
+        singleton_context: false,
+        subjects:
+      )
+      subjects
+    end
+
+    def walk(node, namespace:, singleton_context:, subjects:)
+      return unless node.respond_to?(:type)
+      return if anonymous_class_block?(node)
+
+      namespace, singleton_context = update_context(
+        node,
+        namespace,
+        singleton_context
+      )
+
+      collect_subject(node, namespace, singleton_context, subjects)
+      traverse_children(node, namespace, singleton_context, subjects)
+    end
+
+    def collect_subject(node, namespace, singleton_context, subjects)
+      subject = subject_for(node, namespace, singleton_context)
+      subjects << subject if subject
+    end
+
+    def traverse_children(node, namespace, singleton_context, subjects)
+      node.children.each do |child|
+        walk(child, namespace:, singleton_context:, subjects:)
+      end
+    end
+
+    def anonymous_class_block?(node)
+      return false unless node.type == :block
+
+      call_node = node.children.first
+      return false unless call_node.respond_to?(:type)
+      return false unless call_node.type == :send
+
+      receiver = call_node.children.first
+      method_name = call_node.children[1]
+      receiver_name = constant_name(receiver)
+
+      anonymous_constructor_call?(receiver_name, method_name)
+    end
+
+    def anonymous_constructor_call?(receiver_name, method_name)
+      anonymous_receivers = %w[Class Module Struct Data]
+      anonymous_methods = %i[new define]
+
+      anonymous_receivers.include?(receiver_name) &&
+        anonymous_methods.include?(method_name)
+    end
+
+    def update_context(node, namespace, singleton_context)
+      case node.type
+      when :class, :module
+        [qualify_namespace(namespace, constant_name(node.children.first)),
+         singleton_context]
+      when :sclass
+        [namespace, true]
+      else
+        [namespace, singleton_context]
+      end
+    end
+
+    def subject_for(node, namespace, singleton_context)
+      case node.type
+      when :block
+        define_method_subject(node, namespace, singleton_context)
+      when :def
+        instance_subject(node, namespace, singleton_context)
+      when :defs
+        class_subject(node, namespace)
+      end
+    end
+
+    def instance_subject(node, namespace, singleton_context)
+      return unless namespace
+
+      Subject.new(
+        namespace:,
+        method_name: method_name(node.children.first),
+        method_type: singleton_context ? :class : :instance,
+        source_location: source_location_for(node),
+        ast_node: node
+      )
+    end
+
+    def class_subject(node, namespace)
+      return unless namespace
+
+      Subject.new(
+        namespace:,
+        method_name: method_name(node.children[1]),
+        method_type: :class,
+        source_location: source_location_for(node),
+        ast_node: node
+      )
+    end
+
+    def define_method_subject(node, namespace, singleton_context)
+      call_node = node.children.first
+      return unless define_method_call?(call_node)
+      return unless namespace
+
+      method_name = define_method_name(call_node)
+      return unless method_name
+
+      Subject.new(
+        namespace:,
+        method_name:,
+        method_type: singleton_context ? :class : :instance,
+        source_location: source_location_for(node),
+        ast_node: node
+      )
+    end
+
+    def qualify_namespace(namespace, name)
+      return name if namespace.nil? || namespace.empty?
+      return namespace if name.nil? || name.empty?
+
+      "#{namespace}::#{name}"
+    end
+
+    def constant_name(node)
+      return unless node.respond_to?(:type)
+
+      case node.type
+      when :const
+        parent_name = constant_name(node.children.first)
+        current_name = symbol_name(node.children.last)
+
+        return current_name if parent_name.nil? || parent_name.empty?
+
+        "#{parent_name}::#{current_name}"
+      when :cbase
+        ""
+      end
+    end
+
+    def method_name(value)
+      symbol_name(value)
+    end
+
+    def define_method_call?(call_node)
+      return false unless call_node.respond_to?(:type)
+      return false unless call_node.type == :send
+      return false unless call_node.children[1] == :define_method
+
+      receiver = call_node.children.first
+      receiver.nil? || receiver.type == :self
+    end
+
+    def define_method_name(call_node)
+      literal_method_name(call_node.children[2])
+    end
+
+    def literal_method_name(node)
+      return unless node.respond_to?(:type)
+
+      case node.type
+      when :sym, :str
+        symbol_name(node.children.first)
+      end
+    end
+
+    def symbol_name(value)
+      # Prism exposes identifiers as symbols (for example, :foo), so normalize
+      # them to the string form used by Subject expressions.
+      value.to_s.delete_prefix(":")
+    end
+
+    def source_location_for(node)
+      location = node.location.expression
+
+      {
+        file: location.source_buffer.name,
+        range: location.line..location.last_line
+      }
+    end
+
+    def match_subject?(subject, pattern_subject)
+      if pattern_subject.wildcard?
+        wildcard_match?(subject, pattern_subject)
+      else
+        subject.expression == pattern_subject.expression
+      end
+    end
+
+    def wildcard_match?(subject, pattern_subject)
+      subject_namespace = subject.namespace
+      pattern_namespace = pattern_subject.namespace
+
+      return false unless subject_namespace
+
+      subject_namespace == pattern_namespace ||
+        subject_namespace.start_with?("#{pattern_namespace}::")
+    end
+  end
+end

data/lib/henitai/syntax_validator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "stillborn_filter"
+
+module Henitai
+  # Validates that a mutant can be rendered and compiled as Ruby source.
+  class SyntaxValidator
+    def initialize
+      @stillborn_filter = StillbornFilter.new
+    end
+
+    def valid?(mutant)
+      !@stillborn_filter.suppressed?(mutant)
+    end
+  end
+end

data/lib/henitai/test_prioritizer.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Orders test files so previously effective tests run first.
+  class TestPrioritizer
+    def sort(tests, _mutant, history)
+      Array(tests).each_with_index.sort_by do |test, index|
+        [-history_count(history, test), index]
+      end.map(&:first)
+    end
+
+    private
+
+    def history_count(history, test)
+      return 0 unless history.respond_to?(:fetch)
+
+      history_value = history_value_for(history, test)
+
+      case history_value
+      when Integer
+        history_value
+      when Hash
+        history_value.fetch(:kills, history_value.fetch("kills", 0)).to_i
+      else
+        history_value.to_i
+      end
+    end
+
+    def history_value_for(history, test)
+      history_key_candidates(test).each do |key|
+        value = history.fetch(key, nil)
+        return value unless value.nil?
+      end
+
+      0
+    end
+
+    def history_key_candidates(test)
+      key = test.to_s
+      candidates = [key, File.expand_path(key), relative_history_key(key)]
+      candidates.compact.uniq
+    rescue StandardError
+      [key]
+    end
+
+    def relative_history_key(path)
+      pathname = Pathname.new(path)
+      return unless pathname.absolute?
+
+      pathname.relative_path_from(Pathname.pwd).to_s
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/henitai/unparse_helper.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "unparser"
+
+module Henitai
+  # Shared safe unparse helpers for user-facing output and report serialization.
+  module UnparseHelper
+    private
+
+    def safe_unparse(node)
+      Unparser.unparse(node)
+    rescue StandardError
+      # Unparser does not support all AST node types, so fall back gracefully.
+      fallback_source(node)
+    end
+
+    def fallback_source(node)
+      return "" if node.nil?
+      return node.type.to_s if node.respond_to?(:type)
+
+      node.class.name
+    end
+  end
+end

data/lib/henitai/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Henitai
+  VERSION = "0.1.0"
+end

data/lib/henitai/warning_silencer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Temporarily suppresses noisy warnings emitted by third-party libraries.
+  module WarningSilencer
+    def self.silence
+      original_stderr = $stderr
+      File.open(File::NULL, "w") do |sink|
+        $stderr = sink
+        yield
+      end
+    ensure
+      $stderr = original_stderr
+    end
+  end
+end

data/lib/henitai.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "henitai/version"
+
+# Hen'i-tai (変異体) — Mutation testing for Ruby
+#
+# Usage:
+#   henitai run --use rspec 'MyNamespace*'
+#   henitai run --since HEAD~1 'MyClass#my_method'
+#
+module Henitai
+  HISTORY_STORE_FILENAME = "mutation-history.sqlite3"
+
+  # Raised when the framework encounters a configuration error
+  class ConfigurationError < StandardError; end
+
+  # Raised when a subject expression cannot be resolved
+  class SubjectNotFound < StandardError; end
+
+  # Raised when coverage data cannot be bootstrapped or validated.
+  class CoverageError < StandardError; end
+
+  autoload :Configuration, "henitai/configuration"
+  autoload :CoverageBootstrapper, "henitai/coverage_bootstrapper"
+  autoload :Subject, "henitai/subject"
+  autoload :Mutant, "henitai/mutant"
+  autoload :Operator, "henitai/operator"
+  autoload :Operators, "henitai/operators"
+  autoload :SourceParser, "henitai/source_parser"
+  autoload :SubjectResolver, "henitai/subject_resolver"
+  autoload :GitDiffAnalyzer, "henitai/git_diff_analyzer"
+  autoload :GitDiffError, "henitai/git_diff_analyzer"
+  autoload :MutantGenerator, "henitai/mutant_generator"
+  autoload :MutantHistoryStore, "henitai/mutant_history_store"
+  autoload :AridNodeFilter, "henitai/arid_node_filter"
+  autoload :EquivalenceDetector, "henitai/equivalence_detector"
+  autoload :StaticFilter, "henitai/static_filter"
+  autoload :StillbornFilter, "henitai/stillborn_filter"
+  autoload :ScenarioExecutionResult, "henitai/scenario_execution_result"
+  autoload :CoverageFormatter, "henitai/coverage_formatter"
+  autoload :SyntaxValidator, "henitai/syntax_validator"
+  autoload :SamplingStrategy, "henitai/sampling_strategy"
+  autoload :TestPrioritizer, "henitai/test_prioritizer"
+  autoload :ExecutionEngine, "henitai/execution_engine"
+  autoload :Runner, "henitai/runner"
+  autoload :Reporter, "henitai/reporter"
+  autoload :Integration, "henitai/integration"
+  autoload :Result, "henitai/result"
+  autoload :WarningSilencer, "henitai/warning_silencer"
+  autoload :CLI, "henitai/cli"
+end

data/sig/configuration_validator.rbs

@@ -0,0 +1,29 @@
+module Henitai
+  module ConfigurationValidator
+    def self.validate!: (Hash[Symbol, untyped]) -> void
+
+    private
+
+    def self.validate_top_level_keys: (Hash[Symbol, untyped]) -> void
+    def self.validate_integration: (Hash[Symbol, untyped]) -> void
+    def self.validate_includes: (Hash[Symbol, untyped]) -> void
+    def self.validate_jobs: (Hash[Symbol, untyped]) -> void
+    def self.validate_reporters: (Hash[Symbol, untyped]) -> void
+    def self.validate_all_logs: (Hash[Symbol, untyped]) -> void
+    def self.validate_dashboard: (Hash[Symbol, untyped]) -> void
+    def self.validate_mutation: (Hash[Symbol, untyped]) -> void
+    def self.validate_coverage_criteria: (Hash[Symbol, untyped]) -> void
+    def self.validate_thresholds: (Hash[Symbol, untyped]) -> void
+    def self.validate_operator: (untyped) -> void
+    def self.validate_timeout: (untyped) -> void
+    def self.validate_threshold: (untyped, String) -> void
+    def self.validate_boolean: (untyped, String) -> void
+    def self.validate_optional_string: (untyped, String) -> void
+    def self.validate_string_array: (untyped, String) -> void
+    def self.warn_unknown_keys: (Hash[Symbol, untyped], Array[Symbol], ?String) -> void
+    def self.key_path: (?String, Symbol) -> String
+    def self.ensure_hash!: (untyped, String) -> void
+    def self.describe_array_type: (untyped) -> String
+    def self.configuration_error: (String) -> void
+  end
+end