mutest 0.0.1 → 0.0.2

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

@@ -0,0 +1,45 @@
+module Mutest
+  class Mutator
+    class Node
+      class Literal < self
+        # Mutator for float literals
+        class Float < self
+          handle(:float)
+
+          private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          def dispatch
+            emit_singletons
+            emit_values
+            emit_special_cases
+          end
+
+          SPECIAL = [
+            N_NAN,
+            N_NEGATIVE_INFINITY,
+            N_INFINITY
+          ].freeze
+
+          # Emit special cases
+          #
+          # @return [undefined]
+          def emit_special_cases
+            SPECIAL.each(&method(:emit))
+          end
+
+          # Values to mutate to
+          #
+          # @return [Array]
+          def values
+            original = children.first
+
+            [0.0, 1.0, -original]
+          end
+        end # Float
+      end # Literal
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,52 @@
+module Mutest
+  class Mutator
+    class Node
+      class Literal
+        # Mutator for hash literals
+        class Hash < self
+          handle(:hash)
+
+          private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          def dispatch
+            emit_singletons
+            emit_type
+            mutate_body
+          end
+
+          # Mutate body
+          #
+          # @return [undefined]
+          def mutate_body
+            children.each_index do |index|
+              mutate_child(index)
+              dup_children = children.dup
+              dup_children.delete_at(index)
+              emit_type(*dup_children)
+            end
+          end
+
+          # Mutator for hash pairs
+          class Pair < Node
+            handle(:pair)
+
+            children :key, :value
+
+            private
+
+            # Emit mutations
+            #
+            # @return [undefined]
+            def dispatch
+              emit_key_mutations
+              emit_value_mutations
+            end
+          end # Pair
+        end # Hash
+      end # Literal
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,20 @@
+module Mutest
+  class Mutator
+    class Node
+      class Literal
+        # Mutator for nil literals
+        class Nil < self
+          handle(:nil)
+
+          private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          def dispatch
+          end
+        end # Nil
+      end # Literal
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,38 @@
+module Mutest
+  class Mutator
+    class Node
+      class Literal
+        # Abstract literal range mutator
+        class Range < self
+          MAP = {
+            irange: :erange,
+            erange: :irange
+          }.freeze
+
+          children :lower_bound, :upper_bound
+
+          handle(*MAP.keys)
+
+          private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          def dispatch
+            emit_singletons
+            emit_inverse
+            emit_lower_bound_mutations
+            emit_upper_bound_mutations
+          end
+
+          # Inverse node
+          #
+          # @return [Parser::AST::Node]
+          def emit_inverse
+            emit(s(MAP.fetch(node.type), *children))
+          end
+        end # Range
+      end # Literal
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,76 @@
+module Mutest
+  class Mutator
+    class Node
+      class Literal < self
+        # Mutator for regexp literals
+        class Regex < self
+          handle(:regexp)
+
+          # No input can ever be matched with this
+          NULL_REGEXP_SOURCE = 'nomatch\A'.freeze
+
+          private
+
+          # Original regexp options
+          #
+          # @return [Parser::AST::Node]
+          def options
+            children.last
+          end
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          def dispatch
+            mutate_body
+            emit_singletons unless parent_node
+            children.each_with_index do |child, index|
+              mutate_child(index) unless n_str?(child)
+            end
+            emit_type(options)
+            emit_type(s(:str, NULL_REGEXP_SOURCE), options)
+          end
+
+          # Mutate regexp body
+          #
+          # @note will only mutate parts of regexp body if the
+          # body is composed of only strings. Regular expressions
+          # with interpolation are skipped
+          #
+          # @return [undefined]
+          def mutate_body
+            return unless body.all?(&method(:n_str?))
+            return unless AST::Regexp.supported?(body_expression)
+
+            mutate(body_ast).each do |mutation|
+              source = AST::Regexp.to_expression(mutation).to_s
+              emit_type(s(:str, source), options)
+            end
+          end
+
+          # AST representation of regexp body
+          #
+          # @return [Parser::AST::Node]
+          def body_ast
+            AST::Regexp.to_ast(body_expression)
+          end
+
+          # Expression representation of regexp body
+          #
+          # @return [Regexp::Expression]
+          def body_expression
+            AST::Regexp.parse(body.map(&:children).join)
+          end
+          memoize :body_expression
+
+          # Children of regexp node which compose regular expression source
+          #
+          # @return [Array<Parser::AST::Node>]
+          def body
+            children.slice(0...-1)
+          end
+        end # Regex
+      end # Literal
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,21 @@
+module Mutest
+  class Mutator
+    class Node
+      class Literal
+        # Mutator for string literals
+        class String < self
+          handle(:str)
+
+          private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          def dispatch
+            emit_singletons
+          end
+        end # String
+      end # Literal
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,26 @@
+module Mutest
+  class Mutator
+    class Node
+      class Literal < self
+        # Mutator for symbol literals
+        class Symbol < self
+          handle(:sym)
+
+          children :value
+
+          PREFIX = '__mutest__'.freeze
+
+          private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          def dispatch
+            emit_singletons
+            mutate_with(Util::Symbol, value, &method(:emit_type))
+          end
+        end # Symbol
+      end # Literal
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,21 @@
+module Mutest
+  class Mutator
+    class Node
+      # Mutation emitter to handle multiple assignment nodes
+      class MultipleAssignment < self
+        handle(:masgn)
+
+        children :left, :right
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_singletons
+        end
+      end # MultipleAssignment
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,22 @@
+module Mutest
+  class Mutator
+    class Node
+      # Emitter for perl style match current line node
+      class MatchCurrentLine < self
+        handle :match_current_line
+
+        children :regexp
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_singletons
+          emit_regexp_mutations
+        end
+      end # MatchCurrentLine
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,21 @@
+module Mutest
+  class Mutator
+    class Node
+      # Mutator for multiple assignment left hand side nodes
+      class MLHS < self
+        handle(:mlhs)
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          mutate_single_child do |_child, index|
+            delete_child(index)
+          end
+        end
+      end # MLHS
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,54 @@
+module Mutest
+  class Mutator
+    class Node
+      module NamedValue
+        # Mutation emitter to handle named value access nodes
+        class Access < Node
+          handle(:gvar, :cvar, :lvar, :self)
+
+          private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          def dispatch
+            emit_singletons
+          end
+
+          # Named value access emitter for instance variables
+          class Ivar < Access
+            NAME_RANGE = (1..-1).freeze
+
+            handle(:ivar)
+
+            children :name
+
+            # Emit mutations
+            #
+            # @return [undefined]
+            def dispatch
+              emit_attribute_read
+              super()
+            end
+
+            private
+
+            # Emit instance variable as attribute send
+            #
+            # @return [undefined]
+            def emit_attribute_read
+              emit(s(:send, nil, attribute_name))
+            end
+
+            # Variable name without leading '@'
+            #
+            # @return [Symbol]
+            def attribute_name
+              name.slice(NAME_RANGE).to_sym
+            end
+          end # Ivar
+        end # Access
+      end # NamedValue
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,42 @@
+module Mutest
+  class Mutator
+    class Node
+      module NamedValue
+        # Mutation emitter to handle constant assignment nodes
+        class ConstantAssignment < Node
+          children :cbase, :name, :value
+
+          handle :casgn
+
+          private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          def dispatch
+            mutate_name
+            return unless value # op asgn
+            emit_value_mutations
+            emit_remove_const
+          end
+
+          # Emit remove_const
+          #
+          # @return [undefined]
+          def emit_remove_const
+            emit(s(:send, cbase, :remove_const, s(:sym, name)))
+          end
+
+          # Emit name mutations
+          #
+          # @return [undefined]
+          def mutate_name
+            mutate_with(Util::Symbol, name) do |name|
+              emit_name(name.upcase)
+            end
+          end
+        end # ConstantAssignment
+      end # NamedValue
+    end # Node
+  end # Mutator
+end # Mutest