mutant 0.1.1 → 0.2.0

data/lib/mutant/reporter/null.rb

@@ -0,0 +1,42 @@
+module Mutant
+  class Reporter
+    # Null reporter
+    Null = Class.new(self) do
+      # Report subject
+      #
+      # @param [Subject] subject
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def subject(*)
+        self
+      end
+
+      # Report mutation
+      #
+      # @param [Mutation] mutation
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def mutation(*)
+        self
+      end
+
+      # Report killer
+      #
+      # @param [Killer] killer
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def killer(*)
+        self
+      end
+    end.new.freeze
+  end
+end

data/lib/mutant/reporter/stats.rb

@@ -0,0 +1,64 @@
+module Mutant
+  class Reporter
+
+    # Stats gathered while reporter is running
+    class Stats
+
+      # Return subject count
+      #
+      # @return [Fixnum]
+      #
+      # @api private
+      #
+      attr_reader :subject
+
+      # Return mutation count
+      #
+      # @return [Fixnum]
+      #
+      # @api private
+      #
+      attr_reader :mutation
+
+      # Return kill count
+      #
+      # @return [Fixnum]
+      #
+      # @api private
+      #
+      attr_reader :kill
+
+      # Return mutation runtime
+      #
+      # @return [Float]
+      #
+      # @api private
+      #
+      attr_reader :time
+
+      def initialize
+        @start = Time.now
+        @subject = @mutation = @kill = @time = 0
+      end
+
+      def runtime
+        Time.now - @start
+      end
+
+      def subject
+        @subject +=1
+      end
+
+      def alive
+        @mutation - @kill
+      end
+
+      def killer(killer)
+        @mutation +=1
+        @kill +=1 unless killer.fail?
+        @time += killer.runtime
+      end
+    end
+
+  end
+end

data/lib/mutant/runner.rb

@@ -0,0 +1,112 @@
+module Mutant
+  # Runner that allows to mutate an entire project
+  class Runner
+    include Adamantium::Flat
+    extend MethodObject
+
+    # Return killers with errors
+    #
+    # @return [Enumerable<Killer>]
+    #
+    # @api private
+    #
+    attr_reader :errors
+
+    # Test for failure
+    #
+    # @return [true]
+    #   returns true when there are left mutations
+    #
+    # @return [false]
+    #   returns false othewise
+    #
+    # @api private
+    #
+    def fail?
+      !errors.empty?
+    end
+
+    # Return config
+    #
+    # @return [Mutant::Config]
+    #
+    # @api private
+    #
+    attr_reader :config
+
+  private
+
+    # Initialize object
+    #
+    # @param [Config] config
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize(config)
+      @config, @errors = config, []
+
+      reporter.config(config)
+
+      run
+
+      reporter.errors(@errors)
+    end
+
+    # Return reporter
+    #
+    # @return [Reporter]
+    #
+    # @api private
+    #
+    def reporter
+      config.reporter
+    end
+
+    # Run mutation killers on subjects
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def run
+      config.matcher.each do |subject|
+        reporter.subject(subject)
+        run_subject(subject)
+      end
+    end
+
+    # Run mutation killers on subject
+    #
+    # @param [Subject] subject
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def run_subject(subject)
+      subject.each do |mutation|
+        next unless config.filter.match?(mutation)
+        reporter.mutation(mutation)
+        kill(mutation)
+      end
+    end
+
+    # Run killer on mutation
+    #
+    # @param [Mutation] mutation
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def kill(mutation)
+      killer = config.strategy.kill(mutation)
+      reporter.killer(killer)
+      if killer.fail?
+        @errors << killer
+      end
+    end
+  end
+end

data/lib/mutant/strategy.rb

@@ -0,0 +1,42 @@
+module Mutant
+  class Strategy 
+    include AbstractType
+
+    # Kill mutation
+    #
+    # @param [Mutation]
+    #
+    # @return [Killer]
+    #
+    # @api private
+    #
+    def self.kill(mutation)
+      killer.new(self, mutation)
+    end
+
+    # Return killer
+    #
+    # @return [Class:Killer]
+    #
+    # @api private
+    #
+    def self.killer
+      self::KILLER
+    end
+
+    # Static strategies
+    class Static < self
+
+      # Always fail to kill strategy
+      class Fail < self
+        KILLER = Killer::Static::Fail
+      end
+
+      # Always succeed to kill strategy
+      class Success < self
+        KILLER = Killer::Static::Success
+      end
+
+    end
+  end
+end

data/lib/mutant/strategy/rspec.rb

@@ -0,0 +1,59 @@
+module Mutant
+  class Strategy
+
+    # Rspec strategy base class
+    class Rspec < self
+
+      KILLER = Killer::Forking.new(Killer::Rspec)
+
+      # DM2-style strategy
+      class DM2 < self
+
+        # Return filename pattern
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def self.spec_files(mutation)
+          ExampleLookup.run(mutation)
+        end
+      end
+
+      # Run all unit specs per mutation
+      class Unit < self
+
+        # Return file name pattern for mutation
+        #
+        # @return [Mutation]
+        #
+        # @api private
+        #
+        def self.spec_files(mutation)
+          Dir['spec/unit/**/*_spec.rb']
+        end
+      end
+
+      # Run all integration specs per mutation
+      class Unit < self
+
+        # Return file name pattern for mutation
+        #
+        # @return [Mutation]
+        #
+        # @api private
+        #
+        def self.spec_files(mutation)
+          Dir['spec/integration/**/*_spec.rb']
+        end
+      end
+
+      # Run all specs per mutation
+      class Full < self
+        def self.spec_files(mutation)
+          Dir['spec/**/*_spec.rb']
+        end
+      end
+    end
+  end
+end

data/lib/mutant/strategy/rspec/example_lookup.rb

@@ -0,0 +1,122 @@
+module Mutant
+  class Strategy
+    class Rspec
+
+      # Example lookup for rspec
+      class ExampleLookup
+        include Adamantium::Flat, Equalizer.new(:mutation)
+
+        # Perform example lookup
+        #
+        # @param [Mutation]
+        #
+        # @return [Enumerable<String>]
+        #
+        # @api private
+        #
+        def self.run(mutation)
+          new(mutation).spec_files
+        end
+
+        # Return mutation
+        #
+        # @return [Mutation]
+        #
+        # @api private
+        #
+        attr_reader :mutation
+
+        # Return spec files
+        #
+        # @return [Enumerable<String>]
+        #
+        # @api private
+        #
+        def spec_files
+          expression = glob_expression
+          files = Dir[expression]
+
+          if files.empty?
+            $stderr.puts("Spec file(s): #{expression.inspect} not found for #{mutation.identification}")
+          end
+
+          files
+        end
+        memoize :spec_files
+
+      private
+
+        # Return method matcher
+        #
+        # @return [Matcher]
+        #
+        # @api private
+        #
+        def matcher
+          mutation.subject.matcher
+        end
+
+        # Return spec file
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def spec_file
+          matcher.method_name.to_s.
+            gsub(/\?\z/, '_predicate').
+            gsub(/\=\z/, '_writer').
+            gsub(/!\z/, '_bang') + '_spec.rb'
+        end
+        memoize :spec_file
+
+        # Return glob expression
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def glob_expression
+          if mutation.subject.matcher.public?
+            "#{base_path}/#{spec_file}"
+          else
+            "#{base_path}/*_spec.rb"
+          end
+        end
+
+        # Return instance of singleton path appendo
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def scope_append
+          matcher.kind_of?(Matcher::Method::Singleton) ? '/class_methods' : ''
+        end
+        memoize :scope_append
+
+        # Return base path
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def base_path
+          "spec/unit/#{Inflector.underscore(mutation.subject.context.scope.name)}#{scope_append}"
+        end
+        memoize :base_path
+
+        # Initalize object
+        #
+        # @param [Mutation] mutation
+        #
+        # @api private
+        #
+        def initialize(mutation)
+          @mutation = mutation
+        end
+
+      end
+    end
+  end
+end

data/lib/mutant/subject.rb

@@ -0,0 +1,115 @@
+module Mutant
+  # Subject of a mutation
+  class Subject
+    include Adamantium::Flat, Enumerable, Equalizer.new(:context, :matcher, :node)
+
+    # Return context
+    #
+    # @return [Context]
+    #
+    # @api private
+    #
+    attr_reader :context
+
+    # Return matcher
+    #
+    # @return [Matcher]
+    #
+    # @api private
+    #
+    attr_reader :matcher
+
+    # Return AST node
+    #
+    # @return [Rubinius::AST::Node]
+    #
+    # @api private
+    #
+    attr_reader :node
+
+    # Enumerate possible mutations
+    #
+    # @return [self]
+    #   returns self if block given
+    #
+    # @return [Enumerator<Mutation>]
+    #   returns eumerator if no block given
+    #
+    # @api private
+    #
+    def each
+      return to_enum unless block_given?
+      Mutator.each(node) do |mutant|
+        yield Mutation.new(self, mutant)
+      end
+
+      self
+    end
+
+    # Return subject identicication
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def identification
+      source_path = context.source_path
+      source_line = node.line
+      "#{matcher.identification}:#{source_path}:#{source_line}"
+    end
+    memoize :identification
+
+    # Return source representation of ast
+    #
+    # @return [Source]
+    #
+    # @api private
+    # 
+    def source
+      ToSource.to_source(node)
+    end
+    memoize :source
+
+    # Return root AST for node
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [Rubinius::AST::Node]
+    #
+    # @api private
+    #
+    def root(node)
+      context.root(node)
+    end
+
+    # Return root AST node for original AST ndoe
+    #
+    # @return [Rubinius::AST::Node]
+    #
+    # @api private
+    #
+    def original_root
+      root(node)
+    end
+    memoize :original_root
+
+  private
+
+    # Initialize subject
+    #
+    # @param [Matcher] matcher
+    #   the context of mutations
+    #
+    # @param [Rubinius::AST::Node] node
+    #   the node to be mutated
+    #
+    # @return [unkown]
+    #
+    # @api private
+    #
+    def initialize(matcher, context, node)
+      @matcher, @context, @node = matcher, context, node
+    end
+
+  end
+end