mutest 0.0.1 → 0.0.2

data/lib/mutest/meta/example/verification.rb

@@ -0,0 +1,85 @@
+module Mutest
+  module Meta
+    class Example
+      # Example verification
+      class Verification
+        include Adamantium::Flat, Concord.new(:example, :mutations)
+
+        # Test if mutation was verified successfully
+        #
+        # @return [Boolean]
+        def success?
+          missing.empty? && unexpected.empty? && no_diffs.empty?
+        end
+
+        # Error report
+        #
+        # @return [String]
+        def error_report
+          fail 'no error report on successful validation' if success?
+
+          YAML.dump(
+            'file'            => example.file,
+            'original_ast'    => example.node.inspect,
+            'original_source' => example.source,
+            'missing'         => format_mutations(missing),
+            'unexpected'      => format_mutations(unexpected),
+            'no_diff'         => no_diff_report
+          )
+        end
+
+        private
+
+        # Unexpected mutations
+        #
+        # @return [Array<Parser::AST::Node>]
+        def unexpected
+          mutations.map(&:node) - example.expected
+        end
+        memoize :unexpected
+
+        # Mutations with no diff to original
+        #
+        # @return [Enumerable<Mutation>]
+        def no_diffs
+          mutations.select { |mutation| mutation.source.eql?(example.source) }
+        end
+        memoize :no_diffs
+
+        # Mutation report
+        #
+        # @param [Array<Parser::AST::Node>] nodes
+        #
+        # @return [Array<Hash>]
+        def format_mutations(nodes)
+          nodes.map do |node|
+            {
+              'node'   => node.inspect,
+              'source' => Unparser.unparse(node)
+            }
+          end
+        end
+
+        # No diff mutation report
+        #
+        # @return [Array, nil]
+        def no_diff_report
+          no_diffs.map do |mutation|
+            {
+              'node'   => mutation.node.inspect,
+              'source' => mutation.source
+            }
+          end
+        end
+
+        # Missing mutations
+        #
+        # @return [Array<Parser::AST::Node>]
+        def missing
+          example.expected - mutations.map(&:node)
+        end
+        memoize :missing
+      end # Verification
+    end # Example
+  end # Meta
+end # Mutest

data/lib/mutest/mutation.rb

@@ -0,0 +1,101 @@
+module Mutest
+  # Represent a mutated node with its subject
+  class Mutation
+    include AbstractType, Adamantium::Flat
+    include Concord::Public.new(:subject, :node)
+
+    CODE_DELIMITER = "\0".freeze
+    CODE_RANGE     = (0..4).freeze
+
+    # Identification string
+    #
+    # @return [String]
+    def identification
+      "#{self.class::SYMBOL}:#{subject.identification}:#{code}"
+    end
+    memoize :identification
+
+    # Mutation code
+    #
+    # @return [String]
+    def code
+      sha1[CODE_RANGE]
+    end
+    memoize :code
+
+    # Normalized mutation source
+    #
+    # @return [String]
+    def source
+      Unparser.unparse(node)
+    end
+    memoize :source
+
+    # Normalized original source
+    #
+    # @return [String]
+    def original_source
+      subject.source
+    end
+
+    # Test if mutation is killed by test reports
+    #
+    # @param [Result::Test] test_result
+    #
+    # @return [Boolean]
+    def self.success?(test_result)
+      self::TEST_PASS_SUCCESS.equal?(test_result.passed)
+    end
+
+    # Insert mutated node
+    #
+    # @param kernel [Kernel]
+    #
+    # @return [self]
+    def insert(kernel)
+      subject.prepare
+      Loader.call(
+        binding: TOPLEVEL_BINDING,
+        kernel:  kernel,
+        node:    root,
+        subject: subject
+      )
+      self
+    end
+
+    private
+
+    # SHA1 sum of source and subject identification
+    #
+    # @return [String]
+    def sha1
+      Digest::SHA1.hexdigest(subject.identification + CODE_DELIMITER + source)
+    end
+    memoize :sha1
+
+    # Mutated root node
+    #
+    # @return [Parser::AST::Node]
+    def root
+      subject.context.root(node)
+    end
+
+    # Evil mutation that should case mutations to fail tests
+    class Evil < self
+      SYMBOL            = 'evil'.freeze
+      TEST_PASS_SUCCESS = false
+    end # Evil
+
+    # Neutral mutation that should not cause mutations to fail tests
+    class Neutral < self
+      SYMBOL            = 'neutral'.freeze
+      TEST_PASS_SUCCESS = true
+    end # Neutral
+
+    # Noop mutation, special case of neutral
+    class Noop < Neutral
+      SYMBOL            = 'noop'.freeze
+      TEST_PASS_SUCCESS = true
+    end # Noop
+  end # Mutation
+end # Mutest

data/lib/mutest/mutator.rb

@@ -0,0 +1,117 @@
+module Mutest
+  # Generator for mutations
+  class Mutator
+    REGISTRY = Registry.new
+
+    include Adamantium::Flat,
+            Concord.new(:input, :filter, :parent),
+            AbstractType,
+            Procto.call(:output)
+
+    # Lookup and invoke dedicated AST mutator
+    #
+    # @param node [Parser::AST::Node]
+    # @param parent [nil,Mutest::Mutator::Node]
+    #
+    # @return [Set<Parser::AST::Node>]
+    #
+    # :reek:LongParameterList
+    def self.mutate(node, filter = ->(_) {}, parent = nil)
+      self::REGISTRY.lookup(node.type).call(node, filter, parent)
+    end
+
+    # Register node class handler
+    #
+    # @return [undefined]
+    def self.handle(*types)
+      types.each do |type|
+        self::REGISTRY.register(type, self)
+      end
+    end
+    private_class_method :handle
+
+    # Return output
+    #
+    # @return [Set<Parser::AST::Node>]
+    attr_reader :output
+
+    private
+
+    # Initialize object
+    #
+    # @param [Object] input
+    # @param [#call] mutation filter
+    # @param [Object] parent
+    # @param [#call(node)] block
+    #
+    # @return [undefined]
+    def initialize(_input, _filter, _parent = nil)
+      super
+
+      @output = Set.new
+
+      dispatch unless disabled?
+    end
+
+    def disabled?
+      filter.call(input)
+    end
+
+    # Test if generated object is not guarded from emitting
+    #
+    # @param [Object] object
+    #
+    # @return [Boolean]
+    def new?(object)
+      !object.eql?(input)
+    end
+
+    # Dispatch node generations
+    #
+    # @return [undefined]
+    abstract_method :dispatch
+
+    # Emit generated mutation if object is not equivalent to input
+    #
+    # @param [Object] object
+    #
+    # @return [undefined]
+    def emit(object)
+      return unless new?(object)
+
+      output << object
+    end
+
+    # Shortcut to create a new unfrozen duplicate of input
+    #
+    # @return [Object]
+    def dup_input
+      input.dup
+    end
+
+    # Mutate child nodes within source path
+    #
+    # @return [Set<Parser::AST::Node>]
+    def mutate(node, parent = nil)
+      self.class.mutate(node, filter, parent)
+    end
+
+    # Run input with mutator
+    #
+    # @return [undefined]
+    def run(mutator)
+      mutate_with(mutator, input)
+    end
+
+    # Mutate nodes using a specific mutator class
+    #
+    # @yield [Object] value emitted by provided mutator
+    #
+    # @return [undefined]
+    def mutate_with(mutator, nodes, &block)
+      block ||= method(:emit)
+
+      mutator.call(nodes, filter).each(&block)
+    end
+  end # Mutator
+end # Mutest

data/lib/mutest/mutator/node.rb

@@ -0,0 +1,166 @@
+module Mutest
+  # Generator for mutations
+  class Mutator
+    # Abstract base class for node mutators
+    class Node < self
+      include AbstractType, Unparser::Constants
+      include AST::NamedChildren, AST::NodePredicates, AST::Sexp, AST::Nodes
+
+      TAUTOLOGY = ->(_input) { true }
+
+      # Helper to define a named child
+      #
+      # @param [Parser::AST::Node] node
+      #
+      # @param [Fixnum] index
+      #
+      # @return [undefined]
+      def self.define_named_child(name, index)
+        super
+
+        define_method(:"emit_#{name}_mutations") do |&block|
+          mutate_child(index, &block)
+        end
+
+        define_method(:"emit_#{name}") do |node|
+          emit_child_update(index, node)
+        end
+      end
+      private_class_method :define_named_child
+
+      private
+
+      # Node to mutate
+      #
+      # @return [Parser::AST::Node]
+      alias_method :node, :input
+
+      # Duplicate of original
+      #
+      # @return [Parser::AST::Node]
+      alias_method :dup_node, :dup_input
+
+      # Original nodes children
+      #
+      # @return [Array<Parser::AST::Node>]
+      def children
+        node.children
+      end
+
+      # Dispatch on child index
+      #
+      # @param [Fixnum] index
+      #
+      # @return [undefined]
+      def mutate_child(index, &block)
+        block ||= TAUTOLOGY
+        mutate(children.fetch(index), self).each do |mutation|
+          next unless block.call(mutation)
+          emit_child_update(index, mutation)
+        end
+      end
+
+      # Emit delete child mutation
+      #
+      # @param [Fixnum] index
+      #
+      # @return [undefined]
+      def delete_child(index)
+        dup_children = children.dup
+        dup_children.delete_at(index)
+        emit_type(*dup_children)
+      end
+
+      # Emit updated child
+      #
+      # @param [Fixnum] index
+      # @param [Parser::AST::Node] node
+      #
+      # @return [undefined]
+      def emit_child_update(index, node)
+        new_children = children.dup
+        new_children[index] = node
+        emit_type(*new_children)
+      end
+
+      # Emit a new AST node with same class as wrapped node
+      #
+      # @param [Array<Parser::AST::Node>] children
+      #
+      # @return [undefined]
+      def emit_type(*children)
+        emit(::Parser::AST::Node.new(node.type, children))
+      end
+
+      # Emit singleton literals
+      #
+      # @return [undefined]
+      def emit_singletons
+        emit_nil
+        emit_self
+      end
+
+      # Emit a literal self
+      #
+      # @return [undefined]
+      def emit_self
+        emit(N_SELF)
+      end
+
+      # Emit a literal nil
+      #
+      # @return [undefined]
+      def emit_nil
+        emit(N_NIL) unless asgn_left?
+      end
+
+      # Parent node
+      #
+      # @return [Parser::AST::Node] node
+      #   if parent with node is present
+      #
+      # @return [nil]
+      #   otherwise
+      def parent_node
+        parent.node if parent
+      end
+
+      # Parent type
+      #
+      # @return [Symbol] type
+      #   if parent with type is present
+      #
+      # @return [nil]
+      #   otherwise
+      def parent_type
+        parent_node.type if parent_node
+      end
+
+      # Test if the node is the left of an or_asgn or op_asgn
+      #
+      # @return [Boolean]
+      def asgn_left?
+        AST::Types::OP_ASSIGN.include?(parent_type) && parent.node.children.first.equal?(node)
+      end
+
+      # Children indices
+      #
+      # @param [Range] range
+      #
+      # @return [Enumerable<Fixnum>]
+      def children_indices(range)
+        range.begin.upto(children.length + range.end)
+      end
+
+      # Emit single child mutation
+      #
+      # @return [undefined]
+      def mutate_single_child
+        children.each_with_index do |child, index|
+          mutate_child(index)
+          yield child, index unless children.one?
+        end
+      end
+    end # Node
+  end # Mutator
+end # Mutest