mutant 0.2.20 → 0.3.0.beta2

data/lib/mutant/cli.rb

@@ -1,9 +1,12 @@
+require 'optparse'
+
 module Mutant
+
   # Comandline parser
   class CLI
-    include Adamantium::Flat, Equalizer.new(:matcher, :filter, :strategy, :reporter)
+    include Adamantium::Flat, Equalizer.new(:config)
 
-    # Error raised when CLI argv is inalid
+    # Error raised when CLI argv is invalid
     Error = Class.new(RuntimeError)
 
     EXIT_FAILURE = 1
@@ -18,31 +21,49 @@ module Mutant
     #
     # @api private
     #
-    def self.run(*arguments)
-      error = Runner.run(new(*arguments)).fail?
-      error ? EXIT_FAILURE : EXIT_SUCCESS
+    def self.run(arguments)
+      config = new(arguments).config
+      runner = Runner::Config.run(config)
+      runner.success? ? EXIT_SUCCESS : EXIT_FAILURE
     rescue Error => exception
       $stderr.puts(exception.message)
       EXIT_FAILURE
     end
 
-    # Return matcher
+    # Initialize objecct
     #
-    # @return [Mutant::Matcher]
+    # @param [Array<String>]
     #
-    # @raise [CLI::Error]
-    #   raises error when matcher is not given
+    # @return [undefined]
     #
     # @api private
     #
-    def matcher
-      if @matchers.empty?
-        raise Error, 'No matchers given'
-      end
+    def initialize(arguments=[])
+      @filters, @matchers = [], []
+
+      parse(arguments)
+      strategy
+      matcher
+    end
 
-      Mutant::Matcher::Chain.build(@matchers)
+    # Return config
+    #
+    # @return [Config]
+    #
+    # @api private
+    #
+    def config
+      Config.new(
+        :debug    => debug?,
+        :matcher  => matcher,
+        :filter   => filter,
+        :strategy => strategy,
+        :reporter => reporter
+      )
     end
-    memoize :matcher
+    memoize :config
+
+  private
 
     # Test for running in debug mode
     #
@@ -80,8 +101,7 @@ module Mutant
     # @api private
     #
     def strategy
-      @strategy || raise(Error, 'no strategy was set!')
-      @strategy.new(self)
+      @strategy or raise(Error, 'No strategy was set!')
     end
     memoize :strategy
 
@@ -92,217 +112,150 @@ module Mutant
     # @api private
     #
     def reporter
-      Mutant::Reporter::CLI.new(self)
+      Reporter::CLI.new($stdout)
     end
     memoize :reporter
 
-  private
-
-    OPTIONS = {
-      '--code'               => [:add_filter,           Mutation::Filter::Code    ],
-      '-I'                   => [:add_load_path                                   ],
-      '--include'            => [:add_load_path                                   ],
-      '-r'                   => [:require_library                                 ],
-      '--require'            => [:require_library                                 ],
-      '--debug'              => [:set_debug                                       ],
-      '-d'                   => [:set_debug                                       ],
-      '--rspec-unit'         => [:set_strategy,         Strategy::Rspec::Unit     ],
-      '--rspec-full'         => [:set_strategy,         Strategy::Rspec::Full     ],
-      '--rspec-dm2'          => [:set_strategy,         Strategy::Rspec::DM2      ],
-      '--static-fail'        => [:set_strategy,         Strategy::Static::Fail    ],
-      '--static-success'     => [:set_strategy,         Strategy::Static::Success ]
-    }.freeze
-
-    OPTION_PATTERN = %r(\A-(?:-)?[a-zA-Z0-9\-]+\z).freeze
-
-    # Initialize CLI 
+    # Return matcher
     #
-    # @param [Array<String>] arguments
+    # @return [Mutant::Matcher]
     #
-    # @return [undefined]
+    # @raise [CLI::Error]
+    #   raises error when matcher is not given
     #
     # @api private
     #
-    def initialize(arguments)
-      @filters, @matchers = [], []
-
-      @arguments, @index = arguments, 0
-
-      while @index < @arguments.length
-        dispatch
+    def matcher
+      if @matchers.empty?
+        raise Error, 'No matchers given'
       end
 
-      strategy
-      matcher
+      Matcher::Chain.build(@matchers)
     end
+    memoize :matcher
 
-    # Return option for argument with index
+    # Add mutation filter
+    #
+    # @param [Class<Mutant::Filter>] klass
     #
-    # @param [Fixnum] index
+    # @param [String] filter
     #
-    # @return [String]
+    # @return [undefined]
     #
     # @api private
     #
-    def option(index)
-      @arguments.fetch(index+1)
+    def add_filter(klass,filter)
+      @filters << klass.new(filter)
     end
 
-    # Return current argument
-    #
-    # @return [String]
+    # Set debug mode
     #
     # @api private
     #
-    def current_argument
-      @arguments.fetch(@index)
+    # @return [undefined]
+    #
+    def set_debug
+      @debug = true
     end
 
-    # Return current option value
-    #
-    # @return [String]
+    # Set strategy
     #
-    # @raise [CLI::Error]
-    #   raises error when option is missing
+    # @param [Strategy] strategy
     #
     # @api private
     #
-    def current_option_value
-      @arguments.fetch(@index+1)
-    rescue IndexError
-      raise Error, "#{current_argument.inspect} is missing an argument"
-    end
-
-    # Process current argument
-    #
     # @return [undefined]
     #
-    # @api private
-    #
-    def dispatch
-      if OPTION_PATTERN =~ current_argument
-        dispatch_option
-      else
-        dispatch_matcher
-      end
+    def set_strategy(strategy)
+      @strategy = strategy
     end
 
-    # Move processed argument by amount
-    #
-    # @param [Fixnum] amount
-    #   the amount of arguments to be consumed
+    # Parse the command-line options
     #
-    # @return [undefined]
+    # @param [Array<String>] arguments
+    #   Command-line options and arguments to be parsed.
     #
-    # @api private
+    # @raise [Error]
+    #   An error occurred while parsing the options.
     #
-    def consume(amount)
-      @index += amount
-    end
-
-    # Process matcher argument
-    # 
     # @return [undefined]
     #
     # @api private
     #
-    def dispatch_matcher
-      argument = current_argument
-      matcher = Mutant::Matcher.from_string(argument)
+    def parse(arguments)
+      opts = OptionParser.new do |opts|
+        opts.banner = 'usage: mutant STRATEGY [options] MATCHERS ...'
+        opts.separator ''
+        opts.separator 'Strategies:'
 
-      unless matcher
-        raise Error, "Invalid matcher syntax: #{argument.inspect}"
+        add_strategies(opts)
+        add_options(opts)
       end
 
-      @matchers << matcher
+      matchers =
+        begin
+          opts.parse!(arguments)
+        rescue OptionParser::ParseError => error
+          raise(Error, error.message, error.backtrace)
+        end
 
-      consume(1)
+      parse_matchers(matchers)
     end
 
-    # Process option argument
+    # Parse matchers
     #
-    # @return [Undefined]
-    #
-    # @api private
-    #
-    def dispatch_option
-      argument = current_argument
-      arguments = *OPTIONS.fetch(argument) do
-        raise Error, "Unknown option: #{argument.inspect}"
-      end
-      send(*arguments)
-    end
-
-    # Add mutation filter
-    #
-    # @param [Class<Mutant::Filter>] klass
+    # @param [Enumerable<String>] patterns
     #
     # @return [undefined]
     #
     # @api private
     #
-    def add_filter(klass)
-      @filters << klass.new(current_option_value)
-      consume(2)
+    def parse_matchers(patterns)
+      patterns.each do |pattern|
+        matcher = Classifier.build(pattern)
+        @matchers << matcher if matcher
+      end
     end
 
-    # Add load path
+    # Add strategies
     #
-    # @api private
+    # @param [Object]
     #
     # @return [undefined]
     #
-    def add_load_path
-      $LOAD_PATH << current_option_value
-      consume(2)
-    end
-
-    # Enable rspec
-    #
     # @api private
     #
-    # @return [self]
-    #
-    # @api private
-    #
-    def enable_rspec
-      consume(1)
-      @rspec = true
+    def add_strategies(opts)
+      opts.on('--rspec-unit', 'executes all specs under ./spec/unit') do
+        set_strategy Strategy::Rspec::Unit
+      end.on('--rspec-full', 'executes all specs under ./spec') do
+        set_strategy Strategy::Rspec::Full
+      end.on('--rspec-dm2', 'executes spec/unit/namespace/class/method_spec.rb') do
+        set_strategy Strategy::Rspec::DM2
+      end
     end
 
-    # Set debug mode
+    # Add options
     #
-    # @api private
+    # @param [Object]
     #
     # @return [undefined]
     #
-    def set_debug
-      consume(1)
-      @debug = true
-    end
-
-    # Set strategy
-    #
-    # @param [Strategy] strategy
-    #
     # @api private
     #
-    # @return [undefined]
-    #
-    def set_strategy(strategy)
-      consume(1)
-      @strategy = strategy
+    def add_options(opts)
+      opts.separator ''
+      opts.separator 'Options:'
+
+      opts.on('--code FILTER', 'Adds a code filter') do |filter|
+        add_filter Mutation::Filter::Code, filter
+      end.on('-d','--debug', 'Enable debugging output') do
+        set_debug
+      end.on_tail('-h', '--help', 'Show this message') do
+        puts opts
+        exit
+      end
     end
 
-    # Require library
-    #
-    # @api private
-    # 
-    # @return [undefined]
-    #
-    def require_library
-      require(current_option_value)
-      consume(2)
-    end
-  end
-end
+  end # CLI
+end # Mutant

data/lib/mutant/color.rb

@@ -57,5 +57,5 @@ module Mutant
     RED   = Color.new(31)
     GREEN = Color.new(32)
     BLUE  = Color.new(34)
-  end
-end
+  end # Color
+end # Mutant

data/lib/mutant/config.rb

@@ -0,0 +1,27 @@
+module Mutant
+  # The configuration of a mutator run
+  class Config
+    include Adamantium::Flat, Anima.new(
+      :debug, :strategy, :matcher, :filter, :reporter
+    )
+
+    # Enumerate subjects
+    #
+    # @api private
+    #
+    # @return [self]
+    #   if block given
+    #
+    # @return [Enumerator<Subject>]
+    #   otherwise
+    #
+    # @api private
+    #
+    def subjects(&block)
+      return to_enum(__method__) unless block_given?
+      matcher.each(&block)
+      self
+    end
+
+  end # Config
+end # Mutant

data/lib/mutant/constants.rb

@@ -1,16 +1,12 @@
 module Mutant
 
-  # The list of ruby kewords from http://ruby-doc.org/docs/keywords/1.9/
-  KEYWORDS = %w(
-    BEGIN END __ENCODING__ __END__ __FILE__
-    __LINE__ alias and begin break case class
-    def define do else elsif end ensure false
-    for if in module next nil not or redo
-    rescue retry return self super then true
-    undef unless until when while yield
-  ).map(&:to_sym).to_set.freeze
+  METHOD_POSTFIX_EXPANSIONS = {
+    '?' => '_predicate',
+    '=' => '_writer',
+    '!' => '_bang'
+  }.freeze
 
-  BINARY_METHOD_OPERATOR_EXPANSIONS = {
+  OPERATOR_EXPANSIONS = {
     :<=>  => :spaceship_operator,
     :===  => :case_equality_operator,
     :[]=  => :element_writer,
@@ -33,17 +29,36 @@ module Mutant
     :<    => :less_than_operator,
     :>    => :greater_than_operator,
     :+    => :addition_operator,
-    :-    => :substraction_operator
-  }.freeze
-
-  UNARY_METHOD_OPERATOR_EXPANSIONS = {
+    :-    => :substraction_operator,
     :~@   => :unary_match_operator,
     :+@   => :unary_addition_operator,
     :-@   => :unary_substraction_operator,
     :'!'  => :negation_operator
   }.freeze
 
-  BINARY_METHOD_OPERATORS = BINARY_METHOD_OPERATOR_EXPANSIONS.keys.to_set.freeze
+  INDEX_OPERATORS = [ :[], :[]= ].freeze
+
+  UNARY_METHOD_OPERATORS = [
+    :~@, :+@, :-@, :'!'
+  ].freeze
+
+  BINARY_METHOD_OPERATORS = (OPERATOR_EXPANSIONS.keys - (INDEX_OPERATORS + UNARY_METHOD_OPERATORS)).to_set.freeze
 
-  OPERATOR_EXPANSIONS = BINARY_METHOD_OPERATOR_EXPANSIONS.merge(UNARY_METHOD_OPERATOR_EXPANSIONS).freeze
-end
+  # Hopefully all types parser does generate
+  NODE_TYPES = [
+    :lvasgn, :ivasgn, :cvasgn, :gvasgn,
+    :casgn, :masgn, :mlhs, :break, :rescue,
+    :ensure, :resbody, :begin, :retry, :arg_expr,
+    :args, :blockarg, :optarg, :kwrestarg, :kwoptarg,
+    :kwarg, :restarg, :arg, :block_pass, :or, :and,
+    :next, :undef, :if, :module, :cbase, :block, :send,
+    :zsuper, :super, :empty, :alias, :for, :redo,
+    :return, :splat, :not, :defined?, :op_asgn, :self,
+    :true, :false, :nil, :dstr, :dsym, :regexp,
+    :regopt, :int, :str, :float, :sym, :pair, :hash, :array,
+    :xstr, :def, :defs, :case, :when, :ivar, :lvar, :cvar, :gvar,
+    :back_ref, :const, :nth_ref, :class, :sclass, :yield,
+    :match_with_lvasgn, :match_current_line, :irange, :erange,
+    :or_asgn
+  ].to_set.freeze
+end # Mutant,

data/lib/mutant/context/scope.rb

@@ -3,10 +3,11 @@ module Mutant
     # Scope context for mutation (Class or Module)
     class Scope < self
       include Adamantium::Flat, Equalizer.new(:scope, :source_path)
+      extend NodeHelpers
 
       # Return AST wrapping mutated node
       #
-      # @return [Rubinius::AST::Script]
+      # @return [Parser::AST::Node]
       #
       # @api private
       #
@@ -16,26 +17,36 @@ module Mutant
         end
       end
 
+      # Return identification
+      #
+      # @return [String]
+      #
+      # @ai private
+      #
+      def identification
+        scope.name
+      end
+
       # Wrap node into ast node
       #
-      # @param [Class, Module] scope 
-      # @param [Rubinius::AST::Node] node
+      # @param [Class, Module] scope
+      # @param [Parser::AST::Node] node
       #
-      # @return [Rubinius::AST::Class]
+      # @return [Parser::AST::Class]
       #   if scope is of kind Class
       #
-      # @return [Rubinius::AST::Module]
+      # @return [Parser::AST::Module]
       #   if scope is of kind module
       #
       # @api private
       #
       def self.wrap(scope, node)
-        name = scope.name.split('::').last.to_sym
+        name = s(:const, nil, scope.name.split('::').last.to_sym)
         case scope
         when ::Class
-          ::Rubinius::AST::Class.new(0, name, nil, node)
+          s(:class, name, nil, node)
         when ::Module
-          ::Rubinius::AST::Module.new(0, name, node)
+          s(:module, name, node)
         else
           raise "Cannot wrap scope: #{scope.inspect}"
         end
@@ -66,6 +77,16 @@ module Mutant
         name_nesting.last
       end
 
+      # Return name
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def name
+        scope.name
+      end
+
       # Return scope wrapped by context
       #
       # @return [::Module|::Class]
@@ -88,46 +109,6 @@ module Mutant
         @scope = scope
       end
 
-      # Return scope AST class
-      #
-      # @return [Rubinius::AST::Node]
-      #
-      # @api private
-      #
-      def scope_class
-        self.class::SCOPE_CLASS
-      end
-
-      # Return keyword
-      #
-      # @return [Rubinius::AST::Node]
-      #
-      # @api private
-      #
-      def keyword
-        self.class::KEYWORD
-      end
-
-      # Return new root ast
-      #
-      # @return [Rubinius::AST::Node]
-      #
-      # @api private
-      #
-      def root_ast
-        "#{keyword} #{qualified_name}; end".to_ast
-      end
-
-      # Return qualified name of scope
-      #
-      # @return [String]
-      #
-      # @api private
-      #
-      def qualified_name
-        scope.name
-      end
-
       # Return nesting of names of scope
       #
       # @return [Array<String>]
@@ -138,6 +119,7 @@ module Mutant
         scope.name.split('::')
       end
       memoize :name_nesting
-    end
-  end
-end
+
+    end # Scope
+  end # Context
+end # Mutant

data/lib/mutant/context.rb

@@ -1,36 +1,25 @@
 module Mutant
   # An abstract context where mutations can be appied to.
   class Context
-    include Adamantium::Flat, AbstractType
+    include Adamantium::Flat, AbstractType, Concord::Public.new(:source_path)
 
     # Return root ast node
     #
-    # @return [Rubinis::AST::Script]
+    # @param [Parser::AST::Node] node
+    #
+    # @return [Parser::AST::Node]
     #
     # @api private
     #
     abstract_method :root
 
-    # Return source path
+    # Return identification
     #
     # @return [String]
     #
     # @api private
     #
-    attr_reader :source_path
-
-  private
+    abstract_method :identification
 
-    # Initialize context
-    #
-    # @param [String] source_path
-    #
-    # @return [undefined]
-    #
-    # @api private
-    #
-    def initialize(source_path)
-      @source_path = source_path
-    end
-  end
-end
+  end # Context
+end # Mutant

data/lib/mutant/differ.rb

@@ -3,7 +3,7 @@ module Mutant
   class Differ
     include Adamantium::Flat
 
-    # Return source diff 
+    # Return source diff
     #
     # @return [String]
     #
@@ -20,7 +20,7 @@ module Mutant
     end
     memoize :diff
 
-    # Return colorized source diff 
+    # Return colorized source diff
     #
     # @return [String]
     #
@@ -40,7 +40,7 @@ module Mutant
 
     # Initialize differ object
     #
-    # @param [String] old 
+    # @param [String] old
     # @param [String] new
     #
     # @return [undefined]
@@ -107,6 +107,6 @@ module Mutant
         Color::NONE
       end.format(line)
     end
-  end
-end
 
+  end # Differ
+end # Mutant