mutant 0.10.21 → 0.10.26

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
     #
@@ -20,7 +20,7 @@ module Mutant
     # @return [Matcher]
     def self.from_config(config)
       Filter.new(
-        Chain.new(config.match_expressions.map(&:matcher)),
+        Chain.new(config.subjects.map(&:matcher)),
         method(:allowed_subject?).curry.call(config)
       )
     end
@@ -42,7 +42,7 @@ module Mutant
     #
     # @return [Boolean]
     def self.ignore_subject?(config, subject)
-      config.ignore_expressions.any? do |expression|
+      config.ignore.any? do |expression|
         expression.prefix?(subject.expression)
       end
     end

data/lib/mutant/matcher/config.rb

@@ -5,8 +5,8 @@ module Mutant
     # Subject matcher configuration
     class Config
       include Adamantium, Anima.new(
-        :ignore_expressions,
-        :match_expressions,
+        :ignore,
+        :subjects,
         :start_expressions,
         :subject_filters
       )
@@ -16,16 +16,38 @@ module Mutant
       ATTRIBUTE_FORMAT    = '%s: [%s]'
       ENUM_DELIMITER      = ','
       EMPTY_ATTRIBUTES    = 'empty'
-      PRESENTATIONS       = IceNine.deep_freeze(
-        ignore_expressions: :syntax,
-        match_expressions:  :syntax,
-        start_expressions:  :syntax,
-        subject_filters:    :inspect
-      )
+      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 = Transform::Block.capture(:expression) do |input|
+        Mutant::Config::DEFAULT.expression_parser.call(input)
+      end
+
+      expression_array = Transform::Array.new(expression)
+
+      LOADER =
+        Transform::Sequence.new(
+          [
+            Transform::Hash.new(
+              optional: [
+                Transform::Hash::Key.new('subjects', expression_array),
+                Transform::Hash::Key.new('ignore', expression_array)
+              ],
+              required: []
+            ),
+            Transform::Hash::Symbolize.new,
+            ->(attributes) { Either::Right.new(DEFAULT.with(attributes)) }
+          ]
+        )
+
       # Inspection string
       #
       # @return [String]

data/lib/mutant/matcher/method.rb

@@ -5,7 +5,7 @@ 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
@@ -32,11 +32,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
         #
@@ -87,9 +89,8 @@ module Mutant
           node = matched_node_path.last || return
 
           self.class::SUBJECT_CLASS.new(
-            context:  context,
-            node:     node,
-            warnings: env.world.warnings
+            context: context,
+            node:    node
           )
         end
         memoize :subject

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

@@ -37,7 +37,7 @@ module Mutant
         # @return [Example]
         #
         # @raise [RuntimeError]
-        #   in case example cannot be build
+        #   in case the example cannot be built
         def example
           fail 'source not defined' unless @source
 
@@ -82,6 +82,11 @@ module Mutant
           mutation('self')
         end
 
+        def regexp_mutations
+          mutation('//')
+          mutation('/nomatch\A/')
+        end
+
         def node(input)
           case input
           when String

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/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/block.rb

@@ -21,7 +21,7 @@ module Mutant
         end
 
         def mutate_body
-          emit_body(nil)
+          emit_body(nil) unless unconditional_loop?
           emit_body(N_RAISE)
 
           return unless body
@@ -31,6 +31,10 @@ module Mutant
           mutate_body_receiver
         end
 
+        def unconditional_loop?
+          send.eql?(s(:send, nil, :loop))
+        end
+
         def body_has_control?
           AST.find_last_path(body) do |node|
             n_break?(node) || n_next?(node)

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/kwargs.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      # Mutator for kwargs node
+      class Kwargs < self
+
+        DISALLOW = %i[nil self].freeze
+
+        private_constant(*constants(false))
+
+        handle(:kwargs)
+
+      private
+
+        def dispatch
+          emit_argument_presence
+          emit_argument_mutations
+        end
+
+        def emit_argument_presence
+          Util::Array::Presence.call(children).each do |children|
+            emit_type(*children) unless children.empty?
+          end
+        end
+
+        def emit_argument_mutations
+          children.each_with_index do |child, index|
+            Mutator.mutate(child).each do |mutant|
+              unless forbid_argument?(mutant)
+                emit_child_update(index, mutant)
+              end
+            end
+          end
+        end
+
+        def forbid_argument?(node)
+          n_pair?(node) && DISALLOW.include?(node.children.first.type)
+        end
+      end # Kwargs
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -19,6 +19,7 @@ module Mutant
           end
 
           def dispatch
+            mutate_body
             emit_singletons unless parent_node
             children.each_with_index do |child, index|
               mutate_child(index) unless n_str?(child)
@@ -27,6 +28,17 @@ module Mutant
             emit_type(s(:str, NULL_REGEXP_SOURCE), options)
           end
 
+          def mutate_body
+            # 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
+              emit_type(s(:str, source), options)
+            end
+          end
+
         end # Regex
       end # Literal
     end # Node

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      module Regexp
+        # Mutator for root expression regexp wrapper
+        class RootExpression < Node
+          handle(:regexp_root_expression)
+
+        private
+
+          def dispatch
+            children.each_index(&method(:mutate_child))
+          end
+        end # RootExpression
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      module Regexp
+        # Mutator for pipe in `/foo|bar/` regexp
+        class AlternationMeta < Node
+          handle(:regexp_alternation_meta)
+
+        private
+
+          def dispatch
+            children.each_index(&method(:delete_child))
+          end
+        end # AlternationMeta
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutant

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