mutant 0.8.10 → 0.8.11

data/lib/mutant/isolation/none.rb

@@ -0,0 +1,25 @@
+module Mutant
+  # Module providing isolation
+  class Isolation
+    Error = Class.new(RuntimeError)
+
+    # Absolutly no isolation
+    #
+    # Only useful for debugging.
+    class None < self
+
+      # Call block in no isolation
+      #
+      # @return [Object]
+      #
+      # @raise [Error]
+      #   if block terminates abnormal
+      def call
+        yield
+      rescue => exception
+        raise Error, exception
+      end
+
+    end # None
+  end # Isolation
+end # Mutant

data/lib/mutant/matcher/config.rb

@@ -1,6 +1,8 @@
 module Mutant
   class Matcher
     # Subject matcher configuration
+    #
+    # :reek:TooManyConstants
     class Config
       include Adamantium, Anima.new(
         :ignore_expressions,

data/lib/mutant/matcher/method/singleton.rb

@@ -16,9 +16,10 @@ module Mutant
 
         # Singleton method evaluator
         class Evaluator < Evaluator
-          SUBJECT_CLASS  = Subject::Method::Singleton
-          RECEIVER_INDEX = 0
-          NAME_INDEX     = 1
+          SUBJECT_CLASS    = Subject::Method::Singleton
+          RECEIVER_INDEX   = 0
+          NAME_INDEX       = 1
+          RECEIVER_WARNING = 'Can only match :defs on :self or :const got %p unable to match'.freeze
 
         private
 
@@ -65,7 +66,7 @@ module Mutant
             when :const
               receiver_name?(receiver)
             else
-              env.warn(format('Can only match :defs on :self or :const got %s unable to match', receiver.type.inspect))
+              env.warn(RECEIVER_WARNING % receiver.type)
               nil
             end
           end

data/lib/mutant/meta.rb

@@ -3,26 +3,33 @@ module Mutant
   module Meta
     require 'mutant/meta/example'
     require 'mutant/meta/example/dsl'
+    require 'mutant/meta/example/verification'
 
     # Mutation example
     class Example
 
+      # rubocop:disable MutableConstant
       ALL = []
 
       # Add example
       #
       # @return [undefined]
-      def self.add(&block)
+      def self.add(type, &block)
         file = caller.first.split(':in', 2).first
-        ALL << DSL.run(file, block)
+        ALL << DSL.call(file, type, block)
       end
 
-      Pathname.glob(Pathname.new(__FILE__).parent.parent.parent.join('meta', '**/*.rb'))
+      Pathname.glob(Pathname.new(__dir__).parent.parent.join('meta', '*.rb'))
         .sort
         .each(&method(:require))
+
       ALL.freeze
 
-    end # Example
+      # Remove mutation method only present for DSL executions from meta/**/*.rb
+      class << self
+        undef_method :add
+      end
 
+    end # Example
   end # Meta
 end # Mutant

data/lib/mutant/meta/example.rb

@@ -1,7 +1,7 @@
 module Mutant
   module Meta
     class Example
-      include Adamantium, Concord::Public.new(:file, :node, :mutations)
+      include Adamantium, Anima.new(:file, :node, :node_type, :expected)
 
       # Verification instance for example
       #
@@ -22,126 +22,12 @@ module Mutant
       #
       # @return [Enumerable<Mutant::Mutation>]
       def generated
-        Mutator.each(node).map do |node|
+        Mutator.mutate(node).map do |node|
           Mutation::Evil.new(self, node)
         end
       end
       memoize :generated
 
-      # Example verification
-      class Verification
-        include Adamantium::Flat, Concord.new(:example, :mutations)
-
-        # Test if mutation was verified successfully
-        #
-        # @return [Boolean]
-        def success?
-          unparser.success? && missing.empty? && unexpected.empty? && no_diffs.empty?
-        end
-
-        # Error report
-        #
-        # @return [String]
-        def error_report
-          unless unparser.success?
-            return unparser.report
-          end
-          mutation_report
-        end
-
-      private
-
-        # Unexpected mutations
-        #
-        # @return [Array<Parser::AST::Node>]
-        def unexpected
-          mutations.map(&:node) - example.mutations
-        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
-        #
-        # @return [String]
-        def mutation_report
-          original_node = example.node
-          [
-            "#{example.file}, Original-AST:",
-            original_node.inspect,
-            'Original-Source:',
-            example.source,
-            *missing_report,
-            *unexpected_report,
-            *no_diff_report
-          ].join("\n======\n")
-        end
-
-        # Missing mutation report
-        #
-        # @return [Array, nil]
-        def missing_report
-          [
-            'Missing mutations:',
-            missing.map(&method(:format_mutation)).join("\n-----\n")
-          ] if missing.any?
-        end
-
-        # No diff mutation report
-        #
-        # @return [Array, nil]
-        def no_diff_report
-          [
-            'No source diffs to original:',
-            no_diffs.map do |mutation|
-              "#{mutation.node.inspect}\n#{mutation.source}"
-            end
-          ] if no_diffs.any?
-        end
-
-        # Unexpected mutation report
-        #
-        # @return [Array, nil]
-        def unexpected_report
-          [
-            'Unexpected mutations:',
-            unexpected.map(&method(:format_mutation)).join("\n-----\n")
-          ] if unexpected.any?
-        end
-
-        # Format mutation
-        #
-        # @return [String]
-        def format_mutation(node)
-          [
-            node.inspect,
-            Unparser.unparse(node)
-          ].join("\n")
-        end
-
-        # Missing mutations
-        #
-        # @return [Array<Parser::AST::Node>]
-        def missing
-          example.mutations - mutations.map(&:node)
-        end
-        memoize :missing
-
-        # Unparser verifier
-        #
-        # @return [Unparser::CLI::Source]
-        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

@@ -1,7 +1,6 @@
 module Mutant
   module Meta
     class Example
-
       # Example DSL
       class DSL
         include AST::Sexp
@@ -9,18 +8,21 @@ module Mutant
         # Run DSL on block
         #
         # @return [Example]
-        def self.run(file, block)
-          instance = new(file)
+        def self.call(file, type, block)
+          instance = new(file, type)
           instance.instance_eval(&block)
           instance.example
         end
 
-        # Initialize DSL context
+        private_class_method :new
+
+        # Initialize object
         #
         # @return [undefined]
-        def initialize(file)
-          @file = file
-          @source = nil
+        def initialize(file, type)
+          @file     = file
+          @type     = type
+          @node     = nil
           @expected = []
         end
 
@@ -31,8 +33,13 @@ module Mutant
         # @raise [RuntimeError]
         #   in case example cannot be build
         def example
-          fail 'source not defined' unless @source
-          Example.new(@file, @source, @expected)
+          fail 'source not defined' unless @node
+          Example.new(
+            file:      @file,
+            node:      @node,
+            node_type: @type,
+            expected:  @expected
+          )
         end
 
       private
@@ -41,27 +48,23 @@ module Mutant
         #
         # @param [String,Parser::AST::Node] input
         #
-        # @return [self]
+        # @return [undefined]
         def source(input)
-          fail 'source already defined' if @source
-          @source = node(input)
-
-          self
+          fail 'source already defined' if @node
+          @node = node(input)
         end
 
         # Add expected mutation
         #
         # @param [String,Parser::AST::Node] input
         #
-        # @return [self]
+        # @return [undefined]
         def mutation(input)
           node = node(input)
           if @expected.include?(node)
-            fail "Node for input: #{input.inspect} is already expected"
+            fail "Mutation for input: #{input.inspect} is already expected"
           end
           @expected << node
-
-          self
         end
 
         # Add singleton mutations
@@ -87,7 +90,7 @@ module Mutant
           when ::Parser::AST::Node
             input
           else
-            fail "Cannot coerce to node: #{source.inspect}"
+            fail "Cannot coerce to node: #{input.inspect}"
           end
         end
 

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

@@ -0,0 +1,86 @@
+module Mutant
+  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 # Mutant

data/lib/mutant/mutator.rb

@@ -1,21 +1,19 @@
 module Mutant
   # Generator for mutations
   class Mutator
-    include Adamantium::Flat, AbstractType
 
-    # Run mutator on input
-    #
-    # @param [Object] input
-    #   the input to mutate
+    REGISTRY = Registry.new
+
+    include Adamantium::Flat, Concord.new(:input, :parent), AbstractType, Procto.call(:output)
+
+    # Lookup and invoke dedicated AST mutator
     #
-    # @param [Mutator] parent
+    # @param node [Parser::AST::Node]
+    # @param parent [nil,Mutant::Mutator::Node]
     #
-    # @return [self]
-    def self.each(input, parent = nil, &block)
-      return to_enum(__method__, input, parent) unless block_given?
-      REGISTRY.lookup(input).new(input, parent, block)
-
-      self
+    # @return [Set<Parser::AST::Node>]
+    def self.mutate(node, parent = nil)
+      self::REGISTRY.lookup(node.type).call(node, parent)
     end
 
     # Register node class handler
@@ -23,20 +21,15 @@ module Mutant
     # @return [undefined]
     def self.handle(*types)
       types.each do |type|
-        REGISTRY.register(type, self)
+        self::REGISTRY.register(type, self)
       end
     end
     private_class_method :handle
 
-    # Mutation input
+    # Return output
     #
-    # @return [Object]
-    attr_reader :input
-
-    # Parent context of input
-    #
-    # @return [Object]
-    attr_reader :parent
+    # @return [Set<Parser::AST::Node>]
+    attr_reader :output
 
   private
 
@@ -47,10 +40,11 @@ module Mutant
     # @param [#call(node)] block
     #
     # @return [undefined]
-    def initialize(input, parent, block)
-      @input, @parent, @block = input, parent, block
-      @seen = Set.new
-      guard(input)
+    def initialize(_input, _parent = nil)
+      super
+
+      @output = Set.new
+
       dispatch
     end
 
@@ -60,16 +54,7 @@ module Mutant
     #
     # @return [Boolean]
     def new?(object)
-      !@seen.include?(object)
-    end
-
-    # Add object to guarded values
-    #
-    # @param [Object] object
-    #
-    # @return [undefined]
-    def guard(object)
-      @seen << object
+      !object.eql?(input)
     end
 
     # Dispatch node generations
@@ -85,26 +70,14 @@ module Mutant
     def emit(object)
       return unless new?(object)
 
-      guard(object)
-
-      emit!(object)
-    end
-
-    # Call block with node
-    #
-    # @param [Parser::AST::Node] node
-    #
-    # @return [self]
-    def emit!(node)
-      @block.call(node)
-      self
+      output << object
     end
 
     # Run input with mutator
     #
     # @return [undefined]
     def run(mutator)
-      mutator.new(input, self, method(:emit))
+      mutator.call(input).each(&method(:emit))
     end
 
     # Shortcut to create a new unfrozen duplicate of input