mutest 0.0.1 → 0.0.2

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

@@ -0,0 +1,47 @@
+module Mutest
+  class Mutator
+    class Node
+      module NamedValue
+        # Mutation emitter to handle variable assignment nodes
+        class VariableAssignment < Node
+          children :name, :value
+
+          map = {
+            gvasgn: '$',
+            cvasgn: '@@',
+            ivasgn: '@',
+            lvasgn: EMPTY_STRING
+          }
+
+          MAP = IceNine.deep_freeze(
+            Hash[map.map { |type, prefix| [type, [prefix, /^#{::Regexp.escape(prefix)}/]] }]
+          )
+
+          handle(*MAP.keys)
+
+          private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          def dispatch
+            emit_singletons
+            mutate_name
+            emit_value_mutations if value # op asgn!
+          end
+
+          # Emit name mutations
+          #
+          # @return [undefined]
+          def mutate_name
+            prefix, regexp = MAP.fetch(node.type)
+            stripped = name.to_s.sub(regexp, EMPTY_STRING)
+            mutate_with(Util::Symbol, stripped) do |name|
+              emit_name(:"#{prefix}#{name}")
+            end
+          end
+        end # VariableAssignment
+      end # NamedValue
+    end # Node
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/node/next.rb

@@ -0,0 +1,22 @@
+module Mutest
+  class Mutator
+    class Node
+      # Mutator for loop control keywords
+      class Next < Generic
+        handle(:next)
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          super()
+          emit_singletons
+          children.each_index(&method(:delete_child))
+          emit(s(:break, *children))
+        end
+      end # Next
+    end # Node
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/node/noop.rb

@@ -0,0 +1,19 @@
+module Mutest
+  class Mutator
+    class Node
+      # Mutation emitter to handle noop nodes
+      class Noop < self
+        handle(:block_pass, :cbase)
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          # noop
+        end
+      end # Noop
+    end # Node
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/node/nthref.rb

@@ -0,0 +1,22 @@
+module Mutest
+  class Mutator
+    class Node
+      # Mutator for nth-ref nodes
+      class NthRef < self
+        handle :nth_ref
+
+        children :number
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_number(number - 1) unless number.equal?(1)
+          emit_number(number + 1)
+        end
+      end # NthRef
+    end # Node
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/node/op_asgn.rb

@@ -0,0 +1,50 @@
+module Mutest
+  class Mutator
+    class Node
+      # OpAsgn mutator
+      class OpAsgn < self
+        handle(:op_asgn)
+
+        children :left, :operation, :right
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_singletons
+          emit_left_mutations do |node|
+            !n_self?(node)
+          end
+          emit_right_mutations
+          emit_compound_assignment_mutations
+        end
+
+        # Mutate compound assignments like `+=` to `+` and `=`
+        def emit_compound_assignment_mutations
+          case left.type
+          when :lvasgn then emit_lvar_mutation
+          when :ivasgn then emit_ivar_mutation
+          when :send   then emit_send_mutation
+          end
+        end
+
+        def emit_lvar_mutation
+          emit(s(:send, s(:send, nil, *left), operation, right))
+          emit(s(:lvasgn, *left, right))
+        end
+
+        def emit_ivar_mutation
+          emit(s(:send, s(:ivar, *left), operation, right))
+          emit(s(:ivasgn, *left, right))
+        end
+
+        def emit_send_mutation
+          emit(s(:send, left, operation, right))
+          emit(s(:send, left.children.first, :"#{left.children.last}=", right))
+        end
+      end # OpAsgn
+    end # Node
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/node/or_asgn.rb

@@ -0,0 +1,26 @@
+module Mutest
+  class Mutator
+    class Node
+      # OrAsgn mutator
+      class OrAsgn < self
+        handle(:or_asgn)
+
+        children :left, :right
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_singletons
+          emit_right_mutations
+          return if n_ivasgn?(left)
+          emit_left_mutations do |node|
+            AST::Types::ASSIGNABLE_VARIABLES.include?(node.type)
+          end
+        end
+      end # OrAsgn
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,33 @@
+module Mutest
+  class Mutator
+    class Node
+      module Regexp
+        # Mutator for root expression regexp wrapper
+        class RootExpression < Node
+          handle(:regexp_root_expression)
+
+          # Emit mutations for children of root node
+          #
+          # @return [undefined]
+          def dispatch
+            children.each_index(&method(:mutate_child))
+          end
+        end # RootExpression
+
+        # Mutator for beginning of line anchor `^`
+        class BeginningOfLineAnchor < Node
+          handle(:regexp_bol_anchor)
+
+          # Emit mutations
+          #
+          # Replace `^` with `\A`
+          #
+          # @return [undefined]
+          def dispatch
+            emit(s(:regexp_bos_anchor))
+          end
+        end # BeginningOfLineAnchor
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,21 @@
+module Mutest
+  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 # Mutest

data/lib/mutest/mutator/node/regexp/capture_group.rb

@@ -0,0 +1,26 @@
+module Mutest
+  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 # CaptureGroup
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,29 @@
+module Mutest
+  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 # Mutest

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

@@ -0,0 +1,21 @@
+module Mutest
+  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 # Mutest

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

@@ -0,0 +1,21 @@
+module Mutest
+  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 # Mutest

data/lib/mutest/mutator/node/regexp/one_or_more.rb

@@ -0,0 +1,29 @@
+module Mutest
+  class Mutator
+    class Node
+      module Regexp
+        # Mutator for one-or-more quantifier, `+`
+        class OneOrMore < Node
+          MAP = IceNine.deep_freeze(
+            regexp_greedy_one_or_more:     :regexp_greedy_interval,
+            regexp_reluctant_one_or_more:  :regexp_reluctant_interval,
+            regexp_possessive_one_or_more: :regexp_possessive_interval
+          )
+
+          handle(*MAP.keys)
+
+          children :min, :max, :subject
+
+          # Replace `/a+/` with `/a{2,}/`, `/a+?/` with `/a{2,}?/`, and `/a++/` with `/a{2,}+/`
+          #
+          # @return [undefined]
+          def dispatch
+            emit(s(MAP.fetch(node.type), 2, -1, subject))
+            emit_subject_mutations
+            emit(subject)
+          end
+        end # OneOrMore
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/node/regexp/zero_or_more.rb

@@ -0,0 +1,29 @@
+module Mutest
+  class Mutator
+    class Node
+      module Regexp
+        # Mutator for zero-or-more quantifier, `*`
+        class ZeroOrMore < Node
+          MAP = IceNine.deep_freeze(
+            regexp_greedy_zero_or_more:     :regexp_greedy_one_or_more,
+            regexp_reluctant_zero_or_more:  :regexp_reluctant_one_or_more,
+            regexp_possessive_zero_or_more: :regexp_possessive_one_or_more
+          )
+
+          handle(*MAP.keys)
+
+          children :min, :max, :subject
+
+          # Replace `/a*/` with `/a+/`, `/a*?/` with `/a+?/`, and `/a*+/` with `/a++/`
+          #
+          # @return [undefined]
+          def dispatch
+            emit(s(MAP.fetch(node.type), *children))
+            emit_subject_mutations
+            emit(subject)
+          end
+        end # ZeroOrMore
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/node/regopt.rb

@@ -0,0 +1,28 @@
+module Mutest
+  class Mutator
+    class Node
+      # Regular expression options mutation
+      class Regopt < self
+        MUTATED_FLAGS = IceNine.deep_freeze(%i[i])
+
+        handle(:regopt)
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_type(*mutated_flags)
+        end
+
+        # Altered flags array excluding case insensitive flag
+        #
+        # @return [Array<Symbol>]
+        def mutated_flags
+          (children - MUTATED_FLAGS)
+        end
+      end # Regopt
+    end # Node
+  end # Mutator
+end # Mutest