mutant 0.8.10 → 0.8.11

data/lib/mutant.rb

@@ -14,6 +14,7 @@ require 'parallel'
 require 'parser'
 require 'parser/current'
 require 'pathname'
+require 'regexp_parser'
 require 'set'
 require 'stringio'
 require 'unparser'
@@ -42,12 +43,24 @@ end # Mutant
 require 'mutant/version'
 require 'mutant/env'
 require 'mutant/env/bootstrap'
+require 'mutant/util'
+require 'mutant/registry'
 require 'mutant/ast'
 require 'mutant/ast/sexp'
 require 'mutant/ast/types'
 require 'mutant/ast/nodes'
 require 'mutant/ast/named_children'
 require 'mutant/ast/node_predicates'
+require 'mutant/ast/regexp'
+require 'mutant/ast/regexp/transformer'
+require 'mutant/ast/regexp/transformer/direct'
+require 'mutant/ast/regexp/transformer/text'
+require 'mutant/ast/regexp/transformer/recursive'
+require 'mutant/ast/regexp/transformer/quantifier'
+require 'mutant/ast/regexp/transformer/options_group'
+require 'mutant/ast/regexp/transformer/character_set'
+require 'mutant/ast/regexp/transformer/root'
+require 'mutant/ast/regexp/transformer/alternative'
 require 'mutant/ast/meta'
 require 'mutant/ast/meta/send'
 require 'mutant/ast/meta/const'
@@ -62,6 +75,8 @@ require 'mutant/actor/mailbox'
 require 'mutant/actor/env'
 require 'mutant/parser'
 require 'mutant/isolation'
+require 'mutant/isolation/none'
+require 'mutant/isolation/fork'
 require 'mutant/parallel'
 require 'mutant/parallel/master'
 require 'mutant/parallel/worker'
@@ -70,12 +85,12 @@ require 'mutant/warning_filter'
 require 'mutant/require_highjack'
 require 'mutant/mutation'
 require 'mutant/mutator'
-require 'mutant/mutator/registry'
 require 'mutant/mutator/util'
 require 'mutant/mutator/util/array'
 require 'mutant/mutator/util/symbol'
 require 'mutant/mutator/node'
 require 'mutant/mutator/node/generic'
+require 'mutant/mutator/node/regexp'
 require 'mutant/mutator/node/literal'
 require 'mutant/mutator/node/literal/boolean'
 require 'mutant/mutator/node/literal/range'
@@ -89,7 +104,6 @@ require 'mutant/mutator/node/literal/regex'
 require 'mutant/mutator/node/literal/nil'
 require 'mutant/mutator/node/argument'
 require 'mutant/mutator/node/arguments'
-require 'mutant/mutator/node/blockarg'
 require 'mutant/mutator/node/begin'
 require 'mutant/mutator/node/binary'
 require 'mutant/mutator/node/const'
@@ -110,12 +124,13 @@ require 'mutant/mutator/node/conditional_loop'
 require 'mutant/mutator/node/yield'
 require 'mutant/mutator/node/super'
 require 'mutant/mutator/node/zsuper'
-require 'mutant/mutator/node/restarg'
 require 'mutant/mutator/node/send'
 require 'mutant/mutator/node/send/binary'
+require 'mutant/mutator/node/send/conditional'
 require 'mutant/mutator/node/send/attribute_assignment'
 require 'mutant/mutator/node/send/index'
 require 'mutant/mutator/node/when'
+require 'mutant/mutator/node/class'
 require 'mutant/mutator/node/define'
 require 'mutant/mutator/node/mlhs'
 require 'mutant/mutator/node/nthref'
@@ -125,6 +140,7 @@ require 'mutant/mutator/node/block'
 require 'mutant/mutator/node/if'
 require 'mutant/mutator/node/case'
 require 'mutant/mutator/node/splat'
+require 'mutant/mutator/node/regopt'
 require 'mutant/mutator/node/resbody'
 require 'mutant/mutator/node/rescue'
 require 'mutant/mutator/node/match_current_line'
@@ -188,8 +204,6 @@ module Mutant
   # Reopen class to initialize constant to avoid dep circle
   class Config
     DEFAULT = new(
-      debug:             false,
-      expected_coverage: Rational(1),
       expression_parser: Expression::Parser.new([
         Expression::Method,
         Expression::Methods,
@@ -199,7 +213,14 @@ module Mutant
       fail_fast:         false,
       includes:          EMPTY_ARRAY,
       integration:       Integration::Null,
-      isolation:         Mutant::Isolation::Fork,
+      isolation:         Mutant::Isolation::Fork.new(
+        devnull: ->(&block) { File.open(File::NULL, File::WRONLY, &block) },
+        stdout:  $stdout,
+        stderr:  $stderr,
+        io:      IO,
+        marshal: Marshal,
+        process: Process
+      ),
       jobs:              ::Parallel.processor_count,
       kernel:            Kernel,
       load_path:         $LOAD_PATH,

data/lib/mutant/ast/meta/const.rb

@@ -9,6 +9,8 @@ module Mutant
 
         children :base, :name
 
+        public :base, :name
+
         # Test if AST node is possibly a top level constant
         #
         # @return [Boolean]

data/lib/mutant/ast/meta/optarg.rb

@@ -11,6 +11,8 @@ module Mutant
 
         children :name, :default_value
 
+        public :name, :default_value
+
         # Test if optarg definition intends to be used
         #
         # @return [Boolean]

data/lib/mutant/ast/meta/resbody.rb

@@ -8,6 +8,8 @@ module Mutant
         include NamedChildren, Concord.new(:node)
 
         children :captures, :assignment, :body
+
+        public :captures, :assignment, :body
       end # Resbody
 
     end # Meta

data/lib/mutant/ast/meta/restarg.rb

@@ -8,6 +8,8 @@ module Mutant
         include NamedChildren, Concord.new(:node)
 
         children :name
+
+        public :name
       end # Restarg
 
     end # Meta

data/lib/mutant/ast/meta/send.rb

@@ -9,6 +9,8 @@ module Mutant
 
         children :receiver, :selector
 
+        public :receiver, :selector
+
         INDEX_ASSIGNMENT_SELECTOR            = :[]=
         ATTRIBUTE_ASSIGNMENT_SELECTOR_SUFFIX = '='.freeze
 
@@ -17,6 +19,8 @@ module Mutant
         # @return [Enumerable<Parser::AST::Node>]
         alias_method :arguments, :remaining_children
 
+        public :arguments
+
         # Test if AST node is a valid assignment target
         #
         # @return [Boolean]

data/lib/mutant/ast/meta/symbol.rb

@@ -9,6 +9,8 @@ module Mutant
 
         children :name
 
+        public :name
+
       end # Symbol
     end # Meta
   end # AST

data/lib/mutant/ast/named_children.rb

@@ -42,7 +42,7 @@ module Mutant
         #
         # @return [undefined]
         def define_named_child(name, index)
-          define_method(name) do
+          define_private_method(name) do
             children.at(index)
           end
         end
@@ -53,15 +53,15 @@ module Mutant
         #
         # @return [undefined]
         def define_remaining_children(names)
-          define_method(:remaining_children_with_index) do
+          define_private_method(:remaining_children_with_index) do
             children.each_with_index.drop(names.length)
           end
 
-          define_method(:remaining_children_indices) do
+          define_private_method(:remaining_children_indices) do
             children.each_index.drop(names.length)
           end
 
-          define_method(:remaining_children) do
+          define_private_method(:remaining_children) do
             children.drop(names.length)
           end
         end
@@ -76,6 +76,16 @@ module Mutant
           define_remaining_children(names)
         end
 
+        # Define private method
+        #
+        # @param [Symbol] name
+        #
+        # @return [undefined]
+        def define_private_method(name, &block)
+          define_method(name, &block)
+          private(name)
+        end
+
       end # ClassMethods
     end # NamedChildren
   end # AST

data/lib/mutant/ast/nodes.rb

@@ -1,6 +1,8 @@
 module Mutant
   module AST
     # Singleton nodes
+    #
+    # :reek:TooManyConstants
     module Nodes
       extend Sexp
 
@@ -16,6 +18,6 @@ module Mutant
       N_ZSUPER            = s(:zsuper)
       N_EMPTY_SUPER       = s(:super)
 
-    end # Node
+    end # Nodes
   end # AST
 end # Mutant

data/lib/mutant/ast/regexp.rb

@@ -0,0 +1,53 @@
+module Mutant
+  module AST
+    # Regexp source mapper
+    module Regexp
+      UNSUPPORTED_EXPRESSION_TYPE = :conditional
+
+      private_constant(*constants(false))
+
+      # Parse regex string into expression
+      #
+      # @param regexp [String]
+      #
+      # @return [Regexp::Expression]
+      def self.parse(regexp)
+        ::Regexp::Parser.parse(
+          regexp,
+          "ruby/#{RUBY_VERSION.split('.').first(2).join('.')}"
+        )
+      end
+
+      # Check if expression is supported by mapper
+      #
+      # @param expression [Regexp::Expression]
+      #
+      # @return [Boolean]
+      def self.supported?(expression)
+        expression.terminal? || expression.all? do |subexp|
+          !subexp.type.equal?(UNSUPPORTED_EXPRESSION_TYPE) && supported?(subexp)
+        end
+      end
+
+      # Convert expression into ast node
+      #
+      # @param expression [Regexp::Expression]
+      #
+      # @return [Parser::AST::Node]
+      def self.to_ast(expression)
+        ast_type = :"regexp_#{expression.token}_#{expression.type}"
+
+        Transformer.lookup(ast_type).to_ast(expression)
+      end
+
+      # Convert node into expression
+      #
+      # @param node [Parser::AST::Node]
+      #
+      # @return [Regexp::Expression]
+      def self.to_expression(node)
+        Transformer.lookup(node.type).to_expression(node)
+      end
+    end # Regexp
+  end # AST
+end # Mutant

data/lib/mutant/ast/regexp/transformer.rb

@@ -0,0 +1,185 @@
+module Mutant
+  module AST
+    module Regexp
+      # Regexp bijective mapper
+      #
+      # Transforms parsed regular expression representation from
+      # `Regexp::Expression` instances (provided by `regexp_parser`) into
+      # equivalent representations using `Parser::AST::Node`
+      class Transformer
+        include AbstractType
+
+        REGISTRY = Registry.new
+
+        # Lookup transformer class for regular expression node type
+        #
+        # @param type [Symbol]
+        #
+        # @return [Class<Transformer>]
+        def self.lookup(type)
+          REGISTRY.lookup(type)
+        end
+
+        # Register transformer class as responsible for handling node type
+        #
+        # @param type [Symbol]
+        #
+        # @return [undefined]
+        def self.register(type)
+          REGISTRY.register(type, self)
+        end
+        private_class_method :register
+
+        # Transform expression
+        #
+        # @param expression [Regexp::Expression]
+        #
+        # @return [Parser::AST::Node]
+        def self.to_ast(expression)
+          self::ExpressionToAST.call(expression)
+        end
+
+        # Transform node
+        #
+        # @param node [Parser::AST::Node]
+        #
+        # @return [Regexp::Expression]
+        def self.to_expression(node)
+          self::ASTToExpression.call(node)
+        end
+
+        # Abstract expression transformer
+        class ExpressionToAST
+          PREFIX = :regexp
+
+          include Concord.new(:expression), Procto.call, AST::Sexp, AbstractType, Adamantium
+
+        private
+
+          # Node with provided children using node type constructed in `type`
+          #
+          # @param [Object,Parser::AST::Node] child of node
+          #
+          # @return [Parser::AST::Node]
+          def ast(*children)
+            s(type, *children)
+          end
+
+          # Wrap provided node in a quantifier
+          #
+          # @param node [Parser::AST::Node]
+          #
+          # @return [Parser::AST::Node]
+          #   quantifier node wrapping provided node if expression is quantified
+          #
+          # @return [Parser::AST::Node]
+          #   original node otherwise
+          def quantify(node)
+            return node unless expression.quantified?
+
+            Quantifier.to_ast(expression.quantifier).append(node)
+          end
+
+          # Transformed children of expression
+          #
+          # @return [Array<Parser::AST::Node>]
+          def children
+            expression.expressions.map(&Regexp.method(:to_ast))
+          end
+
+          # Node type constructed from token and type of `Regexp::Expression`
+          #
+          # @return [Symbol]
+          def type
+            :"#{PREFIX}_#{expression.token}_#{expression.type}"
+          end
+        end # ExpressionToAST
+
+        # Abstract node transformer
+        class ASTToExpression
+          include Concord.new(:node), Procto.call, AbstractType, Adamantium
+
+          # Call generic transform method and freeze result
+          #
+          # @return [Regexp::Expression]
+          def call
+            transform.freeze
+          end
+
+        private
+
+          # Transformation of ast into expression
+          #
+          # @return [Regexp::Expression]
+          abstract_method :transform
+
+          # Transformed children of node
+          #
+          # @return [Array<Regexp::Expression>]
+          def subexpressions
+            node.children.map(&Regexp.public_method(:to_expression))
+          end
+        end # ASTToExpression
+
+        # Mixin for node transformers
+        #
+        # Helps construct a mapping from Parser::AST::Node domain to
+        # Regexp::Expression domain
+        module LookupTable
+          Mapping = Class.new.include(Concord::Public.new(:token, :regexp_class))
+
+          # Table mapping ast types to object information for regexp domain
+          class Table
+
+            # Coerce array of mapping information into structured table
+            #
+            # @param [Array(Symbol, Array, Class<Regexp::Expression>)]
+            #
+            # @return [Table]
+            def self.create(*rows)
+              table = rows.map do |ast_type, token, klass|
+                [ast_type, Mapping.new(::Regexp::Token.new(*token), klass)]
+              end.to_h
+
+              new(table)
+            end
+
+            include Concord.new(:table), Adamantium
+
+            # Types defined by the table
+            #
+            # @return [Array<Symbol>]
+            def types
+              table.keys
+            end
+
+            # Lookup mapping information given an ast node type
+            #
+            # @param type [Symbol]
+            #
+            # @return [Mapping]
+            def lookup(type)
+              table.fetch(type)
+            end
+          end # Table
+
+        private
+
+          # Lookup expression token given node type
+          #
+          # @return [Regexp::Token]
+          def expression_token
+            self.class::TABLE.lookup(node.type).token
+          end
+
+          # Lookup regexp class given node type
+          #
+          # @return [Class<Regexp::Expression>]
+          def expression_class
+            self.class::TABLE.lookup(node.type).regexp_class
+          end
+        end # LookupTable
+      end # Transformer
+    end # Regexp
+  end # AST
+end # Mutant