mutant 0.1.1 → 0.2.0

data/lib/mutant/cli.rb

@@ -0,0 +1,309 @@
+module Mutant
+  # Comandline parser
+  class CLI
+    include Adamantium::Flat, Equalizer.new(:matcher, :filter, :killer)
+
+    # Error raised when CLI argv is inalid
+    Error = Class.new(RuntimeError)
+
+    EXIT_FAILURE = 1
+    EXIT_SUCCESS = 0
+
+    # Run cli with arguments
+    #
+    # @param [Array<String>] arguments
+    #
+    # @return [Fixnum]
+    #   returns exit status
+    #
+    # @api private
+    #
+    def self.run(*arguments)
+      error = Runner.run(new(*arguments)).fail?
+      error ? EXIT_FAILURE : EXIT_SUCCESS
+    rescue Error => exception
+      $stderr.puts(exception.message)
+      EXIT_FAILURE
+    end
+
+    # Return matcher
+    #
+    # @return [Mutant::Matcher]
+    #
+    # @raise [CLI::Error]
+    #   raises error when matcher is not given
+    #
+    # @api private
+    #
+    def matcher
+      if @matchers.empty?
+        raise Error, 'No matchers given'
+      end
+
+      Mutant::Matcher::Chain.build(@matchers)
+    end
+    memoize :matcher
+
+    # Return mutation filter
+    #
+    # @return [Mutant::Matcher]
+    #
+    # @api private
+    #
+    def filter
+      if @filters.empty?
+        Mutation::Filter::ALL
+      else
+        Mutation::Filter::Whitelist.new(@filters)
+      end
+    end
+    memoize :filter
+
+    # Return stratety
+    #
+    # @return [Strategy]
+    #
+    # @api private
+    #
+    def strategy
+      @strategy || raise(Error, 'no strategy was set!')
+    end
+
+    # Return reporter
+    #
+    # @return [Mutant::Reporter::CLI]
+    #
+    # @api private
+    #
+    def reporter
+      Mutant::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                                 ],
+     #'--killer-fork'        => [:enable_killer_fork                              ],
+      '--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
+
+    # Return selected killer
+    #
+    # @return [Killer]
+    #
+    # @api private
+    #
+    def selected_killer
+      unless @rspec
+        raise Error, "Only rspec is supported currently use --rspec switch"
+      end
+
+      Mutant::Killer::Rspec
+    end
+    memoize :selected_killer
+
+    # Return option for argument with index
+    #
+    # @param [Fixnum] index
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def option(index)
+      @arguments.fetch(index+1)
+    end
+
+    # Initialize CLI 
+    #
+    # @param [Array<String>] arguments
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize(arguments)
+      @filters, @matchers = [], []
+
+      @arguments, @index = arguments, 0
+
+      while @index < @arguments.length
+        dispatch
+      end
+
+      strategy
+      matcher
+    end
+
+    # Return current argument
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def current_argument
+      @arguments.fetch(@index)
+    end
+
+    # Return current option value
+    #
+    # @return [String]
+    #
+    # @raise [CLI::Error]
+    #   raises error when option is missing
+    #
+    # @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
+    end
+
+    # Move processed argument by amount
+    #
+    # @param [Fixnum] amount
+    #   the amount of arguments to be consumed
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    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)
+
+      unless matcher
+        raise Error, "Invalid matcher syntax: #{argument.inspect}"
+      end
+
+      @matchers << matcher
+
+      consume(1)
+    end
+
+    # Process option argument
+    #
+    # @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>]
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def add_filter(klass)
+      @filters << klass.new(current_option_value)
+      consume(2)
+    end
+
+    # Add load path
+    #
+    # @api private
+    #
+    # @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
+    end
+
+    # Enable killer forking
+    #
+    # @api private
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def enable_killer_fork
+      consume(1)
+      @forking = true
+    end
+
+    # Set strategy
+    #
+    # @param [Strategy]
+    #
+    # @api private
+    #
+    # @return [undefined]
+    #
+    def set_strategy(strategy)
+      consume(1)
+      @strategy = strategy
+    end
+
+    # Require library
+    #
+    # @api private
+    # 
+    # @return [undefined]
+    #
+    def require_library
+      require(current_option_value)
+      consume(2)
+    end
+
+  end
+end

data/lib/mutant/color.rb

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

data/lib/mutant/context.rb

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

data/lib/mutant/context/scope.rb

@@ -0,0 +1,138 @@
+module Mutant
+  class Context
+    # Scope context for mutation (Class or Module)
+    class Scope < self
+      include Adamantium::Flat, AbstractType, Equalizer.new(:scope, :source_path)
+
+      # Class context for mutation
+      class Class < self
+        SCOPE_CLASS = Rubinius::AST::ClassScope
+        KEYWORD     = 'class'.freeze
+      end
+
+      # Module context for mutation
+      class Module < self
+        SCOPE_CLASS = Rubinius::AST::ModuleScope
+        KEYWORD     = 'module'.freeze
+      end
+
+      TABLE = {
+        ::Module => Module,
+        ::Class => Class
+      }.freeze
+
+      # Build scope context from class or module
+      #
+      # @param [String] source_path
+      #
+      # @param [::Class|::Module] scope
+      #
+      # @return [Context::Scope]
+      #
+      # @api private
+      #
+      def self.build(scope, source_path)
+        scope_class = scope.class
+        klass = TABLE.fetch(scope_class) do
+          raise ArgumentError, "Can only build mutation scope from class or module got: #{scope_class.inspect}"
+        end.new(scope, source_path)
+      end
+
+      # Return AST wrapping mutated node
+      #
+      # @return [Rubinius::AST::Script]
+      #
+      # @api private
+      #
+      def root(node)
+        root = root_ast
+        block = Rubinius::AST::Block.new(1, [node])
+        root.body = scope_class.new(1, root.name, block)
+        root
+      end
+
+      # Return unqualified name of scope
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def unqualified_name
+        name_nesting.last
+      end
+
+      # Return scope wrapped by context
+      #
+      # @return [::Module|::Class]
+      #
+      # @api private
+      #
+      attr_reader :scope
+
+    private
+
+      # Initialize object
+      #
+      # @param [Object] scope
+      # @param [String] source_path
+      #
+      # @api private
+      #
+      def initialize(scope, source_path)
+        super(source_path)
+        @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>]
+      #
+      # @api private
+      #
+      def name_nesting
+        scope.name.split('::')
+      end
+      memoize :name_nesting
+    end
+  end
+end