mutest 0.0.1 → 0.0.2

data/lib/mutest/config.rb

@@ -0,0 +1,28 @@
+module Mutest
+  # Standalone configuration of a mutest execution.
+  #
+  # Does not reference any "external" volatile state. The configuration applied
+  # to current environment is being represented by the Mutest::Env object.
+  class Config
+    include Adamantium::Flat, Anima.new(
+      :expression_parser,
+      :fail_fast,
+      :integration,
+      :includes,
+      :isolation,
+      :jobs,
+      :kernel,
+      :load_path,
+      :matcher,
+      :open3,
+      :pathname,
+      :requires,
+      :reporter,
+      :zombie
+    )
+
+    %i[fail_fast zombie].each do |name|
+      define_method(:"#{name}?") { public_send(name) }
+    end
+  end # Config
+end # Mutest

data/lib/mutest/context.rb

@@ -0,0 +1,98 @@
+module Mutest
+  # An abstract context where mutations can be applied to.
+  class Context
+    include Adamantium::Flat, Concord::Public.new(:scope, :source_file)
+    extend AST::Sexp
+
+    NAMESPACE_DELIMITER = '::'.freeze
+
+    # Return root node for mutation
+    #
+    # @return [Parser::AST::Node]
+    def root(node)
+      nesting.reverse.reduce(node) do |current, scope|
+        self.class.wrap(scope, current)
+      end
+    end
+
+    # Identification string
+    #
+    # @return [String]
+    def identification
+      scope.name
+    end
+
+    # Wrap node into ast node
+    #
+    # @param [Class, Module] scope
+    # @param [Parser::AST::Node] node
+    #
+    # @return [Parser::AST::Class]
+    #   if scope is of kind Class
+    #
+    # @return [Parser::AST::Module]
+    #   if scope is of kind module
+    def self.wrap(scope, node)
+      name = s(:const, nil, scope.name.split(NAMESPACE_DELIMITER).last.to_sym)
+      case scope
+      when Class
+        s(:class, name, nil, node)
+      when Module
+        s(:module, name, node)
+      end
+    end
+
+    # Nesting of scope
+    #
+    # @return [Enumerable<Class,Module>]
+    def nesting
+      const = Object
+      name_nesting.map do |name|
+        const = const.const_get(name)
+      end
+    end
+    memoize :nesting
+
+    # Unqualified name of scope
+    #
+    # @return [String]
+    def unqualified_name
+      name_nesting.last
+    end
+
+    # Match expressions for scope
+    #
+    # @return [Enumerable<Expression>]
+    def match_expressions
+      name_nesting.each_index.reverse_each.map do |index|
+        Expression::Namespace::Recursive.new(
+          scope_name: name_nesting.take(index.succ).join(NAMESPACE_DELIMITER)
+        )
+      end
+    end
+    memoize :match_expressions
+
+    # Scope wrapped by context
+    #
+    # @return [Module|Class]
+    attr_reader :scope
+
+    def ignore?(node)
+      source_file.ignore?(node)
+    end
+
+    def source_path
+      source_file.path
+    end
+
+    private
+
+    # Nesting of names in scope
+    #
+    # @return [Array<String>]
+    def name_nesting
+      scope.name.split(NAMESPACE_DELIMITER)
+    end
+    memoize :name_nesting
+  end # Context
+end # Mutest

data/lib/mutest/diff.rb

@@ -0,0 +1,111 @@
+module Mutest
+  # Class to create diffs from source code
+  class Diff
+    include Adamantium::Flat, Concord.new(:old, :new)
+
+    ADDITION = '+'.freeze
+    DELETION = '-'.freeze
+    NEWLINE  = "\n".freeze
+
+    # Unified source diff between old and new
+    #
+    # @return [String]
+    #   if there is exactly one diff
+    #
+    # @return [nil]
+    #   otherwise
+    def diff
+      return if diffs.empty?
+
+      minimized_hunk.diff(:unified) << NEWLINE
+    end
+    memoize :diff
+
+    # Colorized unified source diff between old and new
+    #
+    # @return [String]
+    #   if there is a diff
+    #
+    # @return [nil]
+    #   otherwise
+    def colorized_diff
+      return unless diff
+      diff.lines.map(&self.class.method(:colorize_line)).join
+    end
+    memoize :colorized_diff
+
+    # Build new object from source strings
+    #
+    # @param [String] old
+    # @param [String] new
+    #
+    # @return [Diff]
+    def self.build(old, new)
+      new(lines(old), lines(new))
+    end
+
+    # Break up source into lines
+    #
+    # @param [String] source
+    #
+    # @return [Array<String>]
+    def self.lines(source)
+      source.lines.map(&:chomp)
+    end
+    private_class_method :lines
+
+    private
+
+    # Diffs between old and new
+    #
+    # @return [Array<Array>]
+    def diffs
+      ::Diff::LCS.diff(old, new)
+    end
+
+    # Raw diff-lcs hunks
+    #
+    # @return [Array<Diff::LCS::Hunk>]
+    def hunks
+      diffs.map do |diff|
+        ::Diff::LCS::Hunk.new(old, new, diff, max_length, 0)
+      end
+    end
+
+    # Minimized hunk
+    #
+    # @return Diff::LCS::Hunk
+    def minimized_hunk
+      head, *tail = hunks
+
+      tail.reduce(head) do |left, right|
+        right.merge(left)
+        right
+      end
+    end
+
+    # Max length of source line in new and old
+    #
+    # @return [Fixnum]
+    def max_length
+      [old, new].map(&:length).max
+    end
+
+    # Colorized a unified diff line
+    #
+    # @param [String] line
+    #
+    # @return [String]
+    def self.colorize_line(line)
+      case line[0]
+      when ADDITION
+        Color::GREEN
+      when DELETION
+        Color::RED
+      else
+        Color::NONE
+      end.format(line)
+    end
+    private_class_method :colorize_line
+  end # Diff
+end # Mutest

data/lib/mutest/env.rb

@@ -0,0 +1,59 @@
+module Mutest
+  # Abstract base class for mutest environments
+  class Env
+    include Adamantium::Flat, Anima.new(
+      :actor_env,
+      :config,
+      :integration,
+      :matchable_scopes,
+      :mutations,
+      :parser,
+      :selector,
+      :subjects
+    )
+
+    SEMANTICS_MESSAGE =
+      "Fix your lib to follow normal ruby semantics!\n" \
+      '{Module,Class}#name should return resolvable constant name as String or nil'.freeze
+
+    # Kill mutation
+    #
+    # @param [Mutation] mutation
+    #
+    # @return [Result::Mutation]
+    def kill(mutation)
+      test_result = run_mutation_tests(mutation)
+      Result::Mutation.new(
+        mutation:    mutation,
+        test_result: test_result
+      )
+    end
+
+    private
+
+    # Kill mutation under isolation with integration
+    #
+    # @param [Isolation] isolation
+    # @param [Integration] integration
+    #
+    # @return [Result::Test]
+    #
+    # rubocop:disable MethodLength
+    def run_mutation_tests(mutation)
+      start = Time.now
+      tests = selector.call(mutation.subject)
+
+      config.isolation.call do
+        mutation.insert(config.kernel)
+        integration.call(tests)
+      end
+    rescue Isolation::Error => error
+      Result::Test.new(
+        output:  error.message,
+        passed:  false,
+        runtime: Time.now - start,
+        tests:   tests
+      )
+    end
+  end # Env
+end # Mutest

data/lib/mutest/env/bootstrap.rb

@@ -0,0 +1,159 @@
+module Mutest
+  class Env
+    # Bootstrap environment
+    class Bootstrap
+      include Adamantium::Flat, Concord::Public.new(:config), Procto.call(:env)
+
+      SEMANTICS_MESSAGE_FORMAT =
+        "%<message>s. Fix your lib to follow normal ruby semantics!\n" \
+        '{Module,Class}#name should return resolvable constant name as String or nil'.freeze
+
+      CLASS_NAME_RAISED_EXCEPTION =
+        '%<scope_class>s#name from: %<scope>s raised an error: %<exception>s'.freeze
+
+      CLASS_NAME_TYPE_MISMATCH_FORMAT =
+        '%<scope_class>s#name from: %<scope>s returned %<name>s'.freeze
+
+      private_constant(*constants(false))
+
+      # Scopes that are eligible for matching
+      #
+      # @return [Enumerable<Matcher::Scope>]
+      attr_reader :matchable_scopes
+
+      # Parser for this environment
+      #
+      # @return [Parser]
+      attr_reader :parser
+
+      # Initialize object
+      #
+      # @return [Object]
+      def initialize(*)
+        super
+        @parser = Parser.new
+        infect
+        initialize_matchable_scopes
+      end
+
+      # Print warning message
+      #
+      # @param [String]
+      #
+      # @return [self]
+      def warn(message)
+        config.reporter.warn(message)
+        self
+      end
+
+      # Environment after bootstraping
+      #
+      # @return [Env]
+      # rubocop:disable MethodLength
+      #
+      def env
+        subjects = matched_subjects
+        Env.new(
+          actor_env:        Actor::Env.new(Thread),
+          config:           config,
+          integration:      integration,
+          matchable_scopes: matchable_scopes,
+          mutations:        subjects.flat_map(&:mutations),
+          parser:           parser,
+          selector:         Selector::Expression.new(integration),
+          subjects:         subjects
+        )
+      end
+
+      private
+
+      # Configured mutest integration
+      #
+      # @return [Mutest::Integration]
+      attr_reader :integration
+
+      # Scope name from scoping object
+      #
+      # @param [Class, Module] scope
+      #
+      # @return [String]
+      #   if scope has a name and does not raise exceptions obtaining it
+      #
+      # @return [nil]
+      #   otherwise
+      def scope_name(scope)
+        scope.name
+      rescue => exception
+        semantics_warning(
+          CLASS_NAME_RAISED_EXCEPTION,
+          exception:   exception.inspect,
+          scope:       scope,
+          scope_class: scope.class
+        )
+        nil
+      end
+
+      # Infect environment
+      #
+      # @return [undefined]
+      def infect
+        config.includes.each(&config.load_path.method(:<<))
+        config.requires.each(&config.kernel.method(:require))
+        @integration = config.integration.new(config).setup
+      end
+
+      # Matched subjects
+      #
+      # @return [Enumerable<Subject>]
+      def matched_subjects
+        Matcher::Compiler.call(config.matcher).call(self)
+      end
+
+      # Initialize matchable scopes
+      #
+      # @return [undefined]
+      def initialize_matchable_scopes
+        scopes =
+          ObjectSpace.each_object(Module).each_with_object([]) do |scope, aggregate|
+            expression = expression(scope) || next
+            aggregate << Scope.new(scope, expression)
+          end
+
+        @matchable_scopes = scopes.sort_by { |scope| scope.expression.syntax }
+      end
+
+      # Try to turn scope into expression
+      #
+      # @param [Class, Module] scope
+      #
+      # @return [Expression]
+      #   if scope can be represented in an expression
+      #
+      # @return [nil]
+      #   otherwise
+      def expression(scope)
+        name = scope_name(scope) or return
+
+        unless name.instance_of?(String)
+          semantics_warning(
+            CLASS_NAME_TYPE_MISMATCH_FORMAT,
+            name:        name,
+            scope_class: scope.class,
+            scope:       scope
+          )
+          return
+        end
+
+        config.expression_parser.try_parse(name)
+      end
+
+      # Write a semantics warning
+      #
+      # @return [undefined]
+      def semantics_warning(format, options)
+        message = format % options
+        warn(format(SEMANTICS_MESSAGE_FORMAT, message: message))
+      end
+    end # Bootstrap
+  end # Env
+end # Mutest