mutant 0.10.24 → 0.10.29

data/lib/mutant/matcher.rb

@@ -3,7 +3,7 @@
 module Mutant
   # Abstract matcher to find subjects to mutate
   class Matcher
-    include Adamantium::Flat, AbstractType
+    include Adamantium, AbstractType
 
     # Call matcher
     #

data/lib/mutant/matcher/config.rb

@@ -16,17 +16,20 @@ module Mutant
       ATTRIBUTE_FORMAT    = '%s: [%s]'
       ENUM_DELIMITER      = ','
       EMPTY_ATTRIBUTES    = 'empty'
-      PRESENTATIONS       = IceNine.deep_freeze(
+      PRESENTATIONS       = {
         ignore:            :syntax,
         start_expressions: :syntax,
         subject_filters:   :inspect,
         subjects:          :syntax
-      )
+      }.freeze
+
       private_constant(*constants(false))
 
       DEFAULT = new(Hash[anima.attribute_names.map { |name| [name, []] }])
 
-      expression = ->(input) { Mutant::Config::DEFAULT.expression_parser.call(input) }
+      expression = Transform::Block.capture(:expression) do |input|
+        Mutant::Config::DEFAULT.expression_parser.call(input)
+      end
 
       expression_array = Transform::Array.new(expression)
 

data/lib/mutant/matcher/method.rb

@@ -5,12 +5,9 @@ module Mutant
     # Abstract base class for method matchers
     class Method < self
       include AbstractType,
-              Adamantium::Flat,
+              Adamantium,
               Concord::Public.new(:scope, :target_method, :evaluator)
 
-      # Source locations we cannot acces
-      BLACKLIST = %w[(eval) <internal:prelude>].to_set.freeze
-
       SOURCE_LOCATION_WARNING_FORMAT =
         '%s does not have a valid source location, unable to emit subject'
 
@@ -32,11 +29,13 @@ module Mutant
       # logic would be implemented directly on the Matcher::Method
       # instance
       class Evaluator
-        include AbstractType,
-                Adamantium,
-                Concord.new(:scope, :target_method, :env),
-                Procto.call,
-                AST::NodePredicates
+        include(
+          AbstractType,
+          Adamantium,
+          Concord.new(:scope, :target_method, :env),
+          Procto,
+          AST::NodePredicates
+        )
 
         # Matched subjects
         #
@@ -51,7 +50,10 @@ module Mutant
 
         def skip?
           location = source_location
-          if location.nil? || BLACKLIST.include?(location.first)
+
+          file = location&.first
+
+          if location.nil? || !file.end_with?('.rb')
             env.warn(SOURCE_LOCATION_WARNING_FORMAT % target_method)
           elsif matched_node_path.any?(&method(:n_block?))
             env.warn(CLOSURE_WARNING_FORMAT % target_method)

data/lib/mutant/matcher/method/instance.rb

@@ -13,9 +13,8 @@ module Mutant
         #
         # @return [Matcher::Method::Instance]
         def self.new(scope, target_method)
-          name = target_method.name
           evaluator =
-            if scope.respond_to?(:memoized?) && scope.memoized?(name)
+            if memoized_method?(scope, target_method.name)
               Evaluator::Memoized
             else
               Evaluator
@@ -24,6 +23,11 @@ module Mutant
           super(scope, target_method, evaluator)
         end
 
+        def self.memoized_method?(scope, method_name)
+          scope < Adamantium && scope.memoized?(method_name)
+        end
+        private_class_method :memoized_method?
+
         # Instance method specific evaluator
         class Evaluator < Evaluator
           SUBJECT_CLASS = Subject::Method::Instance

data/lib/mutant/matcher/method/metaclass.rb

@@ -80,7 +80,7 @@ module Mutant
         end # Evaluator
 
         private_constant(*constants(false))
-      end # Singleton
+      end # Metaclass
     end # Method
   end # Matcher
 end # Mutant

data/lib/mutant/matcher/methods.rb

@@ -6,11 +6,11 @@ module Mutant
     class Methods < self
       include AbstractType, Concord.new(:scope)
 
-      CANDIDATE_NAMES = IceNine.deep_freeze(%i[
+      CANDIDATE_NAMES = %i[
         public_instance_methods
         private_instance_methods
         protected_instance_methods
-      ])
+      ].freeze
 
       private_constant(*constants(false))
 
@@ -62,7 +62,6 @@ module Mutant
         def candidate_scope
           scope.singleton_class
         end
-        memoize :candidate_scope, freezer: :noop
 
       end # Singleton
 
@@ -79,7 +78,6 @@ module Mutant
         def candidate_scope
           scope.singleton_class
         end
-        memoize :candidate_scope, freezer: :noop
       end # Metaclass
 
       # Matcher for instance methods

data/lib/mutant/meta/example.rb

@@ -3,7 +3,7 @@
 module Mutant
   module Meta
     class Example
-      include Adamantium::Flat
+      include Adamantium
 
       include Anima.new(
         :expected,

data/lib/mutant/meta/example/dsl.rb

@@ -79,7 +79,6 @@ module Mutant
 
         def singleton_mutations
           mutation('nil')
-          mutation('self')
         end
 
         def regexp_mutations

data/lib/mutant/meta/example/verification.rb

@@ -5,7 +5,7 @@ module Mutant
     class Example
       # Example verification
       class Verification
-        include Adamantium::Flat, Concord.new(:example, :mutations)
+        include Adamantium, Concord.new(:example, :mutations)
 
         # Test if mutation was verified successfully
         #

data/lib/mutant/mutation.rb

@@ -3,7 +3,7 @@
 module Mutant
   # Represent a mutated node with its subject
   class Mutation
-    include AbstractType, Adamantium::Flat
+    include AbstractType, Adamantium
     include Concord::Public.new(:subject, :node)
 
     CODE_DELIMITER = "\0"

data/lib/mutant/mutator.rb

@@ -6,7 +6,12 @@ module Mutant
 
     REGISTRY = Registry.new
 
-    include Adamantium::Flat, Concord.new(:input, :parent), AbstractType, Procto.call(:output)
+    include(
+      Adamantium,
+      Concord.new(:input, :parent),
+      AbstractType,
+      Procto
+    )
 
     # Lookup and invoke dedicated AST mutator
     #
@@ -30,6 +35,8 @@ module Mutant
     # @return [Set<Parser::AST::Node>]
     attr_reader :output
 
+    alias_method :call, :output
+
   private
 
     def initialize(_input, _parent = nil)

data/lib/mutant/mutator/node.rb

@@ -67,11 +67,6 @@ module Mutant
 
       def emit_singletons
         emit_nil
-        emit_self
-      end
-
-      def emit_self
-        emit(N_SELF)
       end
 
       def emit_nil

data/lib/mutant/mutator/node/argument.rb

@@ -30,10 +30,10 @@ module Mutant
         # Mutator for optional arguments
         class Optional < self
 
-          TYPE_MAP = IceNine.deep_freeze(
+          TYPE_MAP = {
             optarg:   :arg,
             kwoptarg: :kwarg
-          )
+          }.freeze
 
           handle(:optarg, :kwoptarg)
 

data/lib/mutant/mutator/node/dynamic_literal.rb

@@ -18,7 +18,7 @@ module Mutant
           end
         end
 
-      end # Dstr
+      end # DynamicLiteral
     end # Node
   end # Mutator
 end # Mutant

data/lib/mutant/mutator/node/index.rb

@@ -17,6 +17,7 @@ module Mutant
         def dispatch
           emit_singletons
           emit_receiver_mutations { |node| !n_nil?(node) }
+          emit_type(N_SELF, *children.drop(1))
           emit(receiver)
           emit_send_forms
           emit_drop_mutation

data/lib/mutant/mutator/node/literal/float.rb

@@ -28,9 +28,7 @@ module Mutant
           end
 
           def values
-            original = children.first
-
-            [0.0, 1.0, -original]
+            [0.0, 1.0]
           end
 
         end # Float

data/lib/mutant/mutator/node/literal/integer.rb

@@ -9,6 +9,8 @@ module Mutant
 
           handle(:int)
 
+          children :value
+
         private
 
           def dispatch
@@ -17,12 +19,7 @@ module Mutant
           end
 
           def values
-            [0, 1, -value, value + 1, value - 1]
-          end
-
-          def value
-            value, = children
-            value
+            [0, 1, value + 1, value - 1]
           end
 
         end # Integer

data/lib/mutant/mutator/node/literal/range.rb

@@ -21,7 +21,7 @@ module Mutant
 
           def dispatch
             emit_singletons
-            emit_lower_bound_mutations
+            emit_lower_bound_mutations if lower_bound
 
             return unless upper_bound
 

data/lib/mutant/mutator/node/literal/regex.rb

@@ -28,11 +28,10 @@ module Mutant
             emit_type(s(:str, NULL_REGEXP_SOURCE), options)
           end
 
-          # NOTE: will only mutate parts of regexp body if the
-          # body is composed of only strings. Regular expressions
-          # with interpolation are skipped
           def mutate_body
-            return unless body.all?(&method(:n_str?))
+            # NOTE: will only mutate parts of regexp body if the body is composed of only strings.
+            # Regular expressions with interpolation are skipped.
+            return unless (body_ast = AST::Regexp.expand_regexp_ast(input))
 
             Mutator.mutate(body_ast).each do |mutation|
               source = AST::Regexp.to_expression(mutation).to_s
@@ -40,19 +39,6 @@ module Mutant
             end
           end
 
-          def body_ast
-            AST::Regexp.to_ast(body_expression)
-          end
-
-          def body_expression
-            AST::Regexp.parse(body.map(&:children).join)
-          end
-          memoize :body_expression
-
-          def body
-            children.slice(0...-1)
-          end
-
         end # Regex
       end # Literal
     end # Node

data/lib/mutant/mutator/node/module.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      class Module < self
+        handle :module
+
+        children :klass, :body
+
+      private
+
+        def dispatch
+          emit_body_mutations if body
+        end
+      end # Module
+    end # Node
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/node/named_value/variable_assignment.rb

@@ -17,9 +17,9 @@ module Mutant
             lvasgn: EMPTY_STRING
           }
 
-          MAP = IceNine.deep_freeze(
-            map.transform_values { |prefix| [prefix, /^#{::Regexp.escape(prefix)}/] }
-          )
+          MAP = map
+            .transform_values { |prefix| [prefix, /^#{::Regexp.escape(prefix)}/] }
+            .freeze
 
           handle(*MAP.keys)
 

data/lib/mutant/mutator/node/regexp.rb

@@ -14,17 +14,6 @@ module Mutant
             children.each_index(&method(:mutate_child))
           end
         end # RootExpression
-
-        # Mutator for beginning of line anchor `^`
-        class BeginningOfLineAnchor < Node
-          handle(:regexp_bol_anchor)
-
-        private
-
-          def dispatch
-            emit(s(:regexp_bos_anchor))
-          end
-        end # BeginningOfLineAnchor
       end # Regexp
     end # Node
   end # Mutator

data/lib/mutant/mutator/node/regexp/beginning_of_line_anchor.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      module Regexp
+        # Mutator for beginning of line anchor `^`
+        class BeginningOfLineAnchor < Node
+          handle(:regexp_bol_anchor)
+
+          private
+
+          def dispatch
+            emit(s(:regexp_bos_anchor))
+          end
+        end # BeginningOfLineAnchor
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/node/regexp/character_type.rb

@@ -15,7 +15,7 @@ module Mutant
             regexp_xgrapheme_type:       :regexp_linebreak_type
           }
 
-          MAP = IceNine.deep_freeze(map.merge(map.invert))
+          MAP = map.merge(map.invert)
 
           handle(*MAP.keys)
 

data/lib/mutant/mutator/node/regexp/named_group.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      module Regexp
+        # Mutator for regexp named capture groups, such as `/(?<foo>bar)/`
+        class NamedGroup < Node
+          handle(:regexp_named_group)
+
+          children :name, :group
+
+        private
+
+          def dispatch
+            return unless group
+
+            emit_group_mutations
+
+            # Allows unused captures to be kept and named if they are explicitly prefixed with an
+            # underscore, like we allow with unused local variables.
+            return if name_underscored?
+
+            emit(s(:regexp_passive_group, group))
+            emit_name_underscore_mutation
+          end
+
+          def emit_name_underscore_mutation
+            emit_type("_#{name}", group)
+          end
+
+          def name_underscored?
+            name.start_with?('_')
+          end
+        end # EndOfLineAnchor
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutant