mutant 0.8.10 → 0.8.11

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

@@ -0,0 +1,55 @@
+module Mutant
+  module AST
+    module Regexp
+      class Transformer
+        # Regexp AST transformer for nodes that encode a text value
+        class Text < self
+          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
+          class ExpressionToAST < Transformer::ExpressionToAST
+            # Transform expression into node preserving text value
+            #
+            # @return [Parser::AST::Node]
+            def call
+              quantify(ast(expression.text))
+            end
+          end # ExpressionToAST
+
+          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
+          class ASTToExpression < Transformer::ASTToExpression
+            include LookupTable
+
+            TABLE = Table.create(
+              [:regexp_literal_literal,       %i[literal literal],       ::Regexp::Expression::Literal],
+              [:regexp_comment_group,         %i[group comment],         ::Regexp::Expression::Group::Comment],
+              [:regexp_named_group,           %i[group named],           ::Regexp::Expression::Group::Named],
+              [:regexp_number_backref,        %i[backref number],        ::Regexp::Expression::Backreference::Number],
+              [:regexp_name_call_backref,     %i[backref name_call],     ::Regexp::Expression::Backreference::NameCall],
+              [:regexp_whitespace_free_space, %i[free_space whitespace], ::Regexp::Expression::WhiteSpace],
+              [:regexp_comment_free_space,    %i[free_space comment],    ::Regexp::Expression::WhiteSpace],
+              [:regexp_hex_escape,            %i[escape hex],            ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_literal_escape,        %i[escape literal],        ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_backslash_escape,      %i[escape backslash],      ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_tab_escape,            %i[escape tab],            ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_codepoint_list_escape, %i[escape codepoint_list], ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_control_escape,        %i[escape control],        ::Regexp::Expression::EscapeSequence::Control],
+              [:regexp_meta_sequence_escape,  %i[escape meta_sequence],  ::Regexp::Expression::EscapeSequence::Control]
+            )
+
+          private
+
+            # Transform node to expression with text value
+            #
+            # @return [Regexp::Expression]
+            def transform
+              token = expression_token.dup
+              token.text = Util.one(node.children)
+              expression_class.new(token)
+            end
+          end # ASTToExpression
+
+          ASTToExpression::TABLE.types.each(&method(:register))
+        end # Text
+      end # Transformer
+    end # Regexp
+  end # AST
+end # Mutant

data/lib/mutant/ast/types.rb

@@ -1,6 +1,9 @@
 module Mutant
   module AST
     # Groups of node types
+    #
+    # :reek:TooManyConstants
+    # rubocop:disable Metrics/ModuleLength
     module Types
       symbolset = ->(strings) { strings.map(&:to_sym).to_set.freeze }
 
@@ -38,15 +41,99 @@ module Mutant
       #
       BLACKLIST = symbolset.(%w[not])
 
+      # Nodes generated by regular expression body parsing
+      REGEXP = symbolset.(%w[
+        regexp_alpha_property
+        regexp_alternation_escape
+        regexp_alternation_meta
+        regexp_atomic_group
+        regexp_backslash_escape
+        regexp_bell_escape
+        regexp_bol_anchor
+        regexp_bos_anchor
+        regexp_capture_group
+        regexp_carriage_escape
+        regexp_character_set
+        regexp_character_set
+        regexp_codepoint_list_escape
+        regexp_comment_free_space
+        regexp_comment_group
+        regexp_control_escape
+        regexp_digit_type
+        regexp_dot_escape
+        regexp_dot_meta
+        regexp_eol_anchor
+        regexp_eol_escape
+        regexp_eos_anchor
+        regexp_eos_ob_eol_anchor
+        regexp_escape_escape
+        regexp_form_feed_escape
+        regexp_greedy_interval
+        regexp_greedy_one_or_more
+        regexp_greedy_zero_or_more
+        regexp_greedy_zero_or_one
+        regexp_group_close_escape
+        regexp_group_open_escape
+        regexp_hex_escape
+        regexp_hex_type
+        regexp_interval_close_escape
+        regexp_interval_open_escape
+        regexp_letter_any_property
+        regexp_literal_escape
+        regexp_literal_literal
+        regexp_lookahead_assertion
+        regexp_lookbehind_assertion
+        regexp_mark_keep
+        regexp_match_start_anchor
+        regexp_meta_sequence_escape
+        regexp_name_call_backref
+        regexp_named_group
+        regexp_newline_escape
+        regexp_nlookahead_assertion
+        regexp_nlookbehind_assertion
+        regexp_nondigit_type
+        regexp_nonspace_type
+        regexp_nonword_boundary_anchor
+        regexp_nonword_type
+        regexp_nonhex_type
+        regexp_number_backref
+        regexp_one_or_more_escape
+        regexp_open_conditional
+        regexp_options_group
+        regexp_passive_group
+        regexp_possessive_interval
+        regexp_possessive_one_or_more
+        regexp_possessive_zero_or_more
+        regexp_possessive_zero_or_one
+        regexp_reluctant_interval
+        regexp_reluctant_one_or_more
+        regexp_reluctant_zero_or_more
+        regexp_root_expression
+        regexp_script_arabic_property
+        regexp_script_han_property
+        regexp_script_hangul_property
+        regexp_script_hiragana_property
+        regexp_script_katakana_property
+        regexp_sequence_expression
+        regexp_set_close_escape
+        regexp_set_open_escape
+        regexp_space_type
+        regexp_tab_escape
+        regexp_vertical_tab_escape
+        regexp_whitespace_free_space
+        regexp_word_boundary_anchor
+        regexp_word_type
+        regexp_zero_or_more_escape
+        regexp_zero_or_one_escape
+      ])
+
       # Nodes that are NOT generated by parser but used by mutant / unparser.
-      EXTRA = symbolset.(%w[empty])
+      GENERATED = symbolset.(%w[empty])
 
-      # Nodes that are currently missing from Parser::Meta::NODE_TYPES
-      # * https://github.com/whitequark/parser/pull/251
-      MISSING = symbolset.(%w[csend])
+      EXTRA = symbolset.(GENERATED + REGEXP)
 
       # All node types mutant handles
-      ALL = symbolset.((Parser::Meta::NODE_TYPES + EXTRA + MISSING) - BLACKLIST)
+      ALL = symbolset.((Parser::Meta::NODE_TYPES + EXTRA) - BLACKLIST)
     end # Types
   end # AST
 end # Mutant

data/lib/mutant/cli.rb

@@ -1,8 +1,5 @@
 module Mutant
-
-  # Commandline parser
-  #
-  # rubocop:disable ClassLength
+  # Commandline parser / runner
   class CLI
     include Adamantium::Flat, Equalizer.new(:config), Procto.call(:config)
 
@@ -103,7 +100,7 @@ module Mutant
     #
     # @return [undefined]
     def setup_integration(name)
-      with(integration: Integration.setup(name))
+      with(integration: Integration.setup(config.kernel, name))
     rescue LoadError
       raise Error, "Could not load integration #{name.inspect} (you may want to try installing the gem mutant-#{name})"
     end
@@ -117,12 +114,6 @@ module Mutant
       opts.separator(nil)
       opts.separator('Options:')
 
-      opts.on(
-        '--expected-coverage COVERAGE',
-        'Fail unless COVERAGE is not reached exactly, parsed via Rational()'
-      ) do |coverage|
-        with(expected_coverage: Rational(coverage))
-      end
       opts.on('--use INTEGRATION', 'Use INTEGRATION to kill mutations', &method(:setup_integration))
     end
 
@@ -162,9 +153,6 @@ module Mutant
         puts("mutant-#{VERSION}")
         config.kernel.exit
       end
-      opts.on('-d', '--debug', 'Enable debugging output') do
-        with(debug: true)
-      end
       opts.on_tail('-h', '--help', 'Show this message') do
         puts(opts.to_s)
         config.kernel.exit

data/lib/mutant/color.rb

@@ -24,7 +24,7 @@ module Mutant
         text
       end
 
-    private
+    private # rubocop:disable AccessModifierIndentation
 
       # Initialize null color
       #

data/lib/mutant/config.rb

@@ -5,8 +5,6 @@ module Mutant
   # to current environment is being represented by the Mutant::Env object.
   class Config
     include Adamantium::Flat, Anima.new(
-      :debug,
-      :expected_coverage,
       :expression_parser,
       :fail_fast,
       :integration,
@@ -23,7 +21,7 @@ module Mutant
       :zombie
     )
 
-    %i[fail_fast zombie debug].each do |name|
+    %i[fail_fast zombie].each do |name|
       define_method(:"#{name}?") { public_send(name) }
     end
 

data/lib/mutant/expression/methods.rb

@@ -55,6 +55,6 @@ module Mutant
         Object.const_get(scope_name)
       end
 
-    end # Method
+    end # Methods
   end # Expression
 end # Mutant

data/lib/mutant/expression/namespace.rb

@@ -57,7 +57,7 @@ module Mutant
         MATCHER = Matcher::Scope
         private_constant(*constants(false))
 
-        REGEXP  = /\A#{SCOPE_NAME_PATTERN}\z/.freeze
+        REGEXP = /\A#{SCOPE_NAME_PATTERN}\z/.freeze
 
         # Matcher matcher on expression
         #
@@ -74,5 +74,5 @@ module Mutant
 
       end # Exact
     end # Namespace
-  end # Namespace
+  end # Expression
 end # Mutant

data/lib/mutant/expression/parser.rb

@@ -5,7 +5,7 @@ module Mutant
 
       class ParserError < RuntimeError
         include AbstractType
-      end
+      end # ParserError
 
       # Error raised on invalid expressions
       class InvalidExpressionError < ParserError; end

data/lib/mutant/integration.rb

@@ -4,38 +4,23 @@ module Mutant
   class Integration
     include AbstractType, Adamantium::Flat, Concord.new(:config)
 
-    REGISTRY = {}
-
     # Setup integration
     #
-    # @param [String] name
+    # Integrations are supposed to define a constant under
+    # Mutant::Integration named after the capitalized +name+
+    # parameter.
     #
-    # @return [Integration]
-    def self.setup(name)
-      require "mutant/integration/#{name}"
-      lookup(name)
-    end
-
-    # Lookup integration for name
+    # This avoids having to maintain a mutable registry.
     #
-    # @param [String] name
+    # @param kernel [Kernel]
+    # @param name [String]
     #
-    # @return [Integration]
-    #   if found
-    def self.lookup(name)
-      REGISTRY.fetch(name)
+    # @return [Class<Integration>]
+    def self.setup(kernel, name)
+      kernel.require("mutant/integration/#{name}")
+      const_get(name.capitalize)
     end
 
-    # Register integration
-    #
-    # @param [String] name
-    #
-    # @return [undefined]
-    def self.register(name)
-      REGISTRY[name] = self
-    end
-    private_class_method :register
-
     # Perform integration setup
     #
     # @return [self]
@@ -67,8 +52,6 @@ module Mutant
     # Null integration that never kills a mutation
     class Null < self
 
-      register('null')
-
       # Available tests for integration
       #
       # @return [Enumerable<Test>]
@@ -91,6 +74,5 @@ module Mutant
       end
 
     end # Null
-
   end # Integration
 end # Mutant

data/lib/mutant/isolation.rb

@@ -1,62 +1,11 @@
 module Mutant
-  # Module providing isolation
-  module Isolation
-    Error = Class.new(RuntimeError)
-
-    module None
-
-      # Call block in isolation
-      #
-      # @return [Object]
-      #
-      # @raise [Error]
-      #   if block terminates abnormal
-      def self.call(&block)
-        block.call
-      rescue => exception
-        raise Error, exception
-      end
-    end
-
-    module Fork
-
-      # Call block in isolation
-      #
-      # This isolation implements the fork strategy.
-      # Future strategies will probably use a process pool that can
-      # handle multiple mutation kills, in-isolation at once.
-      #
-      # @return [Object]
-      #   returns block execution result
-      #
-      # @raise [Error]
-      #   if block terminates abnormal
-      #
-      # rubocop:disable MethodLength
-      def self.call(&block)
-        IO.pipe(binmode: true) do |reader, writer|
-          writer.binmode
-          begin
-            pid = Process.fork do
-              File.open(File::NULL, File::WRONLY) do |file|
-                $stderr.reopen(file)
-                reader.close
-                writer.write(Marshal.dump(block.call))
-                writer.close
-              end
-            end
-
-            writer.close
-            Marshal.load(reader.read)
-          ensure
-            Process.waitpid(pid) if pid
-          end
-        end
-      rescue => exception
-        raise Error, exception
-      end
-
-    end # Fork
-
-  end # Isolator
+  class Isolation
+    include AbstractType
+
+    # Call block in isolation
+    #
+    # @return [Object]
+    #   the blocks result
+    abstract_method :call
+  end # Isolation
 end # Mutant

data/lib/mutant/isolation/fork.rb

@@ -0,0 +1,72 @@
+module Mutant
+  class Isolation
+    # Isolation via the fork(2) systemcall.
+    #
+    # We do inject so many globals and common patterns to make this unit
+    # specifiable without mocking the globals and more important: Not having
+    # mutations that bypass mocks into a real world side effect.
+    class Fork < self
+      include Anima.new(:process, :stderr, :stdout, :io, :devnull, :marshal)
+
+      # Prevent mutation from `process.fork` to `fork` to call Kernel#fork
+      undef_method :fork
+
+      # Call block in isolation
+      #
+      # @return [Object]
+      #   returns block execution result
+      #
+      # @raise [Error]
+      #   if block terminates abnormal
+      def call(&block)
+        io.pipe(binmode: true) do |pipes|
+          parent(*pipes, &block)
+        end
+      rescue => exception
+        raise Error, exception
+      end
+
+      # Handle parent process
+      #
+      # @param [IO] reader
+      # @param [IO] writer
+      #
+      # @return [undefined]
+      def parent(reader, writer, &block)
+        pid = process.fork do
+          child(reader, writer, &block)
+        end
+
+        writer.close
+        marshal.load(reader)
+      ensure
+        process.waitpid(pid) if pid
+      end
+
+      # Handle child process
+      #
+      # @param [IO] reader
+      # @param [IO] writer
+      #
+      # @return [undefined]
+      def child(reader, writer, &block)
+        reader.close
+        writer.binmode
+        writer.syswrite(marshal.dump(result(&block)))
+        writer.close
+      end
+
+      # The block result computed under silencing
+      #
+      # @return [Object]
+      def result
+        devnull.call do |null|
+          stderr.reopen(null)
+          stdout.reopen(null)
+          yield
+        end
+      end
+
+    end # Fork
+  end # Isolation
+end # Mutant