mutant 0.10.23 → 0.10.24

data/lib/mutant/config.rb

@@ -37,54 +37,6 @@ module Mutant
 
     private_constant(*constants(false))
 
-    class CoverageCriteria
-      include Anima.new(:process_abort, :test_result, :timeout)
-
-      EMPTY = new(
-        process_abort: nil,
-        test_result:   nil,
-        timeout:       nil
-      )
-
-      DEFAULT = new(
-        process_abort: false,
-        test_result:   true,
-        timeout:       false
-      )
-
-      TRANSFORM =
-        Transform::Sequence.new(
-          [
-            Transform::Hash.new(
-              optional: [
-                Transform::Hash::Key.new('process_abort', Transform::BOOLEAN),
-                Transform::Hash::Key.new('test_result',   Transform::BOOLEAN),
-                Transform::Hash::Key.new('timeout',       Transform::BOOLEAN)
-              ],
-              required: []
-            ),
-            Transform::Hash::Symbolize.new,
-            ->(value) { Either::Right.new(DEFAULT.with(**value)) }
-          ]
-        )
-
-      def merge(other)
-        self.class.new(
-          process_abort: overwrite(other, :process_abort),
-          test_result:   overwrite(other, :test_result),
-          timeout:       overwrite(other, :timeout)
-        )
-      end
-
-    private
-
-      def overwrite(other, attribute_name)
-        other_value = other.public_send(attribute_name)
-
-        other_value.nil? ? public_send(attribute_name) : other_value
-      end
-    end # CoverageCriteria
-
     # Merge with other config
     #
     # @param [Config] other
@@ -116,13 +68,14 @@ module Mutant
     #
     # @return [Either<String,Config>]
     def self.load_config_file(world)
-      config = DEFAULT
-      files = CANDIDATES.map(&world.pathname.public_method(:new)).select(&:readable?)
+      files = CANDIDATES
+        .map(&world.pathname.public_method(:new))
+        .select(&:readable?)
 
       if files.one?
-        load_contents(files.first).fmap(&config.public_method(:with))
+        load_contents(files.first).fmap(&DEFAULT.public_method(:with))
       elsif files.empty?
-        Either::Right.new(config)
+        Either::Right.new(DEFAULT)
       else
         Either::Left.new(MORE_THAN_ONE_CONFIG_FILE % files.join(', '))
       end
@@ -159,13 +112,14 @@ module Mutant
         Transform::Exception.new(YAML::SyntaxError, YAML.method(:safe_load)),
         Transform::Hash.new(
           optional: [
-            Transform::Hash::Key.new('coverage_criteria', CoverageCriteria::TRANSFORM),
+            Transform::Hash::Key.new('coverage_criteria', ->(value) { CoverageCriteria::TRANSFORM.call(value) }),
             Transform::Hash::Key.new('fail_fast',         Transform::BOOLEAN),
             Transform::Hash::Key.new('includes',          Transform::STRING_ARRAY),
             Transform::Hash::Key.new('integration',       Transform::STRING),
             Transform::Hash::Key.new('jobs',              Transform::INTEGER),
             Transform::Hash::Key.new('mutation_timeout',  Transform::FLOAT),
-            Transform::Hash::Key.new('requires',          Transform::STRING_ARRAY)
+            Transform::Hash::Key.new('requires',          Transform::STRING_ARRAY),
+            Transform::Hash::Key.new('matcher',           Matcher::Config::LOADER)
           ],
           required: []
         ),

data/lib/mutant/config/coverage_criteria.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Config
+    # Configuration of coverge conditions
+    class CoverageCriteria
+      include Anima.new(:process_abort, :test_result, :timeout)
+
+      EMPTY = new(
+        process_abort: nil,
+        test_result:   nil,
+        timeout:       nil
+      )
+
+      DEFAULT = new(
+        process_abort: false,
+        test_result:   true,
+        timeout:       false
+      )
+
+      TRANSFORM =
+        Transform::Sequence.new(
+          [
+            Transform::Hash.new(
+              optional: [
+                Transform::Hash::Key.new('process_abort', Transform::BOOLEAN),
+                Transform::Hash::Key.new('test_result',   Transform::BOOLEAN),
+                Transform::Hash::Key.new('timeout',       Transform::BOOLEAN)
+              ],
+              required: []
+            ),
+            Transform::Hash::Symbolize.new,
+            ->(value) { Either::Right.new(DEFAULT.with(**value)) }
+          ]
+        )
+
+      # Merge coverage criteria with other instance
+      #
+      # Values from the other instance have precedence.
+      #
+      # @param [CoverageCriteria] other
+      #
+      # @return [CoverageCriteria]
+      def merge(other)
+        self.class.new(
+          process_abort: overwrite(other, :process_abort),
+          test_result:   overwrite(other, :test_result),
+          timeout:       overwrite(other, :timeout)
+        )
+      end
+
+    private
+
+      def overwrite(other, attribute_name)
+        other_value = other.public_send(attribute_name)
+
+        other_value.nil? ? public_send(attribute_name) : other_value
+      end
+    end # CoverageCriteria
+  end # Config
+end # Mutant

data/lib/mutant/expression.rb

@@ -4,8 +4,6 @@ module Mutant
 
   # Abstract base class for match expression
   class Expression
-    include AbstractType
-
     fragment             = /[A-Za-z][A-Za-z\d_]*/.freeze
     SCOPE_NAME_PATTERN   = /(?<scope_name>#{fragment}(?:#{SCOPE_OPERATOR}#{fragment})*)/.freeze
     SCOPE_SYMBOL_PATTERN = '(?<scope_symbol>[.#])'
@@ -16,16 +14,6 @@ module Mutant
       super.freeze
     end
 
-    # Syntax of expression
-    #
-    # @return [Matcher]
-    abstract_method :matcher
-
-    # Syntax of expression
-    #
-    # @return [String]
-    abstract_method :syntax
-
     # Match length with other expression
     #
     # @param [Expression] other

data/lib/mutant/matcher.rb

@@ -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
       )
@@ -17,15 +17,34 @@ module Mutant
       ENUM_DELIMITER      = ','
       EMPTY_ATTRIBUTES    = 'empty'
       PRESENTATIONS       = IceNine.deep_freeze(
-        ignore_expressions: :syntax,
-        match_expressions:  :syntax,
-        start_expressions:  :syntax,
-        subject_filters:    :inspect
+        ignore:            :syntax,
+        start_expressions: :syntax,
+        subject_filters:   :inspect,
+        subjects:          :syntax
       )
       private_constant(*constants(false))
 
       DEFAULT = new(Hash[anima.attribute_names.map { |name| [name, []] }])
 
+      expression = ->(input) { Mutant::Config::DEFAULT.expression_parser.call(input) }
+
+      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

@@ -87,9 +87,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/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/mutator/node/kwargs.rb

@@ -28,7 +28,7 @@ module Mutant
         def emit_argument_mutations
           children.each_with_index do |child, index|
             Mutator.mutate(child).each do |mutant|
-              if forbid_argument?(mutant)
+              unless forbid_argument?(mutant)
                 emit_child_update(index, mutant)
               end
             end
@@ -36,7 +36,7 @@ module Mutant
         end
 
         def forbid_argument?(node)
-          !(n_pair?(node) && DISALLOW.include?(node.children.first.type))
+          n_pair?(node) && DISALLOW.include?(node.children.first.type)
         end
       end # Kwargs
     end # Node

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,31 @@ 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?))
+
+            Mutator.mutate(body_ast).each do |mutation|
+              source = AST::Regexp.to_expression(mutation).to_s
+              emit_type(s(:str, source), options)
+            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/regexp.rb

@@ -0,0 +1,31 @@
+# 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
+
+        # 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/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/capture_group.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      module Regexp
+        # Mutator for regexp capture groups, such as `/(foo)/`
+        class CaptureGroup < Node
+          handle(:regexp_capture_group)
+
+          children :group
+
+        private
+
+          def dispatch
+            return unless group
+
+            emit(s(:regexp_passive_group, group))
+            emit_group_mutations
+          end
+        end # EndOfLineAnchor
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      module Regexp
+        # Character type mutator
+        class CharacterType < Node
+          map = {
+            regexp_digit_type:           :regexp_nondigit_type,
+            regexp_hex_type:             :regexp_nonhex_type,
+            regexp_space_type:           :regexp_nonspace_type,
+            regexp_word_boundary_anchor: :regexp_nonword_boundary_anchor,
+            regexp_word_type:            :regexp_nonword_type,
+            regexp_xgrapheme_type:       :regexp_linebreak_type
+          }
+
+          MAP = IceNine.deep_freeze(map.merge(map.invert))
+
+          handle(*MAP.keys)
+
+        private
+
+          def dispatch
+            emit(s(MAP.fetch(node.type)))
+          end
+        end # CharacterType
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutant