crispr 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d070d677dfe3f0926fff8ddf0a2f31aae859ed65a5fdeb76164eaf180a2fc921
-  data.tar.gz: 1a76d002b52a92f4ff756eb11cac032dbaccda83e23fec8bbbfa4ababbfe64a9
+  metadata.gz: fd1d78ee623852936e6f40e030ed4759e1f62315a653908c90efa0f905e3e70e
+  data.tar.gz: 30ca300c36a24e0330e9a891ad9f13c933ba95fe34b51478ef285c94777ac129
 SHA512:
-  metadata.gz: 7bdf7c8476653270d00188101b87ae5b3de8fbcd6c6d5c572211ed35833dbbd88ad3f9e69fe9abd3921567e7914a50899bc071071f50547dc273b560b0823a5e
-  data.tar.gz: cf43c052481ebd7f10d4eaa67056d46e8e85e76419af7675e5b960b743a096e22cbd967bffebfbf86099e693e9f092847f9344e44748c1e5101dac298255ce97
+  metadata.gz: cb4b3a428a9e727e6fdc00e55f537223243d2a1e26a86af6059c468e2d1ddeb4dc92bf60e07a0717e066eb0f4969f709c5d2a328211c537daa640640ef34c07c
+  data.tar.gz: 123b8b26be881baac7caac3a1e9c1a6da75b3db0644fbc3c37e791bf80a3676f5c44f63f997512f7945720fbeb6d6a02e89522d898f34a2d508e88e74a13b6c5

data/.rubocop.yml

@@ -4,7 +4,10 @@ plugins:
 
 AllCops:
   NewCops: enable
-  TargetRubyVersion: 3.1
+  TargetRubyVersion: 3.2
+
+Layout/LineLength:
+  Enabled: false
 
 Metrics/AbcSize:
   Enabled: false

data/README.md

@@ -1,45 +1,5 @@
 # Crispr
 
-TODO: Delete this and the text below, and describe your gem
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/crispr`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-## Installation
-
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
-
-Install the gem and add to the application's Gemfile by executing:
-
-```bash
-bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
-```
-
-If bundler is not being used to manage dependencies, install the gem by executing:
-
-```bash
-gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
-```
-
-## Usage
-
-TODO: Write usage instructions here
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/crispr.
-
-## License
-
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-
-# Crispr
-
 **Crispr** is a mutation testing tool for Ruby. It introduces small mutations into your code to test whether your existing test suite can detect and fail on them. This helps reveal gaps in your test coverage and improve confidence in your codebase.
 
 ## Installation
@@ -108,4 +68,4 @@ Bug reports and pull requests are welcome on GitHub at [https://github.com/afsta
 
 ## License
 
-This project is licensed under the [MIT License](https://opensource.org/licenses/MIT).
+This project is licensed under the [MIT License](https://opensource.org/licenses/MIT).

data/lib/crispr/mutations/arithmetic.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Crispr
+  module Mutations
+    # Mutates arithmetic operations such as +, -, *, /, etc.
+    class Arithmetic < Base
+      COMMUTATIVE = {
+        :+ => %i[- * / % **],
+        :* => %i[+ - / % **]
+      }.freeze
+
+      NON_COMMUTATIVE = {
+        :- => %i[+ * / % **],
+        :/ => %i[+ - * % **],
+        :% => %i[+ - * / **],
+        :** => %i[+ - * / %]
+      }.freeze
+
+      # Returns mutated AST nodes for arithmetic expressions.
+      #
+      # @param node [Parser::AST::Node] the AST node to inspect
+      # @return [Array<Parser::AST::Node>] mutated nodes
+      def mutations_for(node)
+        return [] unless node.is_a?(Parser::AST::Node)
+        return [] unless node.type == :send
+
+        receiver, method_name, *args = node.children
+        return [] unless args.size == 1
+        return [] unless (COMMUTATIVE.keys + NON_COMMUTATIVE.keys).include?(method_name)
+
+        replacements = COMMUTATIVE[method_name] || NON_COMMUTATIVE[method_name]
+        mutations = replacements.map do |op|
+          Parser::AST::Node.new(:send, [receiver, op, args.first])
+        end
+
+        # Additional mutations
+        mutations << receiver
+        mutations << args.first
+
+        # For commutative operators, swap operands
+        mutations << Parser::AST::Node.new(:send, [args.first, method_name, receiver]) if COMMUTATIVE.key?(method_name)
+
+        mutations
+      end
+    end
+  end
+end

data/lib/crispr/mutations/array.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Crispr
+  module Mutations
+    # Provides mutations for Ruby array nodes.
+    class Array < Base
+      # Generates mutated versions of an array node.
+      #
+      # @param node [Parser::AST::Node] the array node to mutate
+      # @return [Array<Parser::AST::Node>] list of mutated nodes
+      def mutations_for(node)
+        return [] unless node.is_a?(Parser::AST::Node) && node.type == :array
+
+        mutations = []
+
+        # Remove each element individually
+        node.children.each_with_index do |_, index|
+          new_elements = node.children.dup
+          new_elements.delete_at(index)
+          mutations << s(:array, *new_elements)
+        end
+
+        # Add nil to the end
+        mutations << s(:array, *node.children, s(:nil))
+
+        # Replace each element individually with nil
+        node.children.each_with_index do |_, index|
+          new_elements = node.children.dup
+          new_elements[index] = s(:nil)
+          mutations << s(:array, *new_elements)
+        end
+
+        # Replace all elements with nil
+        mutations << s(:array, *::Array.new(node.children.size) { s(:nil) })
+
+        mutations
+      end
+    end
+  end
+end

data/lib/crispr/mutations/assignment.rb

@@ -0,0 +1,47 @@
+# rubocop:disable Lint/BooleanSymbol
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Crispr
+  module Mutations
+    # Mutates local variable assignments like `x = value`
+    class Assignment < Base
+      # Returns mutated AST nodes for assignments
+      #
+      # @param node [Parser::AST::Node] the AST node to inspect
+      # @return [Array<Parser::AST::Node>] mutated nodes
+      def mutations_for(node)
+        return [] unless node.is_a?(Parser::AST::Node)
+        return [] unless node.type == :lvasgn
+
+        var_name, value_node = node.children
+        return [] unless value_node
+
+        mutations = []
+
+        # Remove assignment entirely (i.e., drop it)
+        mutations << nil
+
+        # Common alternative values
+        [s(:nil), s(:int, 0), s(:str, ""), s(:true), s(:false)].each do |replacement|
+          rep_node = replacement.is_a?(Symbol) ? s(replacement) : replacement
+          mutations << s(:lvasgn, var_name, rep_node)
+        end
+
+        # Invert boolean
+        if value_node.type == :true
+          mutations << s(:lvasgn, var_name, s(:false))
+        elsif value_node.type == :false
+          mutations << s(:lvasgn, var_name, s(:true))
+        end
+
+        # Negate numeric
+        mutations << s(:lvasgn, var_name, s(:int, -value_node.children.first)) if value_node.type == :int
+
+        mutations.compact
+      end
+    end
+  end
+end
+# rubocop:enable Lint/BooleanSymbol

data/lib/crispr/mutations/base.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Crispr
+  module Mutations
+    # Abstract base class for all mutation strategies.
+    # Subclasses must implement the `#mutations_for` method.
+    class Base
+      include AST::Sexp
+
+      # Returns an array of mutated AST nodes for a given node.
+      #
+      # @param node [Parser::AST::Node] the node to mutate
+      # @return [Array<Parser::AST::Node>] mutations
+      def mutations_for(node)
+        raise NotImplementedError, "#{self.class} must implement #mutations_for"
+      end
+    end
+  end
+end

data/lib/crispr/mutations/block.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Crispr
+  module Mutations
+    # Generates mutations for Ruby block nodes.
+    # - Removes all block arguments.
+    # - Removes the block body.
+    # - Replaces the entire block with the method call only.
+    class Block < Base
+      def mutations_for(node)
+        mutations = []
+
+        method_call, args, body = *node
+
+        # Remove all block arguments
+        mutations << s(:block, method_call, s(:args), body) if args.is_a?(Parser::AST::Node) && args.type == :args && args.children.any?
+
+        # Remove the block body
+        mutations << s(:block, method_call, args, nil)
+
+        # Replace block with just the method call
+        mutations << method_call
+
+        # Remove each individual statement if body is a :begin
+        if body&.type == :begin
+          body.children.each do |child|
+            mutations << s(:block, method_call, args, child)
+          end
+        end
+
+        mutations
+      end
+    end
+  end
+end

data/lib/crispr/mutations/{boolean_mutations.rb → boolean.rb}

@@ -1,16 +1,18 @@
 # rubocop:disable Lint/BooleanSymbol
 # frozen_string_literal: true
 
+require_relative "base"
+
 module Crispr
   module Mutations
     # Provides boolean-specific AST mutations.
     # Currently supports toggling `true` to `false` and `false` to `true`.
-    module BooleanMutations
+    class Boolean < Base
       # Returns a list of stringified mutated forms for the given boolean AST node.
       #
       # @param node [Parser::AST::Node] the AST node to inspect
       # @return [Array<String>] mutated Ruby source code strings
-      def self.mutations_for(node)
+      def mutations_for(node)
         return [] unless node.is_a?(Parser::AST::Node)
 
         case node.type

data/lib/crispr/mutations/comparison.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Crispr
+  module Mutations
+    # Defines mutations for comparison operators.
+    # This includes flipping equality and inequality, and reversing inequality directions.
+    class Comparison < Base
+      COMPARISON_FLIPS = {
+        :== => :!=,
+        :!= => :==,
+        :< => :>=,
+        :<= => :>,
+        :> => :<=,
+        :>= => :<
+      }.freeze
+
+      # Returns a list of mutated AST nodes where comparisons are flipped.
+      #
+      # @param node [Parser::AST::Node] the AST node to inspect
+      # @return [Array<Parser::AST::Node>] mutated nodes
+      def mutations_for(node)
+        return [] unless node.type == :send
+        return [] unless COMPARISON_FLIPS.key?(node.children[1])
+
+        flipped_operator = COMPARISON_FLIPS[node.children[1]]
+        mutated_node = node.updated(nil, [node.children[0], flipped_operator, *node.children[2..]])
+        [mutated_node]
+      end
+    end
+  end
+end

data/lib/crispr/mutations/conditional.rb

@@ -0,0 +1,37 @@
+# rubocop:disable Lint/BooleanSymbol
+# frozen_string_literal: true
+
+module Crispr
+  module Mutations
+    # Mutates conditional expressions like `if`, `unless`, etc.
+    #
+    # This mutator generates mutations for the condition part of a conditional expression.
+    # It flips the condition, replaces it with `true`, or replaces it with `false`.
+    class Conditional < Base
+      # Returns a list of mutated forms for the given AST node.
+      #
+      # @param node [Parser::AST::Node] the AST node to inspect
+      # @return [Array<Parser::AST::Node>] mutated AST nodes
+      def mutations_for(node)
+        return [] unless node.is_a?(Parser::AST::Node)
+        return [] unless %i[if unless].include?(node.type)
+
+        condition, then_branch, else_branch = *node
+        mutations = []
+
+        # Flip condition using a logical not
+        flipped_condition = s(:send, condition, :!)
+        mutations << s(node.type, flipped_condition, then_branch, else_branch)
+
+        # Replace condition with `true`
+        mutations << s(node.type, s(:true), then_branch, else_branch)
+
+        # Replace condition with `false`
+        mutations << s(node.type, s(:false), then_branch, else_branch)
+
+        mutations
+      end
+    end
+  end
+end
+# rubocop:enable Lint/BooleanSymbol

data/lib/crispr/mutations/control_flow.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Crispr
+  module Mutations
+    # Mutates control flow keywords like `next`, `break`, and `return`.
+    class ControlFlow < Base
+      # Returns mutated AST nodes for control flow constructs.
+      #
+      # @param node [Parser::AST::Node] the AST node to inspect
+      # @return [Array<Parser::AST::Node>] mutated nodes
+      def mutations_for(node)
+        return [] unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :next
+          [Parser::AST::Node.new(:break, node.children), Parser::AST::Node.new(:nil)]
+        when :break
+          [Parser::AST::Node.new(:next, node.children), Parser::AST::Node.new(:nil)]
+        when :return
+          [Parser::AST::Node.new(:return, []), Parser::AST::Node.new(:nil)]
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/crispr/mutations/hash.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Crispr
+  module Mutations
+    # Mutations targeting hash literals.
+    class Hash < Base
+      # Returns an array of mutated versions of the given hash node.
+      #
+      # @param node [Parser::AST::Node] the hash AST node
+      # @return [Array<Parser::AST::Node>] mutated AST nodes
+      def mutations_for(node)
+        return [] unless node.is_a?(Parser::AST::Node) && node.type == :hash
+
+        mutations = []
+
+        node.children.each_with_index do |pair, index|
+          # Remove individual pair
+          new_pairs = node.children.dup
+          new_pairs.delete_at(index)
+          mutations << s(:hash, *new_pairs)
+
+          # Replace value with nil
+          next unless pair.type == :pair
+
+          key, _value = *pair
+          new_pair = s(:pair, key, s(:nil))
+          new_pairs = node.children.dup
+          new_pairs[index] = new_pair
+          mutations << s(:hash, *new_pairs)
+        end
+
+        # Add a new nil => nil pair
+        mutations << s(:hash, *(node.children + [s(:pair, s(:nil), s(:nil))]))
+
+        mutations
+      end
+    end
+  end
+end

data/lib/crispr/mutations/literal.rb

@@ -0,0 +1,47 @@
+# rubocop:disable Lint/BooleanSymbol
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Crispr
+  module Mutations
+    # Mutates basic Ruby literals to edge-case or alternate values.
+    class Literal < Base
+      # Returns mutated AST nodes for literal types.
+      #
+      # @param node [Parser::AST::Node] the AST node to inspect
+      # @return [Array<Parser::AST::Node>] mutated nodes
+      def mutations_for(node)
+        return [] unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :int
+          [replace_literal(node, 0), replace_literal(node, -1), replace_literal(node, 1)].uniq
+        when :str
+          [replace_literal(node, ""), replace_literal(node, "crispr")]
+        when :sym
+          [replace_literal(node, :other)]
+        when :array
+          [Parser::AST::Node.new(:array, [])]
+        when :hash
+          [Parser::AST::Node.new(:hash, [])]
+        when :true
+          [replace_literal(node, false)]
+        when :false
+          [replace_literal(node, true)]
+        when :nil
+          [Parser::AST::Node.new(:str, ["null"])]
+        else
+          []
+        end
+      end
+
+      private
+
+      def replace_literal(original, new_value)
+        Parser::AST::Node.new(original.type, [new_value])
+      end
+    end
+  end
+end
+# rubocop:enable Lint/BooleanSymbol

data/lib/crispr/mutations/logical.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Crispr
+  module Mutations
+    # Mutates logical operators like `&&` and `||`.
+    class Logical < Base
+      # Returns mutated AST nodes for logical expressions.
+      #
+      # @param node [Parser::AST::Node] the AST node to inspect
+      # @return [Array<Parser::AST::Node>] mutated nodes
+      def mutations_for(node)
+        return [] unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :and
+          mutate_logical(node, :or)
+        when :or
+          mutate_logical(node, :and)
+        else
+          []
+        end
+      end
+
+      private
+
+      # Generate logical mutations by swapping type and extracting operands
+      #
+      # @param node [Parser::AST::Node]
+      # @param opposite [Symbol] the alternate logical operator type
+      # @return [Array<Parser::AST::Node>]
+      def mutate_logical(node, opposite)
+        left, right = node.children
+        [
+          Parser::AST::Node.new(opposite, [left, right]), # swap AND/OR
+          left,
+          right
+        ]
+      end
+    end
+  end
+end

data/lib/crispr/mutations/method_call.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Crispr
+  module Mutations
+    # Mutates method calls by altering the method name or arguments.
+    class MethodCall < Base
+      # Returns true if the node is a method call (:send).
+      #
+      # @param node [Parser::AST::Node]
+      # @return [Boolean]
+      def match?(node)
+        node.type == :send
+      end
+
+      # Returns a list of mutated versions of the given method call.
+      #
+      # @param node [Parser::AST::Node]
+      # @return [Array<Parser::AST::Node>]
+      def mutations_for(node)
+        return [] unless match?(node)
+
+        original_receiver, original_method_name, *args = *node
+
+        mutations = []
+
+        # Replace method name with a placeholder
+        mutations << s(:send, original_receiver, :foo, *args)
+
+        # Add nil as an argument if none exist
+        mutations << s(:send, original_receiver, original_method_name, s(:nil)) if args.empty?
+
+        # Remove first argument if any exist
+        mutations << s(:send, original_receiver, original_method_name, *args[1..]) if args.any?
+
+        mutations
+      end
+    end
+  end
+end

data/lib/crispr/mutations/numeric.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Crispr
+  module Mutations
+    # The Numeric class defines mutations for integer literals.
+    # It generates alternative integer nodes by applying small transformations,
+    # such as incrementing, decrementing, zeroing, or negating the value.
+    class Numeric < Base
+      # Applies numeric mutations to the given AST node.
+      #
+      # @param node [Parser::AST::Node] the node to mutate
+      # @return [Array<Parser::AST::Node>] an array of mutated nodes
+      def mutations_for(node)
+        return [] unless node.type == :int
+
+        value = node.children[0]
+
+        # Generate a set of numeric mutations
+        mutations = []
+        mutations << replace(node, value + 1)
+        mutations << replace(node, value - 1)
+        mutations << replace(node, 0) unless value.zero?
+        mutations << replace(node, -value) unless value.zero?
+
+        mutations
+      end
+
+      private
+
+      # Creates a new AST node with the given integer value.
+      #
+      # @param node [Parser::AST::Node] the original node
+      # @param new_value [Integer] the new integer value
+      # @return [Parser::AST::Node] the mutated node
+      def replace(node, new_value)
+        Parser::AST::Node.new(:int, [new_value], location: node.location)
+      end
+    end
+  end
+end

data/lib/crispr/mutations/range.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Crispr
+  module Mutations
+    # Mutation class for handling Ruby range expressions (inclusive and exclusive).
+    # Applies mutations such as flipping range type, replacing with nil, and swapping bounds.
+    class Range < Base
+      # Returns a list of mutated forms of the given range node.
+      #
+      # @param node [Parser::AST::Node] the AST node representing a range
+      # @return [Array<Parser::AST::Node>] mutated AST nodes
+      def mutations_for(node)
+        return [] unless %i[irange erange].include?(node.type)
+
+        left, right = node.children
+        mutations = []
+
+        # Flip the range type (inclusive <-> exclusive)
+        flipped_type = node.type == :irange ? :erange : :irange
+        mutations << s(flipped_type, left, right)
+
+        # Replace with nil
+        mutations << s(:nil)
+
+        # Swap bounds if both sides are literals
+        mutations << s(node.type, right, left) if left&.type == :int && right&.type == :int
+
+        mutations
+      end
+    end
+  end
+end

data/lib/crispr/mutations/regexp.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Crispr
+  module Mutations
+    # Generates mutations for regular expressions
+    class Regexp < Base
+      # Returns a list of mutated forms for the given Regexp AST node.
+      #
+      # @param node [Parser::AST::Node] the AST node to inspect
+      # @return [Array<Parser::AST::Node>] mutated AST nodes
+      def mutations_for(node)
+        return [] unless node.type == :regexp
+
+        parts = node.children[0...-1]
+        options = node.children.last
+
+        mutations = []
+
+        # Remove options if present
+        mutations << s(:regexp, *parts, 0) if options != 0
+
+        # Remove the pattern entirely
+        mutations << s(:regexp, s(:str, ""), options)
+
+        mutations
+      end
+    end
+  end
+end

data/lib/crispr/mutations/rescue.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Crispr
+  module Mutations
+    # Generates mutations for `rescue` nodes.
+    #
+    # Possible mutations include:
+    # - Removing the entire rescue and returning only the main body.
+    # - Replacing the rescued body with `nil` or a string.
+    # - Removing individual rescue clauses from the rescue expression.
+    class Rescue < Base
+      def mutations_for(node)
+        mutations = []
+
+        # Remove the rescue entirely (just return the body before rescue)
+        mutations << node.children[0] if node.children[0]
+
+        # Replace the rescued body with nil
+        mutations << s(:block, s(:rescue, node.children.first, s(:resbody, nil, nil, s(:nil)), nil), nil, nil)
+
+        # Replace the rescued body with a different expression
+        mutations << s(:rescue, s(:str, "error"), *node.children[1..])
+
+        # Remove individual rescue clauses if present
+        if node.children[1..] && !node.children[1..].empty?
+          node.children[1..].each_with_index do |_rescue_clause, i|
+            new_children = node.children.dup
+            new_children.delete_at(i + 1) # +1 to skip the body
+            mutations << s(:rescue, *new_children)
+          end
+        end
+
+        mutations
+      end
+    end
+  end
+end

data/lib/crispr/mutations/string.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Crispr
+  module Mutations
+    # Mutates string literals like "hello"
+    class String < Base
+      def mutations_for(node)
+        return [] unless node.is_a?(Parser::AST::Node)
+        return [] unless node.type == :str
+
+        original = node.children.first
+        return [] unless original.is_a?(::String)
+
+        mutations = []
+
+        # Common string mutations
+        mutations << s(:str, "")
+        mutations << s(:str, "a")
+        mutations << s(:str, "test")
+        mutations << s(:str, original.reverse) unless original.empty?
+        mutations << s(:str, original.upcase) unless original.upcase == original
+        mutations << s(:str, original.downcase) unless original.downcase == original
+
+        mutations << s(:str, "mutated")
+        mutations << s(:nil)
+        mutations
+      end
+    end
+  end
+end

data/lib/crispr/mutations/symbol.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Crispr
+  module Mutations
+    # This class generates mutations for symbol nodes in the AST.
+    # It provides different mutated versions of a symbol node for mutation testing.
+    class Symbol < Base
+      # Returns a list of mutated versions of a symbol node.
+      #
+      # @param node [Parser::AST::Node]
+      # @return [Array<Parser::AST::Node>]
+      def mutations_for(node)
+        return [] unless node.type == :sym
+
+        value = node.children.first
+        mutations = []
+
+        # Change the symbol to an empty symbol
+        mutations << s(:sym, :"") unless value == :""
+
+        # Change the symbol to a different symbol
+        mutations << s(:sym, :mutated) unless value == :mutated
+
+        # Remove the symbol node entirely (i.e., replace with nil)
+        mutations << s(:nil)
+
+        mutations
+      end
+    end
+  end
+end

data/lib/crispr/mutations/ternary.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Crispr
+  module Mutations
+    # Mutates ternary expressions like `cond ? a : b`
+    class Ternary < Base
+      # Returns mutated AST nodes for ternary expressions.
+      #
+      # @param node [Parser::AST::Node] the AST node to inspect
+      # @return [Array<Parser::AST::Node>] mutated nodes
+      def mutations_for(node)
+        return [] unless node.is_a?(Parser::AST::Node)
+        return [] unless node.type == :if
+        return [] unless node.loc.respond_to?(:question) && node.loc.question
+
+        cond, if_branch, else_branch = node.children
+        [
+          if_branch,
+          else_branch,
+          cond,
+          Parser::AST::Node.new(:if, [cond, else_branch, if_branch]) # swap branches
+        ].compact
+      end
+    end
+  end
+end

data/lib/crispr/mutations/unary.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Crispr
+  module Mutations
+    # Mutates unary operator expressions such as !x, -x, +x.
+    class Unary < Base
+      # Returns mutated AST nodes for unary operator nodes.
+      #
+      # @param node [Parser::AST::Node] the AST node to inspect
+      # @return [Array<Parser::AST::Node>] mutated nodes
+      def mutations_for(node)
+        return [] unless node.is_a?(Parser::AST::Node)
+        return [] unless node.type == :send
+
+        receiver, method_name, = node.children
+
+        case method_name
+        when :!
+          [receiver].compact
+        when :-@
+          [Parser::AST::Node.new(:send, [receiver, :+@])]
+        when :+@
+          [Parser::AST::Node.new(:send, [receiver, :-@])]
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/crispr/mutator.rb

@@ -2,12 +2,54 @@
 
 require "parser/current"
 require "unparser"
-require_relative "mutations/boolean_mutations"
+require_relative "mutations/boolean"
+require_relative "mutations/numeric"
+require_relative "mutations/comparison"
+require_relative "mutations/literal"
+require_relative "mutations/unary"
+require_relative "mutations/control_flow"
+require_relative "mutations/conditional"
+require_relative "mutations/logical"
+require_relative "mutations/ternary"
+require_relative "mutations/arithmetic"
+require_relative "mutations/assignment"
+require_relative "mutations/method_call"
+require_relative "mutations/array"
+require_relative "mutations/hash"
+require_relative "mutations/range"
+require_relative "mutations/regexp"
+require_relative "mutations/symbol"
+require_relative "mutations/string"
+require_relative "mutations/block"
+require_relative "mutations/rescue"
 
 module Crispr
   # Mutator performs simple AST mutations on Ruby source code.
-  # Currently, it supports changing `true` literals to `false` and vice versa.
+  # It delegates to multiple mutation strategies (Boolean, Numeric, etc.)
   class Mutator
+    MUTATORS = [
+      Crispr::Mutations::Boolean.new,
+      Crispr::Mutations::Numeric.new,
+      Crispr::Mutations::Comparison.new,
+      Crispr::Mutations::Literal.new,
+      Crispr::Mutations::Unary.new,
+      Crispr::Mutations::ControlFlow.new,
+      Crispr::Mutations::Conditional.new,
+      Crispr::Mutations::Logical.new,
+      Crispr::Mutations::Ternary.new,
+      Crispr::Mutations::Arithmetic.new,
+      Crispr::Mutations::Assignment.new,
+      Crispr::Mutations::MethodCall.new,
+      Crispr::Mutations::Array.new,
+      Crispr::Mutations::Hash.new,
+      Crispr::Mutations::Range.new,
+      Crispr::Mutations::Regexp.new,
+      Crispr::Mutations::Symbol.new,
+      Crispr::Mutations::String.new,
+      Crispr::Mutations::Block.new,
+      Crispr::Mutations::Rescue.new
+    ].freeze
+
     def initialize(source_code)
       @source_code = source_code
     end
@@ -24,8 +66,11 @@ module Crispr
     def find_mutations(node)
       return [] unless node.is_a?(Parser::AST::Node)
 
-      local_mutations = Crispr::Mutations::BooleanMutations.mutations_for(node)
-      child_mutations = node.children.flat_map { |child| find_mutations(child) }
+      local_mutations =
+        MUTATORS.flat_map { |mutator| mutator.mutations_for(node) }
+
+      child_mutations =
+        node.children.flat_map { |child| find_mutations(child) }
 
       local_mutations + child_mutations
     end

data/lib/crispr/runner.rb

@@ -13,18 +13,17 @@ module Crispr
     # @param mutated_source [String] the mutated version of the file's source code
     # @param test_path [String, nil] optional path to a specific test file to run
     # @return [Boolean] true if the mutation was killed (test suite failed), false otherwise
-    def self.run_mutation(path:, mutated_source:, test_path: nil)
+    def self.run_mutation(path:, mutated_source:, test_path: nil, verbose: false)
       original_source = File.read(path)
 
       begin
         File.write(path, mutated_source)
 
         test_cmd = test_path ? "bundle exec rspec #{test_path}" : "bundle exec rspec"
-        stdout, stderr, status = Open3.capture3(test_cmd)
-        killed = !status.success?
+        test_cmd += " > /dev/null 2>&1" unless verbose
 
-        puts stdout unless status.success?
-        puts stderr unless status.success?
+        system(test_cmd)
+        killed = !$CHILD_STATUS.success?
 
         killed
       ensure

data/lib/crispr/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Crispr
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/lib/crispr.rb

@@ -5,6 +5,10 @@ require_relative "crispr/mutator"
 require_relative "crispr/runner"
 require_relative "crispr/cli"
 
+require_relative "crispr/mutations/base"
+require_relative "crispr/mutations/boolean"
+require_relative "crispr/mutations/numeric"
+
 module Crispr
   class Error < StandardError; end
   # Your code goes here...

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: crispr
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Aaron F Stanton
@@ -13,30 +13,30 @@ dependencies:
   name: parser
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.3.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.3.8
 - !ruby/object:Gem::Dependency
   name: unparser
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.8.0
 description: Crispr is a mutation testing tool for Ruby that introduces small code
   mutations to verify the effectiveness of your test suite.
 email:
@@ -54,7 +54,27 @@ files:
 - bin/crispr
 - lib/crispr.rb
 - lib/crispr/cli.rb
-- lib/crispr/mutations/boolean_mutations.rb
+- lib/crispr/mutations/arithmetic.rb
+- lib/crispr/mutations/array.rb
+- lib/crispr/mutations/assignment.rb
+- lib/crispr/mutations/base.rb
+- lib/crispr/mutations/block.rb
+- lib/crispr/mutations/boolean.rb
+- lib/crispr/mutations/comparison.rb
+- lib/crispr/mutations/conditional.rb
+- lib/crispr/mutations/control_flow.rb
+- lib/crispr/mutations/hash.rb
+- lib/crispr/mutations/literal.rb
+- lib/crispr/mutations/logical.rb
+- lib/crispr/mutations/method_call.rb
+- lib/crispr/mutations/numeric.rb
+- lib/crispr/mutations/range.rb
+- lib/crispr/mutations/regexp.rb
+- lib/crispr/mutations/rescue.rb
+- lib/crispr/mutations/string.rb
+- lib/crispr/mutations/symbol.rb
+- lib/crispr/mutations/ternary.rb
+- lib/crispr/mutations/unary.rb
 - lib/crispr/mutator.rb
 - lib/crispr/reporter.rb
 - lib/crispr/runner.rb
@@ -76,7 +96,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="