mutest 0.0.1 → 0.0.2

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

@@ -0,0 +1,34 @@
+module Mutest
+  class Mutator
+    class Node
+      # Mutator for resbody nodes
+      class Resbody < self
+        handle(:resbody)
+
+        children :captures, :assignment, :body
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_assignment(nil)
+          emit_body_mutations if body
+          mutate_captures
+        end
+
+        # Mutate captures
+        #
+        # @return [undefined]
+        def mutate_captures
+          return unless captures
+          mutate_with(Util::Array::Element, captures.children) do |matchers|
+            next if matchers.any?(&method(:n_nil?))
+            emit_captures(s(:array, *matchers))
+          end
+        end
+      end # Resbody
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,69 @@
+module Mutest
+  class Mutator
+    class Node
+      # Mutator for rescue nodes
+      class Rescue < self
+        handle :rescue
+
+        children :body
+
+        define_named_child(:else_body, -1)
+
+        RESCUE_INDICES = (1..-2).freeze
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          mutate_body
+          mutate_rescue_bodies
+          mutate_else_body
+        end
+
+        private
+
+        # Mutate child by name
+        #
+        # @return [undefined]
+        def mutate_rescue_bodies
+          children_indices(RESCUE_INDICES).each do |index|
+            mutate_child(index)
+            resbody_body = AST::Meta::Resbody.new(children.fetch(index)).body
+            emit_concat(resbody_body) if resbody_body
+          end
+        end
+
+        # Emit concatenation with body
+        #
+        # @param [Parser::AST::Node] child
+        #
+        # @return [undefined]
+        def emit_concat(child)
+          if body
+            emit(s(:begin, body, child))
+          else
+            emit(child)
+          end
+        end
+
+        # Emit body mutations
+        #
+        # @return [undefined]
+        def mutate_body
+          return unless body
+          emit_body_mutations
+          emit(body)
+        end
+
+        # Emit else body mutations
+        #
+        # @return [undefined]
+        def mutate_else_body
+          return unless else_body
+          emit_else_body_mutations
+          emit_concat(else_body)
+        end
+      end # Rescue
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,24 @@
+module Mutest
+  class Mutator
+    class Node
+      # Mutator for return statements
+      class Return < self
+        handle(:return)
+
+        children :value
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_singletons
+          return unless value
+          emit(value)
+          emit_value_mutations
+        end
+      end # Return
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,270 @@
+module Mutest
+  class Mutator
+    class Node
+      # Namespace for send mutators
+      # rubocop:disable ClassLength
+      class Send < self
+        include AST::Types
+
+        handle(:send)
+
+        children :receiver, :selector
+
+        SELECTOR_REPLACEMENTS = IceNine.deep_freeze(
+          __send__:      %i[public_send],
+          :[] =>         %i[at fetch key?],
+          :< =>          %i[== <= eql? equal?],
+          :<= =>         %i[< == eql? equal?],
+          :== =>         %i[eql? equal?],
+          :=== =>        %i[kind_of?],
+          :> =>          %i[== >= eql? equal?],
+          :>= =>         %i[> == eql? equal?],
+          '=~':          %i[match?],
+          at:            %i[fetch key?],
+          eql?:          %i[equal?],
+          fetch:         %i[key?],
+          first:         %i[last],
+          flat_map:      %i[map],
+          grep_v:        %i[grep],
+          grep:          %i[grep_v],
+          gsub:          %i[sub],
+          is_a?:         %i[instance_of?],
+          kind_of?:      %i[instance_of?],
+          last:          %i[first],
+          map:           %i[each],
+          match:         %i[match?],
+          method:        %i[public_method],
+          pop:           %i[last],
+          reject:        %i[select],
+          reverse_each:  %i[each],
+          reverse_map:   %i[map each],
+          reverse_merge: %i[merge],
+          sample:        %i[first last],
+          select:        %i[reject],
+          send:          %i[public_send __send__],
+          shift:         %i[first],
+          to_a:          %i[to_ary to_set],
+          to_h:          %i[to_hash],
+          to_i:          %i[to_int],
+          to_s:          %i[to_str],
+          values_at:     %i[fetch_values]
+        )
+
+        RECEIVER_SELECTOR_REPLACEMENTS = IceNine.deep_freeze(
+          Date: {
+            parse: %i[jd civil strptime iso8601 rfc3339 xmlschema rfc2822 rfc822 httpdate jisx0301]
+          }
+        )
+
+        private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_singletons
+          if meta.index_assignment?
+            run(Index::Assign)
+          else
+            non_index_dispatch
+          end
+        end
+
+        # Perform non index dispatch
+        #
+        # @return [undefined]
+        def non_index_dispatch
+          if meta.binary_method_operator?
+            run(Binary)
+          elsif meta.attribute_assignment?
+            run(AttributeAssignment)
+          else
+            normal_dispatch
+          end
+        end
+
+        # AST metadata for node
+        #
+        # @return [AST::Meta::Send]
+        def meta
+          AST::Meta::Send.new(node)
+        end
+        memoize :meta
+
+        # Arguments being send
+        #
+        # @return [Enumerable<Parser::AST::Node>]
+        alias_method :arguments, :remaining_children
+        private :arguments
+
+        # Perform normal, non special case dispatch
+        #
+        # @return [undefined]
+        def normal_dispatch
+          emit_naked_receiver
+          emit_selector_replacement
+          emit_selector_specific_mutations
+          emit_argument_propagation
+          emit_receiver_selector_mutations
+          mutate_receiver
+          mutate_arguments
+        end
+
+        # Emit mutations which only correspond to one selector
+        #
+        # @return [undefined]
+        def emit_selector_specific_mutations
+          emit_const_get_mutation
+          emit_integer_mutation
+          emit_array_mutation
+          emit_dig_mutation
+          emit_double_negation_mutation
+          emit_lambda_mutation
+          emit_drop_mutation
+        end
+
+        # Emit selector mutations specific to top level constants
+        #
+        # @return [undefined]
+        def emit_receiver_selector_mutations
+          return unless meta.receiver_possible_top_level_const?
+
+          RECEIVER_SELECTOR_REPLACEMENTS
+            .fetch(receiver.children.last, EMPTY_HASH)
+            .fetch(selector, EMPTY_ARRAY)
+            .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)`
+        # - Mutates `foo.dig(a)` to `foo.fetch(a)`
+        #
+        # @return [undefined]
+        def emit_dig_mutation
+          return if !selector.equal?(:dig) || arguments.none?
+
+          head, *tail = arguments
+
+          fetch_mutation = s(:send, receiver, :fetch, head)
+
+          return emit(fetch_mutation) if tail.empty?
+
+          emit(s(:send, fetch_mutation, :dig, *tail))
+        end
+
+        # Emit mutation `foo[n..-1]` -> `foo.drop(n)`
+        #
+        # @return [undefined]
+        def emit_drop_mutation
+          return if !selector.equal?(:[]) || !arguments.one? || !n_irange?(arguments.first)
+
+          start, ending = *arguments.first
+
+          return unless ending.eql?(s(:int, -1))
+
+          emit(s(:send, receiver, :drop, start))
+        end
+
+        # Emit mutation from `to_i` to `Integer(...)`
+        #
+        # @return [undefined]
+        def emit_integer_mutation
+          return unless selector.equal?(:to_i)
+
+          emit(s(:send, nil, :Integer, receiver))
+        end
+
+        # Emit mutation from `Array(a)` to `[a]`
+        #
+        # @return [undefined]
+        def emit_array_mutation
+          return unless selector.equal?(:Array) && receiver.nil?
+
+          emit(s(:array, *arguments))
+        end
+
+        # Emit mutation from `const_get` to const literal
+        #
+        # @return [undefined]
+        def emit_const_get_mutation
+          return unless selector.equal?(:const_get) && n_sym?(arguments.first)
+
+          emit(s(:const, receiver, AST::Meta::Symbol.new(arguments.first).name))
+        end
+
+        # Emit selector replacement
+        #
+        # @return [undefined]
+        def emit_selector_replacement
+          SELECTOR_REPLACEMENTS.fetch(selector, EMPTY_ARRAY).each(&method(:emit_selector))
+        end
+
+        # Emit naked receiver mutation
+        #
+        # @return [undefined]
+        def emit_naked_receiver
+          emit(receiver) if receiver
+        end
+
+        # Mutate arguments
+        #
+        # @return [undefined]
+        def mutate_arguments
+          emit_type(receiver, selector)
+          remaining_children_with_index.each do |_node, index|
+            mutate_child(index)
+            delete_child(index)
+          end
+        end
+
+        # Emit argument propagation
+        #
+        # @return [undefined]
+        def emit_argument_propagation
+          node = arguments.first
+          emit(node) if arguments.one? && !NOT_STANDALONE.include?(node.type)
+        end
+
+        # Emit receiver mutations
+        #
+        # @return [undefined]
+        def mutate_receiver
+          return unless receiver
+          emit_implicit_self
+          emit_receiver_mutations do |node|
+            !n_nil?(node)
+          end
+        end
+
+        # Emit implicit self mutation
+        #
+        # @return [undefined]
+        def emit_implicit_self
+          emit_receiver(nil) if n_self?(receiver) && !(
+            KEYWORDS.include?(selector)         ||
+            METHOD_OPERATORS.include?(selector) ||
+            meta.attribute_assignment?
+          )
+        end
+      end # Send
+    end # Node
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/node/send/attribute_assignment.rb

@@ -0,0 +1,39 @@
+module Mutest
+  class Mutator
+    class Node
+      class Send
+        # Mutator for attribute assignments
+        class AttributeAssignment < self
+          ATTRIBUTE_RANGE = (0..-2).freeze
+          private_constant(*constants(false))
+
+          private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          def dispatch
+            normal_dispatch
+            emit_attribute_read
+          end
+
+          # Mutate arguments
+          #
+          # @return [undefined]
+          def mutate_arguments
+            remaining_children_indices.each do |index|
+              mutate_child(index)
+            end
+          end
+
+          # Emit attribute read
+          #
+          # @return [undefined]
+          def emit_attribute_read
+            emit_type(receiver, selector[ATTRIBUTE_RANGE].to_sym)
+          end
+        end # AttributeAssignment
+      end # Send
+    end # Node
+  end # Mutator
+end # Mutest

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

@@ -0,0 +1,45 @@
+module Mutest
+  class Mutator
+    class Node
+      class Send
+        # Mutator for sends that correspond to a binary operator
+        class Binary < self
+          children :left, :operator, :right
+
+          private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          def dispatch
+            emit(left)
+            emit_left_mutations
+            emit_selector_replacement
+            emit(right)
+            emit_right_mutations
+            emit_not_equality_mutations
+          end
+
+          # Emit mutations for `!=`
+          #
+          # @return [undefined]
+          def emit_not_equality_mutations
+            return unless operator.equal?(:'!=')
+
+            emit_not_equality_mutation(:eql?)
+            emit_not_equality_mutation(:equal?)
+          end
+
+          # Emit negated method sends with specified operator
+          #
+          # @param new_operator [Symbol] selector to be negated
+          #
+          # @return [undefined]
+          def emit_not_equality_mutation(new_operator)
+            emit(n_not(s(:send, left, new_operator, right)))
+          end
+        end # Binary
+      end # Send
+    end # Node
+  end # Mutator
+end # Mutest