mutant 0.8.0 → 0.8.1

data/lib/mutant/env.rb

@@ -7,6 +7,7 @@ module Mutant
       :cache,
       :subjects,
       :matchable_scopes,
+      :integration,
       :selector,
       :mutations
     )
@@ -22,7 +23,6 @@ module Mutant
     # @return [self]
     #
     # @api private
-    #
     def warn(message)
       config.reporter.warn(message)
       self
@@ -35,7 +35,6 @@ module Mutant
     # @return [Result::Mutation]
     #
     # @api private
-    #
     def kill(mutation)
       test_result = run_mutation_tests(mutation)
       Result::Mutation.new(
@@ -53,17 +52,16 @@ module Mutant
     #
     # @return [Result::Test]
     #
-    # @api private
-    #
     # rubocop:disable MethodLength
     #
+    # @api private
     def run_mutation_tests(mutation)
       start = Time.now
       tests = selector.call(mutation.subject)
 
       config.isolation.call do
         mutation.insert
-        config.integration.call(tests)
+        integration.call(tests)
       end
     rescue Isolation::Error => error
       Result::Test.new(

data/lib/mutant/env/bootstrap.rb

@@ -8,20 +8,18 @@ module Mutant
         "Fix your lib to follow normal ruby semantics!\n" \
         '{Module,Class}#name should return resolvable constant name as String or nil'.freeze
 
-      # Return scopes that are eligible for mnatching
+      # Scopes that are eligible for matching
       #
       # @return [Enumerable<Matcher::Scope>]
       #
       # @api private
-      #
       attr_reader :matchable_scopes
 
-      # Return new bootstrap env
+      # New bootstrap env
       #
       # @return [Env]
       #
       # @api private
-      #
       def self.new(_config, _cache = Cache.new)
         super
       end
@@ -31,7 +29,6 @@ module Mutant
       # @return [Object]
       #
       # @api private
-      #
       def initialize(*)
         super
         infect
@@ -45,35 +42,35 @@ module Mutant
       # @return [self]
       #
       # @api private
-      #
       def warn(message)
         config.reporter.warn(message)
         self
       end
 
-      # Return environment after bootstraping
+      # Environment after bootstraping
       #
       # @return [Env]
       #
       # @api private
+      # rubocop:disable MethodLength
       #
       def env
         subjects = matched_subjects
-
         Env.new(
           actor_env:        Actor::Env.new(Thread),
           config:           config,
           cache:            cache,
           subjects:         subjects,
           matchable_scopes: matchable_scopes,
-          selector:         Selector::Expression.new(config.integration),
+          integration:      @integration,
+          selector:         Selector::Expression.new(@integration),
           mutations:        subjects.flat_map(&:mutations)
         )
       end
 
     private
 
-      # Return scope name
+      # Scope name from scopeing object
       #
       # @param [Class, Module] scope
       #
@@ -84,9 +81,6 @@ module Mutant
       #   otherwise
       #
       # @api private
-      #
-      # rubocop:disable LineLength
-      #
       def scope_name(scope)
         scope.name
       rescue => exception
@@ -99,10 +93,33 @@ module Mutant
       # @return [undefined]
       #
       # @api private
-      #
       def infect
         config.includes.each(&$LOAD_PATH.method(:<<))
         config.requires.each(&method(:require))
+        @integration = config.integration.new(config).setup
+      end
+
+      # Matched subjects
+      #
+      # @return [Enumerable<Subject>]
+      #
+      # @api private
+      def matched_subjects
+        Matcher::Compiler.call(self, config.matcher).to_a
+      end
+
+      # Initialize matchable scopes
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize_matchable_scopes
+        scopes = ObjectSpace.each_object(Module).each_with_object([]) do |scope, aggregate|
+          expression = expression(scope)
+          aggregate << Matcher::Scope.new(self, scope, expression) if expression
+        end
+
+        @matchable_scopes = scopes.sort_by { |scope| scope.expression.syntax }
       end
 
       # Try to turn scope into expression
@@ -116,7 +133,6 @@ module Mutant
       #   otherwise
       #
       # @api private
-      #
       def expression(scope)
         name = scope_name(scope) or return
 
@@ -125,30 +141,7 @@ module Mutant
           return
         end
 
-        Expression.try_parse(name)
-      end
-
-      # Return matched subjects
-      #
-      # @return [Enumerable<Subject>]
-      #
-      # @api private
-      #
-      def matched_subjects
-        Matcher::Compiler.call(self, config.matcher).to_a
-      end
-
-      # Initialize matchable scopes
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
-      def initialize_matchable_scopes
-        @matchable_scopes = ObjectSpace.each_object(Module).each_with_object([]) do |scope, aggregate|
-          expression = expression(scope)
-          aggregate << Matcher::Scope.new(self, scope, expression) if expression
-        end.sort_by(&:identification)
+        config.expression_parser.try_parse(name)
       end
     end # Boostrap
   end # Env

data/lib/mutant/expression.rb

@@ -2,92 +2,28 @@ module Mutant
 
   # Abstract base class for match expression
   class Expression
-    include AbstractType, Adamantium::Flat, Concord::Public.new(:match)
+    include AbstractType, Adamantium::Flat
 
-    include Equalizer.new(:syntax)
+    fragment             = /[A-Za-z][A-Za-z\d_]*/.freeze
+    SCOPE_NAME_PATTERN   = /(?<scope_name>#{fragment}(?:#{SCOPE_OPERATOR}#{fragment})*)/.freeze
+    SCOPE_SYMBOL_PATTERN = '(?<scope_symbol>[.#])'.freeze
 
-    SCOPE_NAME_PATTERN = /[A-Za-z][A-Za-z\d_]*/.freeze
+    private_constant(*constants(false))
 
-    METHOD_NAME_PATTERN = Regexp.union(
-      /[A-Za-z_][A-Za-z\d_]*[!?=]?/,
-      *AST::Types::OPERATOR_METHODS.map(&:to_s)
-    ).freeze
-
-    INSPECT_FORMAT = '<Mutant::Expression: %s>'.freeze
-
-    SCOPE_PATTERN = /#{SCOPE_NAME_PATTERN}(?:#{SCOPE_OPERATOR}#{SCOPE_NAME_PATTERN})*/.freeze
-
-    REGISTRY = {}
-
-    # Error raised on invalid expressions
-    class InvalidExpressionError < RuntimeError; end
-
-    # Error raised on ambiguous expressions
-    class AmbiguousExpressionError < RuntimeError; end
-
-    # Initialize expression
-    #
-    # @param [MatchData] match
-    #
-    # @api private
-    #
-    def initialize(*)
-      super
-      @syntax = match.to_s
-      @inspect = format(INSPECT_FORMAT, syntax)
-    end
-
-    # Return marshallable representation
-    #
-    # FIXME: Remove the need for this.
-    #
-    #   Refactoring Expression objects not to reference a MatchData instance.
-    #   This will make this hack unneeded.
-    #
-    # @return [String]
-    #
-    # @api private
-    #
-    def _dump(_level)
-      syntax
-    end
-
-    # Load serializable representation
-    #
-    # @return [String]
-    #
-    # @return [Expression]
-    #
-    # @api private
-    #
-    def self._load(syntax)
-      parse(syntax)
-    end
-
-    # Return inspection
-    #
-    # @return [String]
-    #
-    # @api private
-    #
-    attr_reader :inspect
-
-    # Return syntax
+    # Syntax of expression
     #
     # @return [String]
     #
     # @api private
-    #
-    attr_reader :syntax
+    abstract_method :syntax
 
-    # Return match length for expression
+    # Match length with other expression
     #
     # @param [Expression] other
     #
     # @return [Fixnum]
     #
     # @api private
-    #
     def match_length(other)
       if eql?(other)
         syntax.length
@@ -103,81 +39,27 @@ module Mutant
     # @return [Boolean]
     #
     # @api private
-    #
     def prefix?(other)
       !match_length(other).zero?
     end
 
-    # Register expression
-    #
-    # @return [undefined]
-    #
-    # @api private
-    #
-    def self.register(regexp)
-      REGISTRY[regexp] = self
-    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 fail InvalidExpressionError, "Expression: #{input.inspect} is not valid"
-    end
-
-    # Parse input into expression
+    # Try to parse input into expression of receiver class
     #
     # @param [String] input
     #
     # @return [Expression]
-    #   if expression is valid
+    #   when successful
     #
     # @return [nil]
     #   otherwise
     #
     # @api private
-    #
     def self.try_parse(input)
-      expressions = expressions(input)
-      case expressions.length
-      when 0
-      when 1
-        expressions.first
-      else
-        fail AmbiguousExpressionError, "Ambiguous expression: #{input.inspect}"
-      end
-    end
-
-    # Return expressions for input
-    #
-    # @param [String] input
-    #
-    # @return [Classifier]
-    #   if classifier can be found
-    #
-    # @return [nil]
-    #   otherwise
-    #
-    # @api private
-    #
-    def self.expressions(input)
-      REGISTRY.each_with_object([]) do |(regexp, klass), expressions|
-        match = regexp.match(input)
-        next unless match
-        expressions << klass.new(match)
-      end
+      match = self::REGEXP.match(input)
+      return unless match
+      names = anima.attribute_names
+      new(Hash[names.zip(names.map(&match.method(:[])))])
     end
-    private_class_method :expressions
 
   end # Expression
 end # Mutant

data/lib/mutant/expression/method.rb

@@ -3,72 +3,55 @@ module Mutant
 
     # Explicit method expression
     class Method < self
+      include Anima.new(:scope_name, :scope_symbol, :method_name)
+      private(*anima.attribute_names)
 
       MATCHERS = IceNine.deep_freeze(
         '.' => Matcher::Methods::Singleton,
         '#' => Matcher::Methods::Instance
       )
 
-      register(
-        /\A(?<scope_name>#{SCOPE_PATTERN})(?<scope_symbol>[.#])(?<method_name>#{METHOD_NAME_PATTERN})\z/
-      )
+      METHOD_NAME_PATTERN = Regexp.union(
+        /(?<method_name>[A-Za-z_][A-Za-z\d_]*[!?=]?)/,
+        *AST::Types::OPERATOR_METHODS.map(&:to_s)
+      ).freeze
 
-      # Return method matcher
-      #
-      # @param [Env] env
-      #
-      # @return [Matcher::Method]
-      #
-      # @api private
-      #
-      def matcher(env)
-        methods_matcher = MATCHERS.fetch(scope_symbol).new(env, scope)
-        method = methods_matcher.methods.detect do |meth|
-          meth.name.equal?(method_name)
-        end or fail NameError, "Cannot find method #{method_name}"
-        methods_matcher.matcher.build(env, scope, method)
-      end
+      private_constant(*constants(false))
 
-    private
+      REGEXP = /\A#{SCOPE_NAME_PATTERN}#{SCOPE_SYMBOL_PATTERN}#{METHOD_NAME_PATTERN}\z/.freeze
 
-      # Return scope name
+      # Syntax of expression
       #
       # @return [String]
       #
       # @api private
-      #
-      def scope_name
-        match[__method__]
+      def syntax
+        [scope_name, scope_symbol, method_name].join
       end
+      memoize :syntax
 
-      # Return scope
-      #
-      # @return [Class, Method]
-      #
-      # @api private
+      # Matcher for expression
       #
-      def scope
-        Object.const_get(scope_name)
-      end
-
-      # Return method name
+      # @param [Env] env
       #
-      # @return [String]
+      # @return [Matcher]
       #
       # @api private
-      #
-      def method_name
-        match[__method__].to_sym
+      def matcher(env)
+        methods_matcher = MATCHERS.fetch(scope_symbol).new(env, scope)
+
+        Matcher::Filter.build(methods_matcher) { |subject| subject.expression.eql?(self) }
       end
 
-      # Return scope symbol
+    private
+
+      # Scope object
       #
-      # @return [Symbol]
+      # @return [Class, Method]
       #
       # @api private
-      #
-      def scope_symbol
-        match[__method__]
+      def scope
+        Object.const_get(scope_name)
       end
 
     end # Method