mutest 0.0.1 → 0.0.2

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

@@ -0,0 +1,55 @@
+module Mutest
+  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 # Mutest

data/lib/mutest/ast/sexp.rb

@@ -0,0 +1,26 @@
+module Mutest
+  module AST
+    # Mixin for node sexp syntax
+    module Sexp
+      private
+
+      # Build node
+      #
+      # @param [Symbol] type
+      #
+      # @return [Parser::AST::Node]
+      def s(type, *children)
+        ::Parser::AST::Node.new(type, children)
+      end
+
+      # Build a negated boolean node
+      #
+      # @param [Parser::AST::Node] node
+      #
+      # @return [Parser::AST::Node]
+      def n_not(node)
+        s(:send, node, :!)
+      end
+    end # Sexp
+  end # AST
+end # Mutest

data/lib/mutest/ast/types.rb

@@ -0,0 +1,140 @@
+module Mutest
+  module AST
+    # Groups of node types
+    #
+    # :reek:TooManyConstants
+    # rubocop:disable Metrics/ModuleLength
+    module Types
+      symbolset = ->(strings) { strings.map(&:to_sym).to_set.freeze }
+
+      ASSIGNABLE_VARIABLES = symbolset.(%w[ivasgn lvasgn cvasgn gvasgn])
+
+      INDEX_ASSIGN_OPERATOR = :[]=
+
+      # Set of nodes that cannot be on the LHS of an assignment
+      NOT_ASSIGNABLE         = symbolset.(%w[int float str dstr class module self nil])
+
+      # Set of op-assign types
+      OP_ASSIGN              = symbolset.(%w[or_asgn and_asgn op_asgn])
+      # Set of node types that are not valid when emitted standalone
+      NOT_STANDALONE         = symbolset.(%w[splat restarg block_pass])
+      INDEX_OPERATORS        = symbolset.(%w[[] []=])
+      UNARY_METHOD_OPERATORS = symbolset.(%w[~@ +@ -@ !])
+
+      # Operators ruby implements as methods
+      METHOD_OPERATORS = symbolset.(%w[
+        <=> === []= [] <= >= == !~ != =~ <<
+        >> ** * % / | ^ & < > + - ~@ +@ -@ !
+      ])
+
+      BINARY_METHOD_OPERATORS = symbolset.(
+        METHOD_OPERATORS - (INDEX_OPERATORS + UNARY_METHOD_OPERATORS)
+      )
+
+      OPERATOR_METHODS = symbolset.(
+        METHOD_OPERATORS + INDEX_OPERATORS + UNARY_METHOD_OPERATORS
+      )
+
+      # Nodes that are NOT handled by mutest.
+      #
+      # not - 1.8 only, mutest does not support 1.8
+      #
+      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_bol_escape
+        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 mutest / unparser.
+      GENERATED = symbolset.(%w[empty])
+
+      EXTRA = symbolset.(GENERATED + REGEXP)
+
+      # All node types mutest handles
+      ALL = symbolset.((Parser::Meta::NODE_TYPES + EXTRA) - BLACKLIST)
+    end # Types
+  end # AST
+end # Mutest

data/lib/mutest/cli.rb

@@ -0,0 +1,196 @@
+module Mutest
+  # Commandline parser / runner
+  class CLI
+    include Adamantium::Flat, Equalizer.new(:config), Procto.call(:config)
+
+    # Error failed when CLI argv is invalid
+    Error = Class.new(RuntimeError)
+
+    # Run cli with arguments
+    #
+    # @param [Array<String>] arguments
+    #
+    # @return [Boolean]
+    def self.run(arguments)
+      Runner.call(Env::Bootstrap.call(call(arguments))).success?
+    rescue Error => exception
+      $stderr.puts(exception.message)
+      false
+    end
+
+    # Initialize object
+    #
+    # @param [Array<String>]
+    #
+    # @return [undefined]
+    def initialize(arguments)
+      @config = Config::DEFAULT
+
+      parse(arguments)
+    end
+
+    # Config parsed from CLI
+    #
+    # @return [Config]
+    attr_reader :config
+
+    private
+
+    # Parse the command-line options
+    #
+    # @param [Array<String>] arguments
+    #   Command-line options and arguments to be parsed.
+    #
+    # @fail [Error]
+    #   An error occurred while parsing the options.
+    #
+    # @return [undefined]
+    def parse(arguments)
+      opts =
+        OptionParser.new do |builder|
+          builder.banner = 'usage: mutest [options] MATCH_EXPRESSION ...'
+          %i[add_environment_options add_mutation_options add_filter_options add_debug_options].each do |name|
+            __send__(name, builder)
+          end
+        end
+
+      parse_match_expressions(opts.parse!(arguments))
+    rescue OptionParser::ParseError => error
+      raise(Error, error)
+    end
+
+    # Parse matchers
+    #
+    # @param [Array<String>] expressions
+    #
+    # @return [undefined]
+    def parse_match_expressions(expressions)
+      expressions.each do |expression|
+        add_matcher(:match_expressions, config.expression_parser.(expression))
+      end
+    end
+
+    # Add environmental options
+    #
+    # @param [Object] opts
+    #
+    # @return [undefined]
+    #
+    # rubocop:disable MethodLength
+    def add_environment_options(opts)
+      opts.separator('Environment:')
+      opts.on('--zombie', 'Run mutest zombified') do
+        with(zombie: true)
+      end
+      opts.on('-I', '--include DIRECTORY', 'Add DIRECTORY to $LOAD_PATH') do |directory|
+        add(:includes, directory)
+      end
+      opts.on('-r', '--require NAME', 'Require file with NAME') do |name|
+        add(:requires, name)
+      end
+      opts.on('-j', '--jobs NUMBER', 'Number of kill jobs. Defaults to number of processors.') do |number|
+        with(jobs: Integer(number))
+      end
+    end
+
+    # Use integration
+    #
+    # @param [String] name
+    #
+    # @return [undefined]
+    def setup_integration(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 mutest-#{name})"
+    end
+
+    # Add mutation options
+    #
+    # @param [OptionParser] opts
+    #
+    # @return [undefined]
+    def add_mutation_options(opts)
+      opts.separator(nil)
+      opts.separator('Options:')
+
+      opts.on('--use INTEGRATION', 'Use INTEGRATION to kill mutations', &method(:setup_integration))
+    end
+
+    # Add filter options
+    #
+    # @param [OptionParser] opts
+    #
+    # @return [undefined]
+    def add_filter_options(opts)
+      opts.on('--ignore-subject EXPRESSION', 'Ignore subjects that match EXPRESSION as prefix') do |pattern|
+        add_matcher(:ignore_expressions, config.expression_parser.(pattern))
+      end
+      opts.on('--since REVISION', 'Only select subjects touched since REVISION') do |revision|
+        add_matcher(
+          :subject_filters,
+          Repository::SubjectFilter.new(
+            Repository::Diff.new(
+              config: config,
+              from:   Repository::Diff::HEAD,
+              to:     revision
+            )
+          )
+        )
+      end
+    end
+
+    # Add debug options
+    #
+    # @param [OptionParser] opts
+    #
+    # @return [undefined]
+    def add_debug_options(opts)
+      opts.on('--fail-fast', 'Fail fast') do
+        with(fail_fast: true)
+      end
+      opts.on('--version', 'Print mutests version') do
+        puts("mutest-#{VERSION}")
+        config.kernel.exit
+      end
+      opts.on_tail('-h', '--help', 'Show this message') do
+        puts(opts.to_s)
+        config.kernel.exit
+      end
+    end
+
+    # With configuration
+    #
+    # @param [Hash<Symbol, Object>] attributes
+    #
+    # @return [undefined]
+    def with(attributes)
+      @config = config.with(attributes)
+    end
+
+    # Add configuration
+    #
+    # @param [Symbol] attribute
+    #   the attribute to add to
+    #
+    # @param [Object] value
+    #   the value to add
+    #
+    # @return [undefined]
+    def add(attribute, value)
+      with(attribute => config.public_send(attribute) + [value])
+    end
+
+    # Add matcher configuration
+    #
+    # @param [Symbol] attribute
+    #   the attribute to add to
+    #
+    # @param [Object] value
+    #   the value to add
+    #
+    # @return [undefined]
+    def add_matcher(attribute, value)
+      with(matcher: config.matcher.add(attribute, value))
+    end
+  end # CLI
+end # Mutest

data/lib/mutest/color.rb

@@ -0,0 +1,39 @@
+module Mutest
+  # Class to colorize strings
+  class Color
+    include Adamantium::Flat, Concord.new(:code)
+
+    # Format text with color
+    #
+    # @param [String] text
+    #
+    # @return [String]
+    def format(text)
+      "\e[#{code}m#{text}\e[0m"
+    end
+
+    NONE = Class.new(self) do
+      # Format null color
+      #
+      # @param [String] text
+      #
+      # @return [String]
+      #   the argument string
+      def format(text)
+        text
+      end
+
+    private # rubocop:disable AccessModifierIndentation
+
+      # Initialize null color
+      #
+      # @return [undefined]
+      def initialize
+      end
+    end.new
+
+    RED   = Color.new(31)
+    GREEN = Color.new(32)
+    BLUE  = Color.new(34)
+  end # Color
+end # Mutest