mutest 0.0.1 → 0.0.2

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

@@ -0,0 +1,23 @@
+module Mutest
+  class Mutator
+    class Node
+      # Mutation emitter to handle const nodes
+      class Const < self
+        handle(:const)
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_singletons unless parent_node && n_const?(parent_node)
+          emit_type(nil, *children.drop(1))
+          children.each_with_index do |child, index|
+            mutate_child(index) if child.instance_of?(::Parser::AST::Node)
+          end
+        end
+      end # Const
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,79 @@
+module Mutest
+  class Mutator
+    class Node
+      # Namespace for define mutations
+      class Define < self
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_arguments_mutations
+          emit_optarg_body_assignments
+          emit_restarg_body_mutation
+          emit_body(N_RAISE)
+          emit_body(N_ZSUPER)
+          emit_body(nil)
+          emit_body_mutations if body
+        end
+
+        # Emit mutations with optional arguments as assignments in method
+        #
+        # @return [undefined]
+        def emit_optarg_body_assignments
+          arguments.children.each do |argument|
+            next unless n_optarg?(argument) && AST::Meta::Optarg.new(argument).used?
+
+            emit_body_prepend(s(:lvasgn, *argument))
+          end
+        end
+
+        # Emit mutation with arg splat as empty array assignment in method
+        #
+        # @return [undefined]
+        def emit_restarg_body_mutation
+          arguments.children.each do |argument|
+            replacement =
+              if n_restarg?(argument)
+                s(:array)
+              elsif n_kwrestarg?(argument)
+                s(:hash)
+              end
+
+            next unless replacement && argument.children.one?
+
+            emit_body_prepend(s(:lvasgn, AST::Meta::Restarg.new(argument).name, replacement))
+          end
+        end
+
+        # Emit valid body ASTs depending on instance body
+        #
+        # @param node [Parser::AST::Node]
+        #
+        # @return [undefined]
+        def emit_body_prepend(node)
+          if body
+            emit_body(s(:begin, node, body))
+          else
+            emit_body(node)
+          end
+        end
+
+        # Mutator for instance method defines
+        class Instance < self
+          handle :def
+
+          children :name, :arguments, :body
+        end # Instance
+
+        # Mutator for singleton method defines
+        class Singleton < self
+          handle :defs
+
+          children :subject, :name, :arguments, :body
+        end # Singleton
+      end # Define
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,24 @@
+module Mutest
+  class Mutator
+    class Node
+      # Namespace for `defined?` mutations
+      class Defined < self
+        handle(:defined?)
+
+        children :expression
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_singletons
+          emit(N_TRUE)
+
+          emit_expression_mutations { |node| !n_self?(node) }
+        end
+      end # Defined
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,20 @@
+module Mutest
+  class Mutator
+    class Node
+      # Dstr mutator
+      class Dstr < Generic
+        handle(:dstr)
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          super()
+          emit_singletons
+        end
+      end # Dstr
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,20 @@
+module Mutest
+  class Mutator
+    class Node
+      # Dsym mutator
+      class Dsym < Generic
+        handle(:dsym)
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          super()
+          emit_singletons
+        end
+      end # Dsym
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,77 @@
+module Mutest
+  class Mutator
+    class Node
+      # Generic mutator
+      class Generic < self
+        unsupported_nodes = %i[
+          ensure
+          redo
+          retry
+          arg_expr
+          blockarg
+          undef
+          module
+          empty
+          alias
+          for
+          xstr
+          back_ref
+          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_one_or_more
+          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_possessive_one_or_more
+          regexp_possessive_zero_or_more
+          regexp_reluctant_one_or_more
+          regexp_reluctant_zero_or_more
+          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(*(unsupported_nodes + unsupported_regexp_nodes))
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          children.each_with_index do |child, index|
+            mutate_child(index) if child.instance_of?(::Parser::AST::Node)
+          end
+        end
+      end # Generic
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,57 @@
+module Mutest
+  class Mutator
+    class Node
+      # Mutator for if nodes
+      class If < self
+        handle(:if)
+
+        children :condition, :if_branch, :else_branch
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_singletons
+          mutate_condition
+          mutate_if_branch
+          mutate_else_branch
+        end
+
+        # Emit condition mutations
+        #
+        # @return [undefined]
+        def mutate_condition
+          emit_condition_mutations do |node|
+            !n_self?(node)
+          end
+          emit_type(n_not(condition), if_branch, else_branch) unless n_match_current_line?(condition)
+          emit_type(N_TRUE,  if_branch, else_branch)
+          emit_type(N_FALSE, if_branch, else_branch)
+        end
+
+        # Emit if branch mutations
+        #
+        # @return [undefined]
+        def mutate_if_branch
+          emit_type(condition, else_branch, nil) if else_branch
+          return unless if_branch
+          emit(if_branch)
+          emit_if_branch_mutations
+          emit_type(condition, if_branch, nil)
+        end
+
+        # Emit else branch mutations
+        #
+        # @return [undefined]
+        def mutate_else_branch
+          return unless else_branch
+          emit(else_branch)
+          emit_else_branch_mutations
+          emit_type(condition, nil, else_branch)
+        end
+      end # If
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,20 @@
+module Mutest
+  class Mutator
+    class Node
+      # Kwbegin mutator
+      class Kwbegin < Generic
+        handle(:kwbegin)
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          super()
+          emit_singletons
+        end
+      end # Kwbegin
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,19 @@
+module Mutest
+  class Mutator
+    class Node
+      # Abstract mutator for literal AST nodes
+      class Literal < self
+        include AbstractType
+
+        private
+
+        # Emit values
+        #
+        # @return [undefined]
+        def emit_values
+          values.each(&method(:emit_type))
+        end
+      end # Literal
+    end # Node
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/node/literal/array.rb

@@ -0,0 +1,37 @@
+module Mutest
+  class Mutator
+    class Node
+      class Literal < self
+        # Mutator for array literals
+        class Array < self
+          handle(:array)
+
+          private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          def dispatch
+            emit_singletons
+            emit_type
+            mutate_body
+            return unless children.one?
+            emit(children.first)
+          end
+
+          # Mutate body
+          #
+          # @return [undefined]
+          def mutate_body
+            children.each_index do |index|
+              dup_children = children.dup
+              dup_children.delete_at(index)
+              emit_type(*dup_children)
+              mutate_child(index)
+            end
+          end
+        end # Array
+      end # Literal
+    end # Node
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/node/literal/boolean.rb

@@ -0,0 +1,27 @@
+module Mutest
+  class Mutator
+    class Node
+      class Literal < self
+        # Abstract mutator for boolean literals
+        class Boolean < self
+          private
+
+          MAP = {
+            true:  :false,
+            false: :true
+          }.freeze
+
+          handle(*MAP.keys)
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          def dispatch
+            emit_nil
+            emit(s(MAP.fetch(node.type)))
+          end
+        end # Boolean
+      end # Literal
+    end # Node
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/node/literal/fixnum.rb

@@ -0,0 +1,36 @@
+module Mutest
+  class Mutator
+    class Node
+      class Literal < self
+        # Mutator for fixnum literals
+        class Fixnum < self
+          handle(:int)
+
+          private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          def dispatch
+            emit_singletons
+            emit_values
+          end
+
+          # Values to mutate to
+          #
+          # @return [Array]
+          def values
+            [0, 1, -value, value + 1, value - 1]
+          end
+
+          # Literal original value
+          #
+          # @return [Object]
+          def value
+            children.first
+          end
+        end # Fixnum
+      end # Literal
+    end # Node
+  end # Mutator
+end # Mutest