mutest 0.0.1 → 0.0.2

data/lib/mutest/runner.rb

@@ -0,0 +1,81 @@
+module Mutest
+  # Runner baseclass
+  class Runner
+    include Adamantium::Flat, Concord.new(:env), Procto.call(:result)
+
+    # Initialize object
+    #
+    # @return [undefined]
+    def initialize(*)
+      super
+
+      reporter.start(env)
+
+      run_mutation_analysis
+    end
+
+    # Final result
+    #
+    # @return [Result::Env]
+    attr_reader :result
+
+    private
+
+    # Run mutation analysis
+    #
+    # @return [undefined]
+    def run_mutation_analysis
+      @result = run_driver(Parallel.async(mutation_test_config))
+      reporter.report(result)
+    end
+
+    # Run driver
+    #
+    # @param [Driver] driver
+    #
+    # @return [Object]
+    #   the last returned status payload
+    def run_driver(driver)
+      status = nil
+      sleep  = env.config.kernel.method(:sleep)
+
+      loop do
+        status = driver.status
+        reporter.progress(status)
+        break if status.done
+        sleep.call(reporter.delay)
+      end
+
+      driver.stop
+
+      status.payload
+    end
+
+    # Configuration for parallel execution engine
+    #
+    # @return [Parallel::Config]
+    def mutation_test_config
+      Parallel::Config.new(
+        env:       env.actor_env,
+        jobs:      config.jobs,
+        processor: env.method(:kill),
+        sink:      Sink.new(env),
+        source:    Parallel::Source::Array.new(env.mutations)
+      )
+    end
+
+    # Reporter to use
+    #
+    # @return [Reporter]
+    def reporter
+      env.config.reporter
+    end
+
+    # Config for this mutest execution
+    #
+    # @return [Config]
+    def config
+      env.config
+    end
+  end # Runner
+end # Mutest

data/lib/mutest/runner/sink.rb

@@ -0,0 +1,63 @@
+module Mutest
+  class Runner
+    class Sink
+      include Concord.new(:env)
+
+      # Initialize object
+      #
+      # @return [undefined]
+      def initialize(*)
+        super
+        @start           = Time.now
+        @subject_results = {}
+      end
+
+      # Runner status
+      #
+      # @return [Result::Env]
+      def status
+        Result::Env.new(
+          env:             env,
+          runtime:         Time.now - @start,
+          subject_results: @subject_results.values
+        )
+      end
+
+      # Test if scheduling stopped
+      #
+      # @return [Boolean]
+      def stop?
+        env.config.fail_fast && !status.subject_results.all?(&:success?)
+      end
+
+      # Handle mutation finish
+      #
+      # @param [Result::Mutation] mutation_result
+      #
+      # @return [self]
+      def result(mutation_result)
+        subject = mutation_result.mutation.subject
+
+        @subject_results[subject] = Result::Subject.new(
+          subject:          subject,
+          mutation_results: previous_mutation_results(subject) + [mutation_result],
+          tests:            mutation_result.test_result.tests
+        )
+
+        self
+      end
+
+      private
+
+      # Return previous results
+      #
+      # @param [Subject]
+      #
+      # @return [Array<Result::Mutation>]
+      def previous_mutation_results(subject)
+        subject_result = @subject_results.fetch(subject) { return EMPTY_ARRAY }
+        subject_result.mutation_results
+      end
+    end # Sink
+  end # Runner
+end # Mutest

data/lib/mutest/scope.rb

@@ -0,0 +1,6 @@
+module Mutest
+  # Class or Module bound to an exact expression
+  class Scope
+    include Concord::Public.new(:raw, :expression)
+  end # Scope
+end # Mutest

data/lib/mutest/selector.rb

@@ -0,0 +1,13 @@
+module Mutest
+  # Abstract base class for test selectors
+  class Selector
+    include AbstractType, Adamantium::Flat
+
+    # Tests for subject
+    #
+    # @param [Subject] subjecto
+    #
+    # @return [Enumerable<Test>]
+    abstract_method :call
+  end # Selector
+end # Mutest

data/lib/mutest/selector/expression.rb

@@ -0,0 +1,25 @@
+module Mutest
+  class Selector
+    # Expression based test selector
+    class Expression < self
+      include Concord.new(:integration)
+
+      # Tests for subject
+      #
+      # @param [Subject] subject
+      #
+      # @return [Enumerable<Test>]
+      def call(subject)
+        subject.match_expressions.each do |match_expression|
+          subject_tests =
+            integration.all_tests.select do |test|
+              match_expression.prefix?(test.expression)
+            end
+          return subject_tests if subject_tests.any?
+        end
+
+        EMPTY_ARRAY
+      end
+    end # Expression
+  end # Selector
+end # Mutest

data/lib/mutest/source_file.rb

@@ -0,0 +1,47 @@
+module Mutest
+  # A source file representation
+  class SourceFile
+    include Concord::Public.new(:path, :ast), Adamantium
+
+    COMMENT_TEXT = '# mutest:disable'.freeze
+
+    # Read and parse file with comments
+    #
+    # @return [undefined]
+    def self.read(path)
+      new(path, *::Parser::CurrentRuby.parse_with_comments(path.read))
+    end
+
+    def initialize(path, ast, comments)
+      super(path, ast)
+
+      @comments = comments
+    end
+
+    # TODO: Support multiple lines of comments preceeding a disable
+    # TODO: Support inline comment disable
+    def ignore?(node)
+      location = node.location
+      return false unless location.expression
+
+      disable_lines.include?(location.line)
+    end
+
+    private
+
+    attr_reader :comments
+
+    def disable_lines
+      disable_comments.map do |comment|
+        comment.location.line + 1
+      end
+    end
+    memoize :disable_lines
+
+    def disable_comments
+      comments.select do |comment|
+        comment.text.eql?(COMMENT_TEXT)
+      end
+    end
+  end # SourceFile
+end # Mutest

data/lib/mutest/subject.rb

@@ -0,0 +1,94 @@
+module Mutest
+  # Subject of a mutation
+  class Subject
+    include AbstractType, Adamantium::Flat, Enumerable
+    include Concord::Public.new(:context, :node)
+
+    # Mutations for this subject
+    #
+    # @return [Enumerable<Mutation>]
+    # @return [undefined]
+    def mutations
+      [neutral_mutation].concat(
+        Mutator.mutate(node, context.method(:ignore?)).map do |mutant|
+          Mutation::Evil.new(self, wrap_node(mutant))
+        end
+      )
+    end
+    memoize :mutations
+
+    # Source path
+    #
+    # @return [Pathname]
+    def source_path
+      context.source_path
+    end
+
+    # Prepare subject for insertion of mutation
+    #
+    # @return [self]
+    def prepare
+      self
+    end
+
+    # Source line range
+    #
+    # @return [Range<Fixnum>]
+    def source_lines
+      expression = node.location.expression
+      expression.line..expression.source_buffer.decompose_position(expression.end_pos).first
+    end
+    memoize :source_lines
+
+    # First source line
+    #
+    # @return [Fixnum]
+    def source_line
+      source_lines.begin
+    end
+
+    # Identification string
+    #
+    # @return [String]
+    def identification
+      "#{expression.syntax}:#{source_path}:#{source_line}"
+    end
+    memoize :identification
+
+    # Source representation of AST
+    #
+    # @return [String]
+    def source
+      Unparser.unparse(wrap_node(node))
+    end
+    memoize :source
+
+    # Match expression
+    #
+    # @return [Expression]
+    abstract_method :expression
+
+    # Match expressions
+    #
+    # @return [Enumerable<Expression>]
+    abstract_method :match_expressions
+
+    private
+
+    # Neutral mutation
+    #
+    # @return [Mutation::Neutral]
+    def neutral_mutation
+      Mutation::Neutral.new(self, wrap_node(node))
+    end
+
+    # Wrap node into subject specific container
+    #
+    # @param [Parser::AST::Node] node
+    #
+    # @return [Parser::AST::Node]
+    def wrap_node(node)
+      node
+    end
+  end # Subject
+end # Mutest

data/lib/mutest/subject/method.rb

@@ -0,0 +1,42 @@
+module Mutest
+  class Subject
+    # Abstract base class for method subjects
+    class Method < self
+      # Method name
+      #
+      # @return [Expression]
+      def name
+        node.children.fetch(self.class::NAME_INDEX)
+      end
+
+      # Match expression
+      #
+      # @return [String]
+      def expression
+        Expression::Method.new(
+          method_name:  name.to_s,
+          scope_symbol: self.class::SYMBOL,
+          scope_name:   scope.name
+        )
+      end
+      memoize :expression
+
+      # Match expressions
+      #
+      # @return [Array<Expression>]
+      def match_expressions
+        [expression].concat(context.match_expressions)
+      end
+      memoize :match_expressions
+
+      private
+
+      # The scope
+      #
+      # @return [Class, Module]
+      def scope
+        context.scope
+      end
+    end # Method
+  end # Subject
+end # Mutest

data/lib/mutest/subject/method/instance.rb

@@ -0,0 +1,43 @@
+module Mutest
+  class Subject
+    class Method
+      # Instance method subjects
+      class Instance < self
+        NAME_INDEX = 0
+        SYMBOL     = '#'.freeze
+
+        # Prepare subject for mutation insertion
+        #
+        # @return [self]
+        def prepare
+          scope.__send__(:undef_method, name)
+          self
+        end
+
+        # Mutator for memoizable memoized instance methods
+        class Memoized < self
+          include AST::Sexp
+
+          # Prepare subject for mutation insertion
+          #
+          # @return [self]
+          def prepare
+            scope.__send__(:memoized_methods).instance_variable_get(:@memory).delete(name)
+            super()
+          end
+
+          private
+
+          # Memoizer node for mutest
+          #
+          # @param [Parser::AST::Node] mutest
+          #
+          # @return [Parser::AST::Node]
+          def wrap_node(mutest)
+            s(:begin, mutest, s(:send, nil, :memoize, s(:args, s(:sym, name))))
+          end
+        end # Memoized
+      end # Instance
+    end # Method
+  end # Subject
+end # Mutest

data/lib/mutest/subject/method/singleton.rb

@@ -0,0 +1,19 @@
+module Mutest
+  class Subject
+    class Method
+      # Singleton method subjects
+      class Singleton < self
+        NAME_INDEX = 1
+        SYMBOL     = '.'.freeze
+
+        # Prepare subject for mutation insertion
+        #
+        # @return [self]
+        def prepare
+          scope.singleton_class.__send__(:undef_method, name)
+          self
+        end
+      end # Singleton
+    end # Method
+  end # Subject
+end # Mutest