kimera 0.1.0

data/lib/kimera/operators/safe_navigation.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::SafeNavigation < Kimera::Operators::Base
+  class << self
+    def key = "safe_navigation"
+  end
+
+  def variants(node, **)
+    return unless node.is_a?(CallNode)
+    return unless node.safe_navigation?
+    solo("&. => .", "csend_to_send")
+  end
+end

data/lib/kimera/operators/selector_swap.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::SelectorSwap < Kimera::Operators::Base
+  SWAPS = { select: :reject, reject: :select, filter_map: :map }
+    .merge({ all?: :any?, any?: :all? })
+    .merge({ min: :max, max: :min })
+    .merge({ first: :last, last: :first })
+    .merge({ detect: :first, find: :first })
+    .freeze
+
+  class << self
+    def key = "selector_swap"
+  end
+
+  def variants(node, **)
+    return unless node.is_a?(CallNode) && node.receiver
+    name = node.name
+    to = SWAPS[name]
+    return unless to
+    solo("#{name} => #{to}", "selector_swap", to: to.to_s)
+  end
+end

data/lib/kimera/operators/statement_deletion.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::StatementDeletion < Kimera::Operators::Base
+  DIAGNOSTIC_NAMES = %i[puts print pp p].freeze
+  LOGGER = %i[logger @logger].freeze
+
+  class << self
+    def key = Kimera::Operators::STATEMENT_DELETION
+
+    def statement? = true
+  end
+
+  def variants(node, **)
+    return unless identifier?(node)
+    return if diagnostic?(node)
+    deletion(node)
+  end
+
+  private
+
+  def diagnostic?(node)
+    syntax(node).diagnostic?(DIAGNOSTIC_NAMES, LOGGER)
+  end
+end

data/lib/kimera/operators/string_literal.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::StringLiteral < Kimera::Operators::Base
+  class << self
+    def key = "string_literal"
+  end
+
+  def variants(node, **)
+    return unless node.is_a?(StringNode)
+    value = node.unescaped
+    return if value.empty?
+    solo("#{excerpt(value)} => \"\"", "string_literal", value: "")
+  end
+
+  private
+
+  def excerpt(value)
+    value.inspect[0, 30]
+  end
+end

data/lib/kimera/operators/symbol_literal.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::SymbolLiteral < Kimera::Operators::Base
+  SUFFIX = "__kimera__"
+
+  class << self
+    def key = "symbol_literal"
+  end
+
+  def variants(node, **)
+    return unless node.is_a?(SymbolNode)
+    return if node.location.slice.end_with?(":")
+    name = node.unescaped
+    return if name.empty?
+    tagged(name)
+  end
+
+  private
+
+  def tagged(name)
+    stem = name[0, 20]
+    solo(":#{stem} => :#{stem}#{SUFFIX}", "symbol_literal", value: "#{name}#{SUFFIX}")
+  end
+end

data/lib/kimera/operators/vocabulary.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "../support/syntax"
+
+module Kimera
+  module Operators
+    Kimera::SyntaxTypes::Installer.new(self).call
+    TYPE = "type"
+    INDEX = "index"
+    STATEMENT_DELETION = "statement_deletion"
+
+    IDENTIFIER = /\A[A-Za-z_]\w*[!?]?\z/
+
+    Variant = Struct.new(:label, :directive, keyword_init: true)
+
+    CallQuery =
+      Data.define(:node) do
+        def named?(names)
+          name = node.name
+          names.is_a?(Symbol) ? name == names : names.include?(name)
+        end
+
+        def call?(names) = node.is_a?(SyntaxTypes::CallNode) && named?(names)
+        def chained?(names) = call?(names) && !!node.receiver
+        def bare?(names) = call?(names) && !node.receiver
+      end
+
+    module Vocabulary
+      module_function
+
+      def directive(type, **fields)
+        { TYPE => type }.merge(fields.transform_keys(&:to_s))
+      end
+
+      def solo(label, type, **fields)
+        [Variant.new(label: label, directive: directive(type, **fields))]
+      end
+
+      def deletion(node)
+        solo("delete `#{first(node)}`", STATEMENT_DELETION)
+      end
+
+      def drops(nodes, type, label:)
+        nodes.each_index.map do |index|
+          Variant.new(label: "#{label} `#{first(nodes[index])}`", directive: directive(type, index: index))
+        end
+      end
+
+      def call(node) = CallQuery.new(node)
+
+      { matches?: :call?, chained?: :chained?, bare?: :bare? }.each do |name, query|
+        define_method(name) { |node, names| call(node).public_send(query, names) }
+      end
+
+      def identifier?(node)
+        node.is_a?(SyntaxTypes::CallNode) && node.name.to_s.match?(IDENTIFIER)
+      end
+
+      def arguments(node)
+        node.arguments&.arguments || []
+      end
+
+      def unary?(node)
+        return false if node.block
+        argument, extra = arguments(node)
+        !extra && argument.is_a?(SyntaxTypes::Node) && !argument.is_a?(SyntaxTypes::SplatNode)
+      end
+
+      def keywords(node)
+        arguments(node).reverse_each.find { |a| a.is_a?(SyntaxTypes::KeywordHashNode) }
+      end
+
+      def unescaped(node)
+        node.unescaped if node.is_a?(SyntaxTypes::SymbolNode)
+      end
+
+      def first(node)
+        node.location.slice.lines.first.to_s.strip
+      end
+    end
+  end
+end

data/lib/kimera/operators.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative "error"
+require_relative "operators/argument_drop"
+require_relative "operators/arithmetic"
+require_relative "operators/base"
+require_relative "operators/boolean"
+require_relative "operators/chain_link_deletion"
+require_relative "operators/collection_literal"
+require_relative "operators/comparison"
+require_relative "operators/conditional"
+require_relative "operators/default_argument"
+require_relative "operators/element_drop"
+require_relative "operators/index_fetch"
+require_relative "operators/kernel_coercion"
+require_relative "operators/method_unwrap"
+require_relative "operators/negation"
+require_relative "operators/numeric_literal"
+require_relative "operators/op_assign"
+require_relative "operators/rails_association"
+require_relative "operators/rails_callback"
+require_relative "operators/rails_permit"
+require_relative "operators/rails_validation"
+require_relative "operators/range"
+require_relative "operators/regexp_literal"
+require_relative "operators/respond_to_guard"
+require_relative "operators/return_value"
+require_relative "operators/safe_navigation"
+require_relative "operators/selector_swap"
+require_relative "operators/statement_deletion"
+require_relative "operators/string_literal"
+require_relative "operators/symbol_literal"
+
+module Kimera
+  module Operators
+    ALL = [
+      Comparison,
+      BooleanConnective,
+      BooleanLiteral,
+      StatementDeletion,
+      Arithmetic,
+      Negation,
+      SafeNavigation,
+      Conditional,
+      NumericLiteral,
+      StringLiteral,
+      CollectionLiteral,
+      Range,
+      MethodUnwrap,
+      ReturnValue,
+      SelectorSwap,
+      RegexpLiteral,
+      RailsPermit,
+      RailsValidation,
+      RailsCallback,
+      RailsAssociation,
+      ElementDrop,
+      ArgumentDrop,
+      OpAssign,
+      IndexFetch,
+      KernelCoercion,
+      RespondToGuard,
+      SymbolLiteral,
+      DefaultArgument,
+      ChainLinkDeletion
+    ].freeze
+
+    DEFAULT_KEYS = [
+      Comparison, BooleanConnective, BooleanLiteral,
+      StatementDeletion, Negation, Conditional
+    ].map(&:key).freeze
+
+    RAILS_KEYS = [RailsPermit, RailsValidation, RailsCallback, RailsAssociation].map(&:key).freeze
+
+    @registered = ALL.dup
+
+    module_function
+
+    def build(keys: DEFAULT_KEYS)
+      requested = expand(keys)
+      validate!(requested)
+      registered.select { |operator| requested.include?(operator.key) }.map(&:new)
+    end
+
+    def keys
+      registered.map(&:key)
+    end
+
+    def registered
+      @registered
+    end
+
+    def register(*klasses)
+      klasses.flatten.each { |klass| admit(klass) }
+      self
+    end
+
+    def reset!
+      @registered = ALL.dup
+      self
+    end
+
+    def admit(klass)
+      raise(UsageError, "not an operator class: #{klass.inspect}") unless operator?(klass)
+      key = klass.key
+      taken = registered.find { |operator| operator.key == key }
+      raise(UsageError, "operator key already registered: #{key} (#{taken})") if taken
+      registered << klass
+    end
+
+    def operator?(klass)
+      klass.is_a?(Class) && klass < Base
+    end
+
+    def custom
+      registered - ALL
+    end
+
+    def expand(keys)
+      Array(keys).map(&:to_s).flat_map { |key| expansion(key) }.uniq
+    end
+
+    def groups
+      { "all" => keys, "rails" => RAILS_KEYS, "custom" => custom.map(&:key) }
+    end
+
+    def expansion(key)
+      groups.fetch(key) { [key] }
+    end
+
+    def vocabulary
+      ["all", "rails", "custom", *keys].join(", ")
+    end
+
+    def validate!(requested)
+      unknown = requested - keys
+      return if unknown.empty?
+      raise(UsageError, "unknown operator(s): #{unknown.join(", ")} (valid: #{vocabulary})")
+    end
+  end
+end

data/lib/kimera/plugins.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "operators/plugins"

data/lib/kimera/registry/builder.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "../operators"
+require_relative "../self_protection"
+require_relative "mutation_point"
+require_relative "registry"
+
+class Kimera::RegistryScan
+  def initialize(operators: nil, root: nil, shielded: true)
+    @chosen = operators
+    @base = root
+    @shielded = shielded
+  end
+
+  def build(paths)
+    fresh.tap do |registry|
+      paths.sort.each { |path| ingest(registry, path) }
+    end
+  end
+
+  def source(source, file:)
+    fresh.tap { |registry| collect(registry, source, file) }
+  end
+
+  private
+
+  def operators = @_operators ||= @chosen || Kimera::Operators.build
+  def root = @_root ||= File.expand_path(@base || Dir.pwd)
+  def numbering = @_numbering ||= Kimera::RegistryScan::Numbering.new
+
+  def fresh
+    Kimera::Registry.new(operators: operators.map(&:key), root: relative(root))
+  end
+
+  def ingest(registry, path)
+    return if @shielded && Kimera::SelfProtection.protected?(path)
+    collect(registry, File.read(path, encoding: Encoding::UTF_8), relative(path))
+  rescue Errno::ENOENT
+    nil
+  end
+
+  def collect(registry, source, file)
+    Kimera::RegistryScan::SourceFile
+      .new(source, file: file, operators: operators, numbering: numbering)
+      .points.each { |point| registry << point }
+    registry
+  end
+
+  def relative(path)
+    abs = File.expand_path(path)
+    return "." if abs == root
+    return path unless abs.start_with?("#{root}/")
+    abs[(root.length + 1)..]
+  end
+end
+
+require_relative "numbering"
+require_relative "source_file"
+require_relative "tally"

data/lib/kimera/registry/mutation_point.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Kimera
+  Location =
+    Struct.new(
+      :start_offset, :span,
+      :start_line, :start_column,
+      :end_line, :end_column,
+      keyword_init: true
+    ) do
+      def finish
+        start_offset + span
+      end
+
+      def range
+        (start_line..end_line)
+      end
+
+      def within?(from, to)
+        interior = ((from + 1)...to)
+        interior.cover?(start_offset) && interior.cover?(finish)
+      end
+
+      def to_h
+        coordinates.merge(columns).merge(offsets)
+      end
+
+      def coordinates
+        { "start_line" => start_line, "end_line" => end_line }
+      end
+
+      def columns
+        { "start_column" => start_column, "end_column" => end_column }
+      end
+
+      def offsets
+        { "start_offset" => start_offset, "length" => span }
+      end
+      class << self
+        def parse(source)
+          new(**extent(source), **corners(source))
+        end
+
+        def from_h(hash) = new(**hash.transform_keys { |key| key == "length" ? :span : key.to_sym })
+        def extent(source) = { start_offset: source.start_offset, span: source.length }
+        def anchor(source) = { start_line: source.start_line, start_column: source.start_column }
+        def corners(source) = anchor(source).merge(end_line: source.end_line, end_column: source.end_column)
+      end
+    end
+
+  Mutant =
+    Struct.new(:id, :label, :directive, keyword_init: true) do
+      def to_h
+        { "id" => id, "label" => label, "directive" => directive }
+      end
+
+      def self.from_h(hash)
+        new(id: hash["id"], label: hash["label"], directive: hash["directive"])
+      end
+
+      def self.of(id, variant)
+        new(id: id, label: variant.label, directive: variant.directive)
+      end
+    end
+end
+
+class Kimera::MutationPoint
+  CLASS_BODY_REASON = "class-body DSL (runs at load; evaluate with --isolated)"
+  SAFE = true
+
+  FIELDS = %i[point_id file operator node_type location original_source method_name mutants unsafe_reason].freeze
+  FIELDS.each { |field| define_method(field) { @attributes[field] } }
+
+  class << self
+    def from_h(hash)
+      new(**plain(hash), **rich(hash))
+    end
+
+    private
+
+    def plain(hash)
+      { point_id: hash["point_id"], file: hash["file"], operator: hash["operator"] }
+        .merge(node_type: hash["node_type"], original_source: hash["original_source"])
+    end
+
+    def rich(hash)
+      { location: Kimera::Location.from_h(hash["location"]), method_name: hash["method_name"] }
+        .merge(unsafe_reason: hash["unsafe_reason"], schema_safe: hash.fetch("schema_safe", SAFE))
+        .merge(mutants: Array(hash["mutants"]).map { |m| Kimera::Mutant.from_h(m) })
+    end
+  end
+
+  def initialize(**attributes)
+    @attributes = attributes
+  end
+
+  def body?
+    unsafe_reason == CLASS_BODY_REASON
+  end
+
+  def safe
+    @attributes.fetch(:schema_safe, SAFE)
+  end
+
+  def unsafe!(reason)
+    @attributes[:schema_safe] = false
+    @attributes[:unsafe_reason] = reason
+  end
+
+  def taint!(ranges)
+    return self unless safe?
+    hit = ranges.find { |range| range.contains?(location.start_offset, location.finish) }
+    unsafe!(hit.reason) if hit
+    self
+  end
+
+  def ids
+    mutants.map(&:id)
+  end
+
+  def project(*fields)
+    fields.map { |field| public_send(field) }
+  end
+
+  def safe?
+    safe
+  end
+
+  def to_h
+    identity.merge(anchor).merge(verdict).merge("mutants" => mutants.map(&:to_h))
+  end
+
+  def identity
+    { "point_id" => point_id, "file" => file, "operator" => operator }
+  end
+
+  def anchor
+    { "node_type" => node_type, "location" => location.to_h, "original_source" => original_source }
+  end
+
+  def verdict
+    { "method_name" => method_name, "schema_safe" => safe, "unsafe_reason" => unsafe_reason }
+  end
+
+  NONE = new(mutants: []).freeze
+end

data/lib/kimera/registry/numbering.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "tally"
+
+class Kimera::RegistryScan::Numbering
+  def point = points.next
+
+  def mutant = mutants.next
+
+  private
+
+  def points = @_points ||= Kimera::RegistryScan::Tally.new
+
+  def mutants = @_mutants ||= Kimera::RegistryScan::Tally.new
+end

data/lib/kimera/registry/registry.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "mutation_point"
+
+class Kimera::Registry
+  FORMAT_VERSION = 1
+
+  attr_reader :points, :operators, :root
+
+  def initialize(points: [], operators: [], root: ".")
+    @points = points
+    @operators = operators
+    @root = root
+  end
+
+  def <<(point)
+    @points << point
+    @_groups = nil
+    self
+  end
+
+  def size
+    @points.size
+  end
+
+  def count
+    @points.sum { |p| p.mutants.size }
+  end
+
+  def files
+    groups.keys
+  end
+
+  def summary
+    "Found #{count} mutants at #{size} mutation " \
+      "points across #{files.size} files."
+  end
+
+  def at(file)
+    groups.fetch(file, [])
+  end
+
+  def index
+    @_index ||= by_mutant_id { |_mutant, point| point }
+  end
+
+  def mutant(id)
+    lookup[id]
+  end
+
+  def point(id)
+    paired[id]
+  end
+
+  def each
+    return enum_for(:each) unless block_given?
+    @points.each do |point|
+      point.mutants.each { |m| yield(m, point) }
+    end
+  end
+
+  def to_h
+    identity.merge(stats)
+  end
+
+  def identity
+    { "format_version" => FORMAT_VERSION, "root" => root, "operators" => operators }
+  end
+
+  def stats
+    {
+      "stats" => { "files" => files.size, "points" => size, "mutants" => count },
+      "points" => points.map(&:to_h)
+    }
+  end
+
+  def to_json(*)
+    JSON.generate(to_h, *)
+  end
+
+  def write(path)
+    File.write(path, JSON.pretty_generate(to_h))
+    path
+  end
+
+  class << self
+    def from_h(hash)
+      new(root: hash["root"] || ".", operators: hash["operators"] || [], points: cast(hash["points"]))
+    end
+
+    def load(path)
+      from_h(JSON.parse(File.read(path, encoding: Encoding::UTF_8)))
+    end
+
+    private
+
+    def cast(points)
+      Array(points).map { |p| Kimera::MutationPoint.from_h(p) }
+    end
+  end
+
+  private
+
+  def groups
+    @_groups ||= @points.group_by(&:file)
+  end
+
+  def paired
+    @_paired ||= by_mutant_id { |mutant, point| [mutant, point] }
+  end
+
+  def lookup
+    @_lookup ||= by_mutant_id { |mutant, _point| mutant }
+  end
+
+  def by_mutant_id
+    each.with_object({}) { |(mutant, point), hash| hash[mutant.id] = yield(mutant, point) }
+  end
+end