mutant 0.8.0 → 0.8.1

data/lib/mutant/expression/methods.rb

@@ -3,36 +3,45 @@ module Mutant
 
     # Abstract base class for methods expression
     class Methods < self
+      include Anima.new(:scope_name, :scope_symbol)
+      private(*anima.attribute_names)
 
       MATCHERS = IceNine.deep_freeze(
         '.' => Matcher::Methods::Singleton,
         '#' => Matcher::Methods::Instance
       )
+      private_constant(*constants(false))
 
-      register(
-        /\A(?<scope_name>#{SCOPE_PATTERN})(?<scope_symbol>[.#])\z/
-      )
+      REGEXP = /\A#{SCOPE_NAME_PATTERN}#{SCOPE_SYMBOL_PATTERN}\z/.freeze
+
+      # Syntax of expression
+      #
+      # @return [String]
+      #
+      # @api private
+      def syntax
+        [scope_name, scope_symbol].join
+      end
+      memoize :syntax
 
-      # Return method matcher
+      # Matcher on expression
       #
       # @param [Env] env
       #
       # @return [Matcher::Method]
       #
       # @api private
-      #
       def matcher(env)
         MATCHERS.fetch(scope_symbol).new(env, scope)
       end
 
-      # Return length of match
+      # Length of match with other expression
       #
       # @param [Expression] expression
       #
       # @return [Fixnum]
       #
       # @api private
-      #
       def match_length(expression)
         if expression.syntax.start_with?(syntax)
           syntax.length
@@ -43,36 +52,15 @@ module Mutant
 
     private
 
-      # Return scope name
-      #
-      # @return [String]
-      #
-      # @api private
-      #
-      def scope_name
-        match[__method__]
-      end
-
-      # Return scope
+      # Scope object
       #
       # @return [Class, Method]
       #
       # @api private
-      #
       def scope
         Object.const_get(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

@@ -2,24 +2,12 @@ module Mutant
   class Expression
     # Abstract base class for expressions matching namespaces
     class Namespace < self
-      include AbstractType
-
-    private
-
-      # Return matched namespace
-      #
-      # @return [String]
-      #
-      # @api private
-      #
-      def namespace
-        match[__method__]
-      end
+      include AbstractType, Anima.new(:scope_name)
+      private(*anima.attribute_names)
 
       # Recursive namespace expression
       class Recursive < self
-
-        register(/\A(?<namespace>#{SCOPE_PATTERN})?\*\z/)
+        REGEXP = /\A#{SCOPE_NAME_PATTERN}?\*\z/.freeze
 
         # Initialize object
         #
@@ -29,35 +17,43 @@ module Mutant
         def initialize(*)
           super
           @recursion_pattern = Regexp.union(
-            /\A#{namespace}\z/,
-            /\A#{namespace}::/,
-            /\A#{namespace}[.#]/
+            /\A#{scope_name}\z/,
+            /\A#{scope_name}::/,
+            /\A#{scope_name}[.#]/
           )
         end
 
-        # Return matcher
+        # Syntax for expression
+        #
+        # @return [String]
+        #
+        # @api private
+        def syntax
+          "#{scope_name}*"
+        end
+        memoize :syntax
+
+        # Matcher for expression
         #
         # @param [Env::Bootstrap] env
         #
         # @return [Matcher]
         #
         # @api private
-        #
         def matcher(env)
           Matcher::Namespace.new(env, self)
         end
 
-        # Return length of match
+        # Length of match with other expression
         #
         # @param [Expression] expression
         #
         # @return [Fixnum]
         #
         # @api private
-        #
         def match_length(expression)
           if @recursion_pattern =~ expression.syntax
-            namespace.length
+            scope_name.length
           else
             0
           end
@@ -68,22 +64,31 @@ module Mutant
       # Exact namespace expression
       class Exact < self
 
-        register(/\A(?<namespace>#{SCOPE_PATTERN})\z/)
-
         MATCHER = Matcher::Scope
+        private_constant(*constants(false))
+
+        REGEXP  = /\A#{SCOPE_NAME_PATTERN}\z/.freeze
 
-        # Return matcher
+        # Matcher matcher on expression
         #
         # @param [Env::Bootstrap] env
         #
         # @return [Matcher]
         #
         # @api private
-        #
         def matcher(env)
-          Matcher::Scope.new(env, Object.const_get(namespace), self)
+          Matcher::Scope.new(env, Object.const_get(scope_name), self)
         end
 
+        # Syntax for expression
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        alias_method :syntax, :scope_name
+        public :syntax
+
       end # Exact
     end # Namespace
   end # Namespace

data/lib/mutant/expression/parser.rb

@@ -0,0 +1,71 @@
+module Mutant
+  class Expression
+    class Parser
+      include Concord.new(:types)
+
+      class ParserError < RuntimeError
+        include AbstractType
+      end
+
+      # Error raised on invalid expressions
+      class InvalidExpressionError < ParserError; end
+
+      # Error raised on ambiguous expressions
+      class AmbiguousExpressionError < ParserError; end
+
+      # Parse input into expression or raise
+      #
+      # @param [String] syntax
+      #
+      # @return [Expression]
+      #   if expression is valid
+      #
+      # @raise [ParserError]
+      #   otherwise
+      #
+      # @api private
+      def call(input)
+        try_parse(input) or fail InvalidExpressionError, "Expression: #{input.inspect} is not valid"
+      end
+
+      # Try to parse input into expression
+      #
+      # @param [String] input
+      #
+      # @return [Expression]
+      #   if expression is valid
+      #
+      # @return [nil]
+      #   otherwise
+      #
+      # @api private
+      def try_parse(input)
+        expressions = expressions(input)
+        case expressions.length
+        when 0, 1
+          expressions.first
+        else
+          fail AmbiguousExpressionError, "Ambiguous expression: #{input.inspect}"
+        end
+      end
+
+    private
+
+      # Expressions parsed from input
+      #
+      # @param [String] input
+      #
+      # @return [Array<Expression>]
+      #   if expressions can be parsed from input
+      #
+      # @api private
+      def expressions(input)
+        types.each_with_object([]) do |type, aggregate|
+          expression = type.try_parse(input)
+          aggregate << expression if expression
+        end
+      end
+
+    end # Parser
+  end # Expression
+end # Mutant

data/lib/mutant/integration.rb

@@ -2,7 +2,7 @@ module Mutant
 
   # Abstract base class mutant test framework integrations
   class Integration
-    include AbstractType, Adamantium::Flat, Equalizer.new
+    include AbstractType, Adamantium::Flat, Concord.new(:config)
 
     REGISTRY = {}
 
@@ -13,7 +13,6 @@ module Mutant
     # @return [Integration]
     #
     # @api private
-    #
     def self.setup(name)
       require "mutant/integration/#{name}"
       lookup(name)
@@ -27,9 +26,8 @@ module Mutant
     #   if found
     #
     # @api private
-    #
     def self.lookup(name)
-      REGISTRY.fetch(name).new
+      REGISTRY.fetch(name)
     end
 
     # Register integration
@@ -39,11 +37,8 @@ module Mutant
     # @return [undefined]
     #
     # @api private
-    #
     def self.register(name)
       REGISTRY[name] = self
-
-      define_method(:name) { name }
     end
     private_class_method :register
 
@@ -52,52 +47,58 @@ module Mutant
     # @return [self]
     #
     # @api private
-    #
     def setup
       self
     end
 
-    # Return test result for tests
+    # Run a collection of tests
     #
     # @param [Enumerable<Test>] tests
     #
     # @return [Result::Test]
     #
     # @api private
-    #
     abstract_method :call
 
-    # Return all available tests by integration
+    # Available tests for integration
     #
     # @return [Enumerable<Test>]
     #
     # @api private
-    #
     abstract_method :all_tests
 
+  private
+
+    # Expression parser
+    #
+    # @return [Expression::Parser]
+    #
+    # @api private
+    def expression_parser
+      config.expression_parser
+    end
+
     # Null integration that never kills a mutation
     class Null < self
 
       register('null')
 
-      # Return all tests
+      # Available tests for integration
       #
       # @return [Enumerable<Test>]
       #
       # @api private
-      #
       def all_tests
         EMPTY_ARRAY
       end
 
-      # Return report for test
+      # Run a collection of tests
       #
       # @param [Enumerable<Mutant::Test>] tests
       #
       # @return [Result::Test]
       #
       # @api private
-      #
       def call(tests)
         Result::Test.new(
           tests:   tests,

data/lib/mutant/isolation.rb

@@ -13,7 +13,6 @@ module Mutant
       #   if block terminates abnormal
       #
       # @api private
-      #
       def self.call(&block)
         block.call
       rescue => exception
@@ -35,28 +34,29 @@ module Mutant
       # @raise [Error]
       #   if block terminates abnormal
       #
-      # @api private
-      #
       # rubocop:disable MethodLength
       #
+      # @api private
       def self.call(&block)
-        reader, writer = IO.pipe.map(&:binmode)
+        IO.pipe(binmode: true) do |reader, writer|
+          begin
+            pid = Process.fork do
+              File.open(File::NULL, 'w') do |file|
+                $stderr.reopen(file)
+                reader.close
+                writer.write(Marshal.dump(block.call))
+                writer.close
+              end
+            end
 
-        pid = Process.fork do
-          File.open('/dev/null', 'w') do |file|
-            $stderr.reopen(file)
-            reader.close
-            writer.write(Marshal.dump(block.call))
             writer.close
+            Marshal.load(reader.read)
+          ensure
+            Process.waitpid(pid) if pid
           end
         end
-
-        writer.close
-        Marshal.load(reader.read)
       rescue => exception
         raise Error, exception
-      ensure
-        Process.waitpid(pid) if pid
       end
 
     end # Fork

data/lib/mutant/loader.rb

@@ -10,12 +10,11 @@ module Mutant
       #
       # @return [undefined]
       #
-      # @api private
-      #
       # One off the very few valid uses of eval
       #
       # rubocop:disable Lint/Eval
       #
+      # @api private
       def call
         eval(
           source,
@@ -28,12 +27,11 @@ module Mutant
 
     private
 
-      # Return source
+      # Source generated from AST
       #
       # @return [String]
       #
       # @api private
-      #
       def source
         Unparser.unparse(root)
       end