kimera 0.1.0

data/lib/kimera/operators/arithmetic.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "binary_swap"
+
+class Kimera::Operators::Arithmetic < Kimera::Operators::BinarySwap
+  MUTATIONS = { :+ => [:-], :- => [:+], :* => [:/] }.merge({ :/ => [:*], :% => [:*], :** => [:*] }).freeze
+  DIRECTIVE = "op_swap"
+
+  class << self
+    def key = "arithmetic"
+  end
+end

data/lib/kimera/operators/audit.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "../audit/operator_audit"

data/lib/kimera/operators/base.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../support/syntax_types"
+require_relative "vocabulary"
+
+class Kimera::Operators::Base
+  SYNTAX = ->(node) { Kimera::Syntax.view(node) }
+  include Kimera::SyntaxTypes
+  include Kimera::Operators::Vocabulary
+
+  class << self
+    def key = raise(NotImplementedError, "#{self} must define .key")
+
+    def statement? = false
+
+    def body? = false
+  end
+
+  def key
+    self.class.key
+  end
+
+  def statement?
+    self.class.statement?
+  end
+
+  def body?
+    self.class.body?
+  end
+
+  def variants(node, position:)
+    raise(NotImplementedError, "#{self} must define #variants")
+  end
+
+  def pairs(node, position:)
+    Array(variants(node, position: position)).map { |variant| [key, variant] }
+  end
+
+  def syntax(node) = self.class::SYNTAX.call(node)
+end

data/lib/kimera/operators/binary_swap.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::BinarySwap < Kimera::Operators::Base
+  def variants(node, **)
+    return unless swappable?(node)
+    name = node.name
+    self.class::MUTATIONS[name].map { |to| swap(name, to) }
+  end
+
+  private
+
+  def swappable?(node)
+    return false unless node.is_a?(CallNode)
+    return false unless arguments(node).length == 1
+    self.class::MUTATIONS.key?(node.name)
+  end
+
+  def swap(name, to)
+    Kimera::Operators::Variant.new(label: "#{name} => #{to}", directive: directive(self.class::DIRECTIVE, to: to.to_s))
+  end
+end

data/lib/kimera/operators/boolean.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "node_swap"
+
+module Kimera
+  module Operators
+    BOOLEAN_OPERATORS = {
+      BooleanConnective: [
+        "boolean_connective",
+        {
+          AndNode => { label: "&& => ||", to: "or" },
+          OrNode => { label: "|| => &&", to: "and" }
+        }
+      ],
+      BooleanLiteral: [
+        "boolean_literal",
+        {
+          TrueNode => { label: "true => false", to: "false" },
+          FalseNode => { label: "false => true", to: "true" }
+        }
+      ]
+    }.freeze
+
+    BOOLEAN_OPERATORS.each { |name, (key, swaps)| const_set(name, NodeSwap.define(key, swaps)) }
+  end
+end

data/lib/kimera/operators/chain_link_deletion.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "base"
+
+class Kimera::Operators::ChainLinkDeletion < Kimera::Operators::Base
+  class << self
+    def key = "chain_link_deletion"
+  end
+
+  def variants(node, **)
+    return unless deletable?(node)
+    solo("drop chain link `.#{node.receiver.name}`", "drop_receiver_link")
+  end
+
+  private
+
+  def deletable?(node)
+    return false unless node.is_a?(CallNode)
+    link = node.receiver
+    return false unless link.is_a?(CallNode) && link.receiver
+    return false if link.block.is_a?(BlockNode)
+    identifier?(link)
+  end
+end

data/lib/kimera/operators/collection_literal.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::CollectionLiteral < Kimera::Operators::Base
+  EMPTIED = { ArrayNode => "array => []", HashNode => "hash => {}" }.freeze
+
+  class << self
+    def key = "collection_literal"
+  end
+
+  def variants(node, **)
+    case node
+    when ArrayNode, HashNode
+      solo(EMPTIED[node.class], "empty_collection") unless node.elements.empty?
+    end
+  end
+end

data/lib/kimera/operators/comparison.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "binary_swap"
+
+class Kimera::Operators::Comparison < Kimera::Operators::BinarySwap
+  MUTATIONS = { :> => %i[>= <], :>= => %i[> <=], :< => %i[<= >] }
+    .merge({ :<= => %i[< >=], :== => [:!=], :!= => [:==] }).freeze
+  DIRECTIVE = "comparison"
+
+  class << self
+    def key = "comparison"
+  end
+end

data/lib/kimera/operators/conditional.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::Conditional < Kimera::Operators::Base
+  class << self
+    def key = "conditional"
+  end
+
+  def variants(node, **)
+    return unless conditional?(node)
+    return if elsif?(node)
+    return if memoized?(node)
+    %w[true false].map { |to| flip(to) }
+  end
+
+  private
+
+  def flip(to)
+    Kimera::Operators::Variant.new(label: "condition => #{to}", directive: directive("condition", to: to))
+  end
+
+  def conditional?(node)
+    node.is_a?(IfNode) || node.is_a?(UnlessNode)
+  end
+
+  def elsif?(node)
+    node.is_a?(IfNode) && node.if_keyword_loc&.slice == "elsif"
+  end
+
+  def memoized?(node)
+    predicate = node.predicate
+    predicate.is_a?(DefinedNode) &&
+      predicate.value.is_a?(InstanceVariableReadNode)
+  end
+end

data/lib/kimera/operators/default_argument.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::DefaultArgument < Kimera::Operators::Base
+  class << self
+    def key = "default_argument"
+  end
+
+  def variants(node, **)
+    case node
+    when OptionalParameterNode, OptionalKeywordParameterNode
+      name = node.name
+      solo("default => required (#{name})", "required_argument", name: name.to_s)
+    end
+  end
+end

data/lib/kimera/operators/element_drop.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::ElementDrop < Kimera::Operators::Base
+  SPLATS = { ArrayNode => SplatNode, HashNode => AssocSplatNode }.freeze
+
+  class << self
+    def key = "element_drop"
+  end
+
+  def variants(node, **)
+    parts = collection(node)
+    drop(*parts) if parts
+  end
+
+  private
+
+  def collection(node)
+    syntax(node).collection(SPLATS)
+  end
+
+  def drop(elements, splat)
+    return unless droppable?(elements, splat)
+    drops(elements, "drop_element", label: "drop")
+  end
+
+  def droppable?(elements, splat)
+    elements.length > 1 && elements.none?(splat)
+  end
+end

data/lib/kimera/operators/index_fetch.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::IndexFetch < Kimera::Operators::Base
+  class << self
+    def key = "index_fetch"
+  end
+
+  def variants(node, **)
+    return unless call(node).chained?(:[])
+    return unless unary?(node)
+    solo("[] => fetch", "index_to_fetch")
+  end
+end

data/lib/kimera/operators/kernel_coercion.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::KernelCoercion < Kimera::Operators::Base
+  COERCIONS = %i[Array String Integer Float].freeze
+
+  class << self
+    def key = "kernel_coercion"
+  end
+
+  def variants(node, **)
+    return unless call(node).bare?(COERCIONS)
+    return unless unary?(node)
+    solo("delete #{node.name}()", "unwrap_argument")
+  end
+end

data/lib/kimera/operators/method_unwrap.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::MethodUnwrap < Kimera::Operators::Base
+  UNWRAPPABLE = %i[
+    dup clone freeze to_s to_sym to_i to_f to_a to_h
+    strip chomp lstrip rstrip downcase upcase capitalize
+    uniq compact flatten sort reverse presence
+  ].freeze
+
+  class << self
+    def key = "method_unwrap"
+  end
+
+  def variants(node, **)
+    name = syntax(node).unwrap(UNWRAPPABLE)
+    solo("delete .#{name}", "unwrap_receiver") if name
+  end
+end

data/lib/kimera/operators/negation.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::Negation < Kimera::Operators::Base
+  class << self
+    def key = "negation"
+  end
+
+  def variants(node, **)
+    return unless call(node).chained?(:!)
+    return if node.arguments
+    solo("delete !", "unwrap_receiver")
+  end
+end

data/lib/kimera/operators/node_swap.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::NodeSwap < Kimera::Operators::Base
+  class << self
+    def define(key, mutations)
+      Class.new(self) do
+        const_set(:MUTATIONS, mutations.freeze)
+        define_singleton_method(:key) { key }
+      end
+    end
+  end
+
+  def variants(node, **)
+    swap = self.class::MUTATIONS[node.class]
+    return unless swap
+    solo(swap[:label], key, to: swap[:to])
+  end
+end

data/lib/kimera/operators/numeric_literal.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::NumericLiteral < Kimera::Operators::Base
+  IntegerTargets =
+    Data.define(:value) do
+      include Enumerable
+      def each(&) = targets.uniq.each(&)
+      private
+      def targets
+        [value - 1, value + 1].tap { |all| all << 0 unless value.zero? }
+      end
+    end
+  class << self
+    def key = "numeric_literal"
+  end
+
+  def variants(node, **)
+    case node
+    in IntegerNode(value:) then integers(value)
+    in FloatNode(value:) then floats(value)
+    else nil
+    end
+  end
+
+  private
+
+  def integers(value)
+    IntegerTargets.new(value).map do |to|
+      Kimera::Operators::Variant.new(label: "#{value} => #{to}", directive: directive("integer_literal", value: to))
+    end
+  end
+
+  def floats(value)
+    shifted = value + 1.0
+    solo("#{value} => #{shifted}", "float_literal", value: shifted)
+  end
+end

data/lib/kimera/operators/op_assign.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::OpAssign < Kimera::Operators::Base
+  MUTATIONS = { :+ => :-, :- => :+, :* => :/ }.merge({ :/ => :*, :% => :* }).freeze
+
+  class << self
+    def key = "op_assign"
+  end
+
+  def variants(node, **)
+    operator = syntax(node).operator
+    to = MUTATIONS[operator]
+    return unless to
+    solo("#{operator}= => #{to}=", "op_asgn_swap", to: to.to_s)
+  end
+end

data/lib/kimera/operators/plugins.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../error"
+require_relative "../operators"
+
+module Kimera
+  module Plugins
+    module_function
+
+    def load!(paths, root: ".")
+      Array(paths).each { |path| pull(path, root) }
+      Kimera::Operators.custom
+    end
+
+    def pull(path, root)
+      require(resolve(path, root))
+    rescue Kimera::Error
+      raise
+    rescue ScriptError, StandardError => error
+      raise(UsageError, "cannot load #{path}: #{error.class}: #{error.message}")
+    end
+
+    def resolve(path, root)
+      File.expand_path(path, File.expand_path(root))
+    end
+  end
+end

data/lib/kimera/operators/rails_association.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "rails_declaration"
+
+class Kimera::Operators::RailsAssociation < Kimera::Operators::RailsDeclaration
+  NAMES = %i[has_many has_one belongs_to has_and_belongs_to_many].freeze
+
+  class << self
+    def key = "rails_association"
+  end
+
+  private
+
+  def declaration(node)
+    return unless dependent?(node)
+    solo("#{first(node)}: drop dependent:", "kwarg_pair_drop", key: "dependent")
+  end
+
+  def dependent?(node)
+    keywords(node)&.elements.to_a.any? do |assoc|
+      assoc.is_a?(AssocNode) && unescaped(assoc.key) == "dependent"
+    end
+  end
+end

data/lib/kimera/operators/rails_callback.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "rails_declaration"
+
+class Kimera::Operators::RailsCallback < Kimera::Operators::RailsDeclaration
+  NAMES = %i[
+    before_action after_action around_action
+    before_save after_save before_create after_create
+    before_update after_update before_destroy after_destroy
+    before_validation after_validation after_commit after_rollback
+    after_initialize after_find after_touch
+  ].freeze
+
+  class << self
+    def key = "rails_callback"
+  end
+
+  private
+
+  def declaration(node)
+    deletion(node) + scopes(node)
+  end
+
+  def scopes(node)
+    keywords(node)&.elements.to_a.flat_map { |assoc| scope(node, assoc) }
+  end
+
+  def scope(node, assoc)
+    return [] unless scopable?(assoc)
+    indexed(node, unescaped(assoc.key), assoc.value.elements)
+  end
+
+  def scopable?(assoc)
+    return false unless assoc.is_a?(AssocNode)
+    return false unless %w[only except].include?(unescaped(assoc.key))
+    assoc.value.is_a?(ArrayNode)
+  end
+
+  def indexed(node, key, elements)
+    elements.each_index.map { |index| variant(node, key, elements, index) }
+  end
+
+  def variant(node, key, elements, index)
+    Kimera::Operators::Variant.new(
+      label: "#{node.name}: drop #{elements[index].location.slice} from #{key}:",
+      directive: directive("kwarg_element_drop", key: key, index: index)
+    )
+  end
+end

data/lib/kimera/operators/rails_declaration.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::RailsDeclaration < Kimera::Operators::Base
+  class << self
+    def body? = true
+
+    def statement? = true
+  end
+
+  def variants(node, **)
+    return unless call(node).bare?(self.class::NAMES)
+    declaration(node)
+  end
+end

data/lib/kimera/operators/rails_permit.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::RailsPermit < Kimera::Operators::Base
+  class << self
+    def key = "rails_permit"
+  end
+
+  def variants(node, **)
+    return unless call(node).chained?(:permit)
+    args = arguments(node)
+    return unless args.all? { |a| plain?(a) }
+    indexed(args)
+  end
+
+  private
+
+  def indexed(args)
+    args.each_index.map { |index| variant(args, index) }
+  end
+
+  def variant(args, index)
+    Kimera::Operators::Variant.new(
+      label: "permit: drop #{args[index].location.slice}",
+      directive: directive("drop_argument", index: index)
+    )
+  end
+
+  def plain?(node)
+    !node.is_a?(SplatNode) && !node.is_a?(KeywordHashNode) &&
+      !node.is_a?(BlockArgumentNode)
+  end
+end

data/lib/kimera/operators/rails_validation.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "rails_declaration"
+
+class Kimera::Operators::RailsValidation < Kimera::Operators::RailsDeclaration
+  NAMES = %i[validates validate validates_with validates_each].freeze
+
+  class << self
+    def key = "rails_validation"
+  end
+
+  private
+
+  def declaration(node)
+    deletion(node)
+  end
+end

data/lib/kimera/operators/range.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::Range < Kimera::Operators::Base
+  class << self
+    def key = "range"
+  end
+
+  def variants(node, **)
+    return unless node.is_a?(RangeNode)
+    return solo("... => ..", "range_flip", to: "irange") if node.exclude_end?
+    solo(".. => ...", "range_flip", to: "erange")
+  end
+end

data/lib/kimera/operators/regexp_literal.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::RegexpLiteral < Kimera::Operators::Base
+  class << self
+    def key = "regexp"
+  end
+
+  def variants(node, **)
+    return unless node.is_a?(RegularExpressionNode)
+    return if node.unescaped.empty?
+    solo("regexp => // (match all)", "regexp_literal", source: "") +
+      solo("regexp => /(?!)/ (match none)", "regexp_literal", source: "(?!)")
+  end
+end

data/lib/kimera/operators/respond_to_guard.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::RespondToGuard < Kimera::Operators::Base
+  class << self
+    def key = "respond_to_guard"
+  end
+
+  def variants(node, **)
+    return unless guard?(node)
+    solo("delete .respond_to?", "unwrap_receiver")
+  end
+
+  private
+
+  def guard?(node)
+    return false unless call(node).chained?(:respond_to?) && !node.block
+    args = arguments(node)
+    return false unless (1..2).cover?(args.length)
+    target = args.first
+    target.is_a?(SymbolNode) || target.is_a?(StringNode)
+  end
+end

data/lib/kimera/operators/return_value.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Kimera::Operators::ReturnValue < Kimera::Operators::Base
+  class << self
+    def key = "return_value"
+  end
+
+  SKIPPED = [NilNode, ParenthesesNode].freeze
+  POSITIONS = Hash.new(->(_operator, _node) {}).merge(tail: ->(operator, node) { operator.tail(node) }).freeze
+
+  def variants(node, position:)
+    return returned(node) if node.is_a?(ReturnNode)
+    POSITIONS[position].call(self, node)
+  end
+
+  private
+
+  def tail(node)
+    solo("tail => nil", Kimera::Operators::STATEMENT_DELETION) if nilable?(node)
+  end
+
+  public :tail
+
+  def nilable?(node)
+    return false if identifier?(node)
+    SKIPPED.none? { |kind| node.is_a?(kind) }
+  end
+
+  def returned(node)
+    args = arguments(node)
+    return if args.empty? || (args in [NilNode])
+    solo("return => return nil", "return_nil")
+  end
+end