mutest 0.0.1 → 0.0.2

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

@@ -0,0 +1,25 @@
+module Mutest
+  class Mutator
+    class Node
+      # AndAsgn mutator
+      class AndAsgn < self
+        handle(:and_asgn)
+
+        children :left, :right
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_singletons
+          emit_left_mutations do |node|
+            !n_self?(node)
+          end
+          emit_right_mutations
+        end
+      end # AndAsgn
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,68 @@
+module Mutest
+  class Mutator
+    class Node
+      # Mutator for required arguments
+      class Argument < self
+        handle(:arg, :restarg, :kwarg, :kwrestarg)
+
+        UNDERSCORE = '_'.freeze
+
+        children :name
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_name_mutation
+        end
+
+        # Emit name mutations
+        #
+        # @return [undefined]
+        def emit_name_mutation
+          return if skip?
+          emit_name(:"#{UNDERSCORE}#{name}")
+        end
+
+        # Test if argument mutation is skipped
+        #
+        # @return [Boolean]
+        def skip?
+          name.nil? || name.to_s.start_with?(UNDERSCORE)
+        end
+
+        # Mutator for optional arguments
+        class Optional < self
+          TYPE_MAP = IceNine.deep_freeze(
+            optarg:   :arg,
+            kwoptarg: :kwarg
+          )
+
+          handle(:optarg, :kwoptarg)
+
+          children :name, :default
+
+          private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          def dispatch
+            emit_name_mutation
+            emit_required_mutation
+            emit_default_mutations
+          end
+
+          # Emit required mutation
+          #
+          # @return [undefined]
+          def emit_required_mutation
+            emit(s(TYPE_MAP.fetch(node.type), name))
+          end
+        end # Optional
+      end # Argument
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,90 @@
+module Mutest
+  class Mutator
+    class Node
+      # Mutator for arguments node
+      class Arguments < self
+        handle(:args)
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_argument_presence
+          emit_argument_mutations
+          emit_hash_type_hint
+          emit_mlhs_expansion
+        end
+
+        # Emit argument presence mutation
+        #
+        # @return [undefined]
+        def emit_argument_presence
+          emit_type
+          mutate_with(Util::Array::Presence, children) do |children|
+            emit_type(*children)
+          end
+        end
+
+        # Emit argument mutations
+        #
+        # @return [undefined]
+        def emit_argument_mutations
+          children.each_with_index do |child, index|
+            mutate(child).each do |mutest|
+              next if invalid_argument_replacement?(mutest, index)
+              emit_child_update(index, mutest)
+            end
+          end
+        end
+
+        # Test if child mutation is allowed
+        #
+        # @param [Parser::AST::Node]
+        #
+        # @return [Boolean]
+        def invalid_argument_replacement?(mutest, index)
+          n_arg?(mutest) && children[0...index].any?(&method(:n_optarg?))
+        end
+
+        def emit_hash_type_hint
+          *first_args, last_arg = children
+
+          return unless last_arg && hintworthy_node?(last_arg)
+
+          last_name = last_arg.children.first
+
+          emit_type(*first_args, s(:kwrestarg, last_name)) unless last_name.to_s.start_with?('_')
+        end
+
+        # Is this a simple arg or arg={} ?
+        def hintworthy_node?(node)
+          n_arg?(node) ||
+            (n_optarg?(node) && node.children.last.eql?(s(:hash)))
+        end
+
+        # Emit mlhs expansions
+        #
+        # @return [undefined]
+        def emit_mlhs_expansion
+          mlhs_childs_with_index.each do |child, index|
+            dup_children = children.dup
+            dup_children.delete_at(index)
+            dup_children.insert(index, *child)
+            emit_type(*dup_children)
+          end
+        end
+
+        # Multiple left hand side childs
+        #
+        # @return [Enumerable<Parser::AST::Node, Fixnum>]
+        def mlhs_childs_with_index
+          children.each_with_index.select do |child, _index|
+            n_mlhs?(child)
+          end
+        end
+      end # Arguments
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,21 @@
+module Mutest
+  class Mutator
+    class Node
+      # Mutator for begin nodes
+      class Begin < self
+        handle(:begin)
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          mutate_single_child do |child|
+            emit(child)
+          end
+        end
+      end # Begin
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,64 @@
+module Mutest
+  class Mutator
+    class Node
+      # Mutation emitter to handle binary connectives
+      class Binary < self
+        INVERSE = {
+          and: :or,
+          or:  :and
+        }.freeze
+
+        handle(*INVERSE.keys)
+
+        children :left, :right
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_singletons
+          emit_promotions
+          emit_operator_mutations
+          emit_left_negation
+          emit_left_mutations
+          emit_right_mutations
+        end
+
+        # Emit operator mutations
+        #
+        # @return [undefined]
+        def emit_operator_mutations
+          emit(s(INVERSE.fetch(node.type), left, right))
+        end
+
+        # Emit promotions
+        #
+        # @return [undefined]
+        def emit_promotions
+          emit(left)
+          emit(right)
+        end
+
+        # Emit left negation
+        #
+        # We do not emit right negation as the `and` and `or` nodes
+        # in ruby are also used for control flow.
+        #
+        # Irrespective of their syntax, aka `||` parses internally to `or`.
+        #
+        # `do_a or do_b`. Negating left makes sense, negating right
+        # only when the result is actually used.
+        #
+        # It *would* be possible to emit the right negation in case the use of the result is proved.
+        # Like parent is an assignment to an {l,i}var. Dunno if we ever get the time to do that.
+        #
+        # @return [undefined]
+        def emit_left_negation
+          emit(s(node.type, n_not(left), right))
+        end
+      end # Binary
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,51 @@
+module Mutest
+  class Mutator
+    class Node
+      # Emitter for mutations on 19 blocks
+      class Block < self
+        handle(:block)
+
+        children :send, :arguments, :body
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_singletons
+          emit(send)
+          emit_send_mutations(&method(:n_send?))
+          emit_arguments_mutations
+
+          mutate_body
+        end
+
+        # Emit body mutations
+        #
+        # @return [undefined]
+        def mutate_body
+          emit_body(nil)
+          emit_body(N_RAISE)
+
+          return unless body
+          emit(body)
+          emit_body_mutations
+
+          mutate_body_receiver
+        end
+
+        # Mutate method send in body scope of `send`
+        #
+        # @return [undefined]
+        def mutate_body_receiver
+          return unless n_send?(body)
+
+          body_meta = AST::Meta::Send.new(body)
+
+          emit(s(:send, send, body_meta.selector, *body_meta.arguments))
+        end
+      end # Block
+    end # Node
+  end # Mutator
+end # Mutest

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

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

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

@@ -0,0 +1,47 @@
+module Mutest
+  class Mutator
+    class Node
+      # Mutator for case nodes
+      class Case < self
+        handle(:case)
+
+        children :condition
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_singletons
+          emit_condition_mutations if condition
+          emit_when_mutations
+          emit_else_mutations
+        end
+
+        # Emit when mutations
+        #
+        # @return [undefined]
+        def emit_when_mutations
+          indices = children.each_index.drop(1).take(children.length - 2)
+          one = indices.one?
+          indices.each do |index|
+            mutate_child(index)
+            delete_child(index) unless one
+          end
+        end
+
+        # Emit else mutations
+        #
+        # @return [undefined]
+        def emit_else_mutations
+          else_branch = children.last
+          else_index = children.length - 1
+          return unless else_branch
+          mutate_child(else_index)
+          emit_child_update(else_index, nil)
+        end
+      end # Case
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,21 @@
+module Mutest
+  class Mutator
+    class Node
+      # Namespace for class mutations
+      class Class < self
+        handle :class
+
+        children :klass, :parent, :body
+
+        private
+
+        # Emit mutations only for class body
+        #
+        # @return [undefined]
+        def dispatch
+          emit_body_mutations if body
+        end
+      end # Class
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,25 @@
+module Mutest
+  class Mutator
+    class Node
+      # Mutator for while expressions
+      class ConditionalLoop < self
+        handle(:until, :while)
+
+        children :condition, :body
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_singletons
+          emit_condition_mutations
+          emit_body_mutations if body
+          emit_body(nil)
+          emit_body(N_RAISE)
+        end
+      end # ConditionalLoop
+    end # Node
+  end # Mutator
+end # Mutest