mutant 0.5.17 → 0.5.18

data/lib/mutant/matcher/namespace.rb

@@ -36,7 +36,7 @@ module Mutant
       # @api private
       #
       def pattern
-        /\A#{Regexp.escape(namespace.name)}(?:::)?/
+        /\A#{Regexp.escape(namespace)}(?:::)?/
       end
       memoize :pattern
 
@@ -87,12 +87,11 @@ It raised an error: #{exception.inspect} fix your lib!
       #
       def emit_scope(scope)
         name = self.class.scope_name(scope)
-        # FIXME: Fix nokogiri to return a string here
         unless name.nil? or name.kind_of?(String)
           $stderr.puts <<-MESSAGE
 WARNING:
-#{scope.class}#name did not return a string or nil.
-Fix your lib!
+#{scope.class}#name from: #{scope.inspect} did not return a String or nil.
+Fix your lib to support normal ruby semantics!
           MESSAGE
           return
         end

data/lib/mutant/meta.rb

@@ -0,0 +1,31 @@
+module Mutant
+  # Namespace for mutant metadata
+  module Meta
+
+    require 'mutant/meta/example'
+    require 'mutant/meta/example/dsl'
+
+    # Mutation example
+    class Example
+
+      ALL = []
+
+      # Add example
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def self.add(&block)
+        ALL << DSL.run(block)
+      end
+
+      Pathname.glob(Pathname.new(__FILE__).parent.parent.parent.join('meta', '**/*.rb'))
+        .sort
+        .each(&method(:require))
+      ALL.freeze
+
+    end # Example
+
+  end # Meta
+end # Mutant

data/lib/mutant/meta/example.rb

@@ -0,0 +1,152 @@
+# encoding: UTF-8
+
+module Mutant
+  module Meta
+    class Example
+      include Adamantium, Concord::Public.new(:node, :mutations)
+
+      # Return a verification instance
+      #
+      # @return [Verification]
+      #
+      # @api private
+      #
+      def verification
+        Verification.new(self, generated)
+      end
+
+      # Return generated mutations
+      #
+      # @return [Emumerable<Parser::AST::Node>]
+      #
+      # @api private
+      #
+      def generated
+        Mutant::Mutator.each(node).to_a
+      end
+      memoize :generated
+
+      # Example verification
+      class Verification
+        include Adamantium::Flat, Concord.new(:example, :generated)
+
+        # Test if mutation was verified successfully
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        #
+        def success?
+          unparser.success? && missing.empty? && unexpected.empty?
+        end
+
+        # Return error report
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def error_report
+          unless unparser.success?
+            return unparser.report
+          end
+          mutation_report
+        end
+
+      private
+
+        # Return unexpected mutationso
+        #
+        # @return [Array<Parser::AST::Node>]
+        #
+        # @api private
+        #
+        def unexpected
+          generated - example.mutations
+        end
+        memoize :unexpected
+
+        # Return mutation report
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def mutation_report
+          original_node = example.node
+          [
+            'Original-AST:',
+            original_node.inspect,
+            'Original-Source:',
+            Unparser.unparse(original_node),
+            *missing_report,
+            *unexpected_report
+          ].join("\n======\n")
+        end
+
+        # Return missing report
+        #
+        # @return [Array, nil]
+        #
+        # @api private
+        #
+        def missing_report
+          if missing.any?
+            ['Missing mutations:', missing.map(&method(:format_mutation)).join("\n-----\n")]
+          end
+        end
+
+        # Return unexpected report
+        #
+        # @return [Array, nil]
+        #
+        # @api private
+        #
+        def unexpected_report
+          if unexpected.any?
+            [
+              'Unexpected mutations:',
+              unexpected.map(&method(:format_mutation)).join("\n-----\n")
+            ]
+          end
+        end
+
+        # Format mutation
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def format_mutation(node)
+          [
+            node.inspect,
+            Unparser.unparse(node)
+          ].join("\n")
+        end
+
+        # Return missing mutationso
+        #
+        # @return [Array<Parser::AST::Node>]
+        #
+        # @api private
+        #
+        def missing
+          example.mutations - generated
+        end
+        memoize :missing
+
+        # Return unparser verifier
+        #
+        # @return [Unparser::CLI::Source]
+        #
+        # @api private
+        #
+        def unparser
+          Unparser::CLI::Source::Node.new(Unparser::Preprocessor.run(example.node))
+        end
+        memoize :unparser
+
+      end # Verification
+    end # Example
+  end # Meta
+end # Mutant

data/lib/mutant/meta/example/dsl.rb

@@ -0,0 +1,105 @@
+module Mutant
+  module Meta
+    class Example
+
+      # Example DSL
+      class DSL
+        include NodeHelpers
+
+        # Run DSL on block
+        #
+        # @return [Example]
+        #
+        # @api private
+        #
+        def self.run(block)
+          instance = new
+          instance.instance_eval(&block)
+          instance.example
+        end
+
+        # Initialize DSL context
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def initialize
+          @source = nil
+          @expected = []
+        end
+
+        # Return example
+        #
+        # @return [Example]
+        #
+        # @raise [RuntimeError]
+        #   in case example cannot be build
+        #
+        # @api private
+        #
+        def example
+          raise 'source not defined' unless @source
+          Example.new(@source, @expected)
+        end
+
+      private
+
+        # Set original source
+        #
+        # @param [String,Parser::AST::Node] input
+        #
+        # @return [self]
+        #
+        def source(input)
+          raise 'source already defined' if @source
+          @source = node(input)
+
+          self
+        end
+
+        # Add expected mutation
+        #
+        # @param [String,Parser::AST::Node] input
+        #
+        # @return [self]
+        #
+        def mutation(input)
+          node = node(input)
+          if @expected.include?(node)
+            raise "Node for input: #{input.inspect} is already expected"
+          end
+          @expected << node
+
+          self
+        end
+
+        # Helper method to coerce input to node
+        #
+        # @param [String,Parser::AST::Node] input
+        #
+        # @return [Parser::AST::Node]
+        #
+        # @raise [RuntimeError]
+        #   in case input cannot be coerced
+        #
+        # @api private
+        #
+        def node(input)
+          node =
+            case input
+            when String
+              Parser::CurrentRuby.parse(input)
+            when Parser::AST::Node
+              input
+            else
+              raise "Cannot coerce to node: #{source.inspect}"
+            end
+
+          Unparser::Preprocessor.run(node)
+        end
+
+      end # DSL
+    end # Example
+  end # Meta
+end # Mutant

data/lib/mutant/mutator/node.rb

@@ -96,7 +96,7 @@ module Mutant
       #
       def emit_children_mutations
         Mutator::Util::Array.each(children, self) do |children|
-          emit_self(*children)
+          emit_type(*children)
         end
       end
 
@@ -136,7 +136,7 @@ module Mutant
       def delete_child(index)
         dup_children = children.dup
         dup_children.delete_at(index)
-        emit_self(*dup_children)
+        emit_type(*dup_children)
       end
 
       # Emit updated child
@@ -151,7 +151,7 @@ module Mutant
       def emit_child_update(index, node)
         new_children = children.dup
         new_children[index] = node
-        emit_self(*new_children)
+        emit_type(*new_children)
       end
 
       # Emit a new AST node with same class as wrapped node
@@ -162,7 +162,7 @@ module Mutant
       #
       # @api private
       #
-      def emit_self(*children)
+      def emit_type(*children)
         emit(new_self(*children))
       end
 
@@ -196,7 +196,7 @@ module Mutant
       #
       def emit_values(values)
         values.each do |value|
-          emit_self(value)
+          emit_type(value)
         end
       end
 
@@ -221,7 +221,7 @@ module Mutant
       # @api private
       #
       def asgn_left?
-        OP_ASSIGN.include?(parent_type) && parent.left.equal?(node)
+        OP_ASSIGN.include?(parent_type) && parent.node.children.first.equal?(node)
       end
 
     end # Node

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

@@ -32,7 +32,7 @@ module Mutant
             dup_children = children.dup
             dup_children.delete_at(index)
             dup_children.insert(index, *child.children)
-            emit_self(*dup_children)
+            emit_type(*dup_children)
           end
         end
 

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

@@ -41,7 +41,7 @@ module Mutant
           when 1
             emit(children.first)
           else
-            emit_self(*children)
+            emit_type(*children)
           end
         end
 

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

@@ -19,7 +19,7 @@ module Mutant
         #
         def dispatch
           emit_nil unless parent_type == :const
-          emit_self(nil, *children.drop(1))
+          emit_type(nil, *children.drop(1))
           children.each_with_index do |child, index|
             mutate_child(index) if child.kind_of?(Parser::AST::Node)
           end

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

@@ -33,9 +33,9 @@ module Mutant
         #
         def mutate_condition
           emit_condition_mutations
-          emit_self(n_not(condition), if_branch, else_branch) unless condition.type == :match_current_line
-          emit_self(N_TRUE,  if_branch, else_branch)
-          emit_self(N_FALSE, if_branch, else_branch)
+          emit_type(n_not(condition), if_branch, else_branch) unless condition.type == :match_current_line
+          emit_type(N_TRUE,  if_branch, else_branch)
+          emit_type(N_FALSE, if_branch, else_branch)
         end
 
         # Emit if branch mutations
@@ -45,10 +45,10 @@ module Mutant
         # @api private
         #
         def mutate_if_branch
-          emit_self(condition, else_branch, nil) if else_branch
+          emit_type(condition, else_branch, nil) if else_branch
           if if_branch
             emit_if_branch_mutations
-            emit_self(condition, if_branch, nil)
+            emit_type(condition, if_branch, nil)
           end
         end
 
@@ -61,7 +61,7 @@ module Mutant
         def mutate_else_branch
           if else_branch
             emit_else_branch_mutations
-            emit_self(condition, nil, else_branch)
+            emit_type(condition, nil, else_branch)
           end
         end
 

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

@@ -19,7 +19,7 @@ module Mutant
           #
           def dispatch
             emit_nil
-            emit_self
+            emit_type
             mutate_body
             if children.one?
               emit(children.first)
@@ -36,7 +36,7 @@ module Mutant
             children.each_index do |index|
               dup_children = children.dup
               dup_children.delete_at(index)
-              emit_self(*dup_children)
+              emit_type(*dup_children)
               mutate_child(index)
             end
           end