mutant 0.5.23 → 0.5.24

data/lib/mutant/delegator.rb

@@ -37,6 +37,8 @@ module Mutant
     #
     # @param [Class,Module] host
     #
+    # @return [undefined]
+    #
     # @api private
     #
     def self.included(host)

data/lib/mutant/diff.rb

@@ -3,6 +3,10 @@ module Mutant
   class Diff
     include Adamantium::Flat, Concord.new(:old, :new)
 
+    ADDITION = '+'.freeze
+    DELETION = '-'.freeze
+    NEWLINE  = "\n".freeze
+
     # Return source diff
     #
     # @return [String]
@@ -16,7 +20,7 @@ module Mutant
     def diff
       return unless diffs.length.equal?(1)
       ::Diff::LCS::Hunk.new(old, new, diffs.first, max_length, 0)
-        .diff(:unified) << "\n"
+        .diff(:unified) << NEWLINE
     end
     memoize :diff
 
@@ -97,9 +101,9 @@ module Mutant
     #
     def self.colorize_line(line)
       case line[0]
-      when '+'
+      when ADDITION
         Color::GREEN
-      when '-'
+      when DELETION
         Color::RED
       else
         Color::NONE

data/lib/mutant/env.rb

@@ -0,0 +1,49 @@
+module Mutant
+  # Abstract base class for mutant environments
+  class Env
+    include AbstractType, Adamantium
+
+    # Return config
+    #
+    # @return [Config]
+    #
+    # @api private
+    #
+    abstract_method :config
+
+    # Return cache
+    #
+    # @return [Cache]
+    #
+    # @api private
+    #
+    abstract_method :cache
+
+    # Return reporter
+    #
+    # @return [Reporter]
+    #
+    # @api private
+    #
+    abstract_method :reporter
+
+    # Print warning message
+    #
+    # @param [String]
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def warn(message)
+      reporter.warn(message)
+      self
+    end
+
+    # Boot environment used for matching
+    class Boot < self
+      include Concord::Public.new(:reporter, :cache)
+    end # Boot
+
+  end # ENV
+end # Mutant

data/lib/mutant/expression.rb

@@ -10,7 +10,7 @@ module Mutant
 
     METHOD_NAME_PATTERN = Regexp.union(
       /[A-Za-z_][A-Za-z\d_]*[!?=]?/,
-      *OPERATOR_METHODS.map(&:to_s)
+      *AST::Types::OPERATOR_METHODS.map(&:to_s)
     ).freeze
 
     SCOPE_PATTERN = /#{SCOPE_NAME_PATTERN}(?:#{SCOPE_OPERATOR}#{SCOPE_NAME_PATTERN})*/.freeze
@@ -38,20 +38,32 @@ module Mutant
 
     # Return match length for expression
     #
-    # @param [Expression] neddle
+    # @param [Expression] other
     #
     # @return [Fixnum]
     #
     # @api private
     #
-    def match_length(neddle)
-      if eql?(neddle)
+    def match_length(other)
+      if eql?(other)
         syntax.length
       else
         0
       end
     end
 
+    # Test if expression is prefix
+    #
+    # @param [Expression] other
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    #
+    def prefix?(other)
+      !match_length(other).zero?
+    end
+
     # Register expression
     #
     # @return [undefined]
@@ -63,9 +75,25 @@ module Mutant
     end
     private_class_method :register
 
+    # Parse input into expression or raise
+    #
+    # @param [String] syntax
+    #
+    # @return [Expression]
+    #   if expression is valid
+    #
+    # @raise [RuntimeError]
+    #   otherwise
+    #
+    # @api private
+    #
+    def self.parse(input)
+      try_parse(input) or raise "Expression: #{input.inspect} is not valid"
+    end
+
     # Parse input into expression
     #
-    # @param [String] pattern
+    # @param [String] input
     #
     # @return [Expression]
     #   if expression is valid
@@ -75,14 +103,14 @@ module Mutant
     #
     # @api private
     #
-    def self.parse(pattern)
-      expressions = expressions(pattern)
+    def self.try_parse(input)
+      expressions = expressions(input)
       case expressions.length
       when 0
       when 1
         expressions.first
       else
-        fail "Ambigous expression: #{pattern.inspect}"
+        fail "Ambigous expression: #{input.inspect}"
       end
     end
 

data/lib/mutant/expression/methods.rb

@@ -0,0 +1,62 @@
+module Mutant
+  class Expression
+
+    # Abstrat base class for methods expression
+    class Methods < self
+
+      MATCHERS = {
+        '.' => Matcher::Methods::Singleton,
+        '#' => Matcher::Methods::Instance
+      }.freeze
+
+      register(
+        /\A(?<scope_name>#{SCOPE_PATTERN})(?<scope_symbol>[.#])\z/
+      )
+
+      # Return method matcher
+      #
+      # @param [Cache] cache
+      #
+      # @return [Matcher::Method]
+      #
+      # @api private
+      #
+      def matcher(cache)
+        MATCHERS.fetch(scope_symbol).new(cache, scope)
+      end
+
+    private
+
+      # Return scope name
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def scope_name
+        match[__method__]
+      end
+
+      # Return scope
+      #
+      # @return [Class, Method]
+      #
+      # @api private
+      #
+      def scope
+        Mutant.constant_lookup(scope_name)
+      end
+
+      # Return scope symbol
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      #
+      def scope_symbol
+        match[__method__]
+      end
+
+    end # Method
+  end # Expression
+end # Mutant

data/lib/mutant/expression/namespace.rb

@@ -4,37 +4,11 @@ module Mutant
     class Namespace < self
       include AbstractType
 
-      # Return matcher
-      #
-      # @param [Cache] cache
-      #
-      # @return [Matcher]
-      #
-      # @api private
-      #
-      def matcher(cache)
-        self.class::MATCHER.new(cache, namespace)
-      end
-
-    private
-
-      # Return namespace
-      #
-      # @return [Class, Module]
-      #
-      # @api private
-      #
-      def namespace
-        Mutant.constant_lookup(match[__method__].to_s)
-      end
-
       # Recursive namespace expression
       class Recursive < self
 
         register(/\A(?<namespace>#{SCOPE_PATTERN})?\*\z/)
 
-        MATCHER = Matcher::Namespace
-
         # Initialize object
         #
         # @return [undefined]
@@ -43,7 +17,23 @@ module Mutant
         def initialize(*)
           super
           namespace_src = Regexp.escape(namespace)
-          @recursion_pattern = Regexp.union(/\A#{namespace_src}\z/, /\A#{namespace_src}::/)
+          @recursion_pattern = Regexp.union(
+            /\A#{namespace_src}\z/,
+            /\A#{namespace_src}::/,
+            /\A#{namespace_src}[.#]/
+          )
+        end
+
+        # Return matcher
+        #
+        # @param [Cache] cache
+        #
+        # @return [Matcher]
+        #
+        # @api private
+        #
+        def matcher(cache)
+          Matcher::Namespace.new(cache, self)
         end
 
         # Return length of match
@@ -83,8 +73,31 @@ module Mutant
 
         MATCHER = Matcher::Scope
 
-      end # Exact
+        # Return matcher
+        #
+        # @param [Cache] cache
+        #
+        # @return [Matcher]
+        #
+        # @api private
+        #
+        def matcher(cache)
+          Matcher::Scope.new(cache, Mutant.constant_lookup(namespace))
+        end
+
+      private
+
+        # Return namespace
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def namespace
+          match[__method__].to_s
+        end
 
+      end # Exact
     end # Namespace
   end # Namespace
 end # Mutant

data/lib/mutant/{strategy.rb → integration.rb}

@@ -1,16 +1,16 @@
 module Mutant
 
-  # Abstract base class for killing strategies
-  class Strategy
+  # Abstract base class mutant test framework integrations
+  class Integration
     include AbstractType, Adamantium::Flat, Equalizer.new
 
     REGISTRY = {}
 
-    # Lookup strategy for name
+    # Lookup integration for name
     #
     # @param [String] name
     #
-    # @return [Strategy]
+    # @return [Integration]
     #   if found
     #
     # @api private
@@ -19,7 +19,7 @@ module Mutant
       REGISTRY.fetch(name)
     end
 
-    # Register strategy
+    # Register integration
     #
     # @param [String] name
     #
@@ -29,10 +29,12 @@ module Mutant
     #
     def self.register(name)
       REGISTRY[name] = self
+
+      define_method(:name) { name }
     end
     private_class_method :register
 
-    # Perform strategy setup
+    # Perform integration setup
     #
     # @return [self]
     #
@@ -42,7 +44,7 @@ module Mutant
       self
     end
 
-    # Perform strategy teardown
+    # Perform integration teardown
     #
     # @return [self]
     #
@@ -52,7 +54,7 @@ module Mutant
       self
     end
 
-    # Return all available tests by strategy
+    # Return all available tests by integration
     #
     # @return [Enumerable<Test>]
     #
@@ -60,28 +62,7 @@ module Mutant
     #
     abstract_method :all_tests
 
-    # Return tests for mutation
-    #
-    # TODO: This logic is now centralized but still fucked.
-    #
-    # @param [Mutation] mutation
-    #
-    # @return [Enumerable<Test>]
-    #
-    # @api private
-    #
-    def tests(subject)
-      subject.match_prefixes.map do |match_expression|
-        tests = all_tests.select do |test|
-          test.subject_identification.start_with?(match_expression)
-        end
-        return tests if tests.any?
-      end
-
-      EMPTY_ARRAY
-    end
-
-    # Null strategy that never kills a mutation
+    # Null integration that never kills a mutation
     class Null < self
 
       register('null')
@@ -98,5 +79,5 @@ module Mutant
 
     end # Null
 
-  end # Strategy
+  end # Integration
 end # Mutant

data/lib/mutant/isolation.rb

@@ -16,7 +16,7 @@ module Mutant
     # @api private
     #
     def self.call(&block)
-      Parallel.map([block], in_processes: 1) do |block|
+      Parallel.map([block], in_processes: 1) do
         block.call
       end.first
     end

data/lib/mutant/matcher.rb

@@ -3,29 +3,9 @@ module Mutant
   class Matcher
     include Adamantium::Flat, Enumerable, AbstractType
 
-    # Enumerate subjects
-    #
-    # @param [Object] input
-    #
-    # @return [self]
-    #   if block given
-    #
-    # @return [Enumerable<Subject>]
-    #   otherwise
-    #
-    # @api private
-    #
-    def self.each(cache, input, &block)
-      return to_enum(__method__, cache, input) unless block_given?
-
-      build(cache, input).each(&block)
-
-      self
-    end
-
     # Default matcher build implementation
     #
-    # @param [Cache] cache
+    # @param [Env] env
     # @param [Object] input
     #
     # @return [undefined]