mutant 0.8.11 → 0.8.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2b6726d9cc7696a22bc3de412e2aec93c6098212
-  data.tar.gz: 1c68cebbe3bd9faf603b604621a5af7cfb6402d1
+  metadata.gz: e9fccb5b88d832378fa591e769d03f29bd9157ad
+  data.tar.gz: 7a84e4ba5e25a538218b4a4d2efab2be9a7c90e0
 SHA512:
-  metadata.gz: c9a1dd4866a3264565adccb269d212b0609bdd806fc94e9f42b3366deb951967c48d0595f6044158a1719155557af450fb949821eadb7699432aa73262e7e1cf
-  data.tar.gz: 2cb50707ab5a178bb9eb8d1288251e978db32fbd92efddc1a4417e772df2ec4f2cefa86fceaeeb2dc5a7b7a654afe9c9182d548183a733497d17fdc9459515ea
+  metadata.gz: 0590a8d9f4775c4c21b1599a67f2360a8319b5fce2ec4264846c731a9468a09108bccb8ed56bc72ca7ba5087eac13135e004ab02fb4848f490bbe86c2c6e9833
+  data.tar.gz: c2a3e39dbb3ee300d3c526e0aecba9fcf866fef79a4954eb004a928f448f2c67e56655a84df4f0145e9b06f4b14e65e6de85a1ffa8e98dc7c540b8936335f4cc

data/.gitattributes

@@ -0,0 +1 @@
+Changelog.md merge=union

data/Changelog.md

@@ -1,10 +1,36 @@
-# v0.8.11 2016-01-xx
+# v0.8.12 2016-10-17
+
+* Add mutation from `/foo|bar/` to `/foo/` and `/bar/`
+* Add mutation from `/$/` to `/\z/`
+* Add mutation from `/\h/` to `/\H/`
+* Add mutation from `/\H/` to `/\h/`
+* Add mutation from `/\Z/` to `/\z/`
+* Add mutation from `flat_map` to `map`
+* Add mutation from `/(foo)/` to `/(?:foo)/`
+* Add mutation from `/a*/` to `/a+/`
+* Add mutation from `/a*/` to `/a/`
+* Add mutation from `!!foo` to `foo`
+* Add mutation from `proc { }` to `lambda { }`
+
+# v0.8.11 2016-08-01
 
 * Add support for rspec-3.5
-* Remove misleading --debug option
-* Remove misleading --expect-coverage option
+* Remove misleading `--debug` option
+* Remove misleading `--expect-coverage` option
 * Add basic support for regexp mutations (machinery and simple anchor mutations)
 * Add support for mutating csend (duck tape operator) into regular sends
+* Add mutation from `foo&.bar` to `foo.bar`
+* Add mutation from `#to_a` to `#to_set`
+* Add mutation from `foo.dig(a, b)` to `foo.fetch(a).dig(b)`
+* Add mutation from `def foo(bar:); end` to `def foo(_bar:); end`
+* Add mutation from `def foo(bar: baz); end` to `def foo(_bar: baz); end`
+* Add mutation from `/regex/i` to `/regex/`
+* Add mutation from `foo[n..-1]` to `foo.drop(n)`
+* Add mutation from `/^/` to `/\A/`
+* Add mutation from `#first` to `#last`
+* Add mutation from `#last` to `#first`
+* Add mutation from `#sample` to `#first` and `#last`
+* Remove mutations from `1..n` to `1..(0.0 / 0.0)` and `1..(1.0 / 0.0)`
 
 # v0.8.10 2016-01-24
 

data/README.md

@@ -340,6 +340,7 @@ Blog posts
 
 Sorted by recency:
 
+* [A deep dive into mutation testing and how the Mutant gem works][troessner]
 * [How to write better code using mutation testing (November 2015)][blockscore]
 * [How good are your Ruby tests? Testing your tests with mutant (June 2015)][arkency1]
 * [Mutation testing and continuous integration (May 2015)][arkency2]
@@ -347,6 +348,7 @@ Sorted by recency:
 * [Mutation testing with mutant (April 2014)][sitepoint]
 * [Mutation testing with mutant (January 2013)][solnic]
 
+[troessner]: https://troessner.svbtle.com/kill-all-the-mutants-a-deep-dive-into-mutation-testing-and-how-the-mutant-gem-works
 [blockscore]: https://blog.blockscore.com/how-to-write-better-code-using-mutation-testing/
 [sitepoint]: http://www.sitepoint.com/mutation-testing-mutant/
 [arkency1]: http://blog.arkency.com/2015/06/how-good-are-your-ruby-tests-testing-your-tests-with-mutant/

data/config/flay.yml

@@ -1,3 +1,3 @@
 ---
 threshold: 16
-total_score: 1284
+total_score: 1317

data/lib/mutant.rb

@@ -91,6 +91,12 @@ require 'mutant/mutator/util/symbol'
 require 'mutant/mutator/node'
 require 'mutant/mutator/node/generic'
 require 'mutant/mutator/node/regexp'
+require 'mutant/mutator/node/regexp/alternation_meta'
+require 'mutant/mutator/node/regexp/capture_group'
+require 'mutant/mutator/node/regexp/character_type'
+require 'mutant/mutator/node/regexp/end_of_line_anchor'
+require 'mutant/mutator/node/regexp/end_of_string_or_before_end_of_line_anchor'
+require 'mutant/mutator/node/regexp/greedy_zero_or_more'
 require 'mutant/mutator/node/literal'
 require 'mutant/mutator/node/literal/boolean'
 require 'mutant/mutator/node/literal/range'

data/lib/mutant/ast/meta/send.rb

@@ -21,6 +21,13 @@ module Mutant
 
         public :arguments
 
+        # Test if node is defining a proc
+        #
+        # @return [Boolean]
+        def proc?
+          naked_proc? || proc_new?
+        end
+
         # Test if AST node is a valid assignment target
         #
         # @return [Boolean]
@@ -59,6 +66,25 @@ module Mutant
           Const.new(receiver).possible_top_level?
         end
 
+      private
+
+        # Test if node is `proc { ... }`
+        #
+        # @return [Boolean]
+        def naked_proc?
+          !receiver && selector.equal?(:proc)
+        end
+
+        # Test if node is `Proc.new { ... }`
+        #
+        # @return [Boolean]
+        def proc_new?
+          receiver                &&
+            selector.equal?(:new) &&
+            n_const?(receiver)    &&
+            Const.new(receiver).name.equal?(:Proc)
+        end
+
       end # Send
     end # Meta
   end # AST

data/lib/mutant/ast/regexp/transformer/direct.rb

@@ -70,6 +70,7 @@ module Mutant
               [:regexp_script_hiragana_property, [:property, :script_hiragana,  '\p{Hiragana}'], ::Regexp::Expression::UnicodeProperty::Script],
               [:regexp_script_katakana_property, [:property, :script_katakana,  '\p{Katakana}'], ::Regexp::Expression::UnicodeProperty::Script],
               [:regexp_letter_any_property,      [:property, :letter_any,       '\p{L}'],        ::Regexp::Expression::UnicodeProperty::Letter::Any],
+              [:regexp_hex_type,                 [:type,     :hex,              '\h'],           ::Regexp::Expression::CharacterType::Hex],
               [:regexp_digit_type,               [:type,     :digit,            '\d'],           ::Regexp::Expression::CharacterType::Digit],
               [:regexp_space_type,               [:type,     :space,            '\s'],           ::Regexp::Expression::CharacterType::Space],
               [:regexp_word_type,                [:type,     :word,             '\w'],           ::Regexp::Expression::CharacterType::Word],

data/lib/mutant/env/bootstrap.rb

@@ -56,17 +56,22 @@ module Mutant
         Env.new(
           actor_env:        Actor::Env.new(Thread),
           config:           config,
-          integration:      @integration,
+          integration:      integration,
           matchable_scopes: matchable_scopes,
           mutations:        subjects.flat_map(&:mutations),
           parser:           parser,
-          selector:         Selector::Expression.new(@integration),
+          selector:         Selector::Expression.new(integration),
           subjects:         subjects
         )
       end
 
     private
 
+      # Configured mutant integration
+      #
+      # @return [Mutant::Integration]
+      attr_reader :integration
+
       # Scope name from scoping object
       #
       # @param [Class, Module] scope

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

@@ -75,6 +75,14 @@ module Mutant
           mutation('self')
         end
 
+        # Add regexp mutations
+        #
+        # @return [undefined]
+        def regexp_mutations
+          mutation('//')
+          mutation('/nomatch\A/')
+        end
+
         # Helper method to coerce input to node
         #
         # @param [String,Parser::AST::Node] input

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

@@ -5,16 +5,60 @@ module Mutant
       # Generic mutator
       class Generic < self
 
+        unsupported_nodes = %i[
+          ensure
+          redo
+          retry
+          arg_expr
+          blockarg
+          kwrestarg
+          undef
+          module
+          empty
+          alias
+          for
+          xstr
+          back_ref
+          restarg
+          sclass
+          match_with_lvasgn
+          while_post
+          until_post
+          preexe
+          postexe
+          iflipflop
+          eflipflop
+          kwsplat
+          shadowarg
+          rational
+          complex
+          __FILE__
+          __LINE__
+        ]
+
+        unsupported_regexp_nodes = AST::Types::REGEXP.to_a - %i[
+          regexp_alternation_meta
+          regexp_bol_anchor
+          regexp_capture_group
+          regexp_digit_type
+          regexp_eol_anchor
+          regexp_eos_ob_eol_anchor
+          regexp_greedy_zero_or_more
+          regexp_hex_type
+          regexp_nondigit_type
+          regexp_nonhex_type
+          regexp_nonspace_type
+          regexp_nonword_boundary_anchor
+          regexp_nonword_type
+          regexp_root_expression
+          regexp_space_type
+          regexp_word_boundary_anchor
+          regexp_word_type
+        ]
+
         # These nodes still need a dedicated mutator,
         # your contribution is that close!
-        handle(
-          :ensure, :redo, :retry, :arg_expr, :blockarg,
-          :kwrestarg, :undef, :module, :empty,
-          :alias, :for, :xstr, :back_ref, :restarg,
-          :sclass, :match_with_lvasgn, :while_post,
-          :until_post, :preexe, :postexe, :iflipflop, :eflipflop, :kwsplat,
-          :shadowarg, :rational, :complex, :__FILE__, :__LINE__
-        )
+        handle(*(unsupported_nodes + unsupported_regexp_nodes))
 
       private
 

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

@@ -2,17 +2,6 @@ module Mutant
   class Mutator
     class Node
       module Regexp
-        # Generic regexp mutator
-        class Generic < Node
-          handle(*(AST::Types::REGEXP - %i[regexp_root_expression regexp_bol_anchor]))
-
-          # Noop dispatch
-          #
-          # @return [undefined]
-          def dispatch
-          end
-        end # Generic
-
         # Mutator for root expression regexp wrapper
         class RootExpression < Node
           handle(:regexp_root_expression)

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

@@ -0,0 +1,21 @@
+module Mutant
+  class Mutator
+    class Node
+      module Regexp
+        # Mutator for pipe in `/foo|bar/` regexp
+        class AlternationMeta < Node
+          handle(:regexp_alternation_meta)
+
+        private
+
+          # Dispatch mutations
+          #
+          # @return [undefined]
+          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,26 @@
+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
+
+          # Emit mutations
+          #
+          # Replace `(captured_group)` with `(?:non_captured_group)`
+          #
+          # @return [undefined]
+          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,29 @@
+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
+          }
+
+          MAP = IceNine.deep_freeze(map.merge(map.invert))
+
+          handle(*MAP.keys)
+
+          # Mutate to invert character type
+          #
+          # @return [undefined]
+          def dispatch
+            emit(s(MAP.fetch(node.type)))
+          end
+        end # CharacterType
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -0,0 +1,21 @@
+module Mutant
+  class Mutator
+    class Node
+      module Regexp
+        # Mutator for end of line anchor `$`
+        class EndOfLineAnchor < Node
+          handle(:regexp_eol_anchor)
+
+          # Emit mutations
+          #
+          # Replace `$` with `\z`
+          #
+          # @return [undefined]
+          def dispatch
+            emit(s(:regexp_eos_anchor))
+          end
+        end # EndOfLineAnchor
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -0,0 +1,21 @@
+module Mutant
+  class Mutator
+    class Node
+      module Regexp
+        # Mutator for end of line or before end of string anchor `\Z`
+        class EndOfStringOrBeforeEndOfLineAnchor < Node
+          handle(:regexp_eos_ob_eol_anchor)
+
+          # Emit mutations
+          #
+          # Replace `\Z` with `\z`
+          #
+          # @return [undefined]
+          def dispatch
+            emit(s(:regexp_eos_anchor))
+          end
+        end # EndOfStringOrBeforeEndOfLineAnchor
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -0,0 +1,25 @@
+module Mutant
+  class Mutator
+    class Node
+      module Regexp
+        # Mutator for greedy zero-or-more quantifier, `*`
+        class GreedyZeroOrMore < Node
+          handle(:regexp_greedy_zero_or_more)
+
+          children :min, :max, :subject
+
+          # Emit mutations
+          #
+          # Replace `/a*/` with `/a+/`
+          #
+          # @return [undefined]
+          def dispatch
+            emit(s(:regexp_greedy_one_or_more, *children))
+            emit_subject_mutations
+            emit(subject)
+          end
+        end # GreedyZeroOrMore
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -18,6 +18,7 @@ module Mutant
           reverse_each:  %i[each],
           reverse_merge: %i[merge],
           map:           %i[each],
+          flat_map:      %i[map],
           sample:        %i[first last],
           pop:           %i[last],
           shift:         %i[first],
@@ -110,6 +111,8 @@ module Mutant
           emit_const_get_mutation
           emit_integer_mutation
           emit_dig_mutation
+          emit_double_negation_mutation
+          emit_lambda_mutation
           emit_drop_mutation
         end
 
@@ -125,6 +128,23 @@ module Mutant
             .each(&method(:emit_selector))
         end
 
+        # Emit mutation from `!!foo` to `foo`
+        #
+        # @return [undefined]
+        def emit_double_negation_mutation
+          return unless selector.equal?(:!) && n_send?(receiver)
+
+          negated = AST::Meta::Send.new(meta.receiver)
+          emit(negated.receiver) if negated.selector.equal?(:!)
+        end
+
+        # Emit mutation from proc definition to lambda
+        #
+        # @return [undefined]
+        def emit_lambda_mutation
+          emit(s(:send, nil, :lambda)) if meta.proc?
+        end
+
         # Emit mutation for `#dig`
         #
         # - Mutates `foo.dig(a, b)` to `foo.fetch(a).dig(b)`
@@ -232,5 +252,4 @@ module Mutant
       end # Send
     end # Node
   end # Mutator
-
 end # Mutant