mutant 0.9.8 → 0.9.13

data/spec/shared/method_matcher_behavior.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples_for 'a method matcher' do
-  let(:node)              { mutation_subject.node    }
-  let(:context)           { mutation_subject.context }
-  let(:mutation_subject)  { subject.first            }
-
-  it 'returns one subject' do
-    expect(subject.size).to be(1)
-  end
-
-  it 'has expected method name' do
-    expect(name).to eql(method_name)
-  end
-
-  it 'has expected line number' do
-    expect(node.location.expression.line).to eql(method_line)
-  end
-
-  it 'has expected arity' do
-    expect(arguments.children.length).to eql(method_arity)
-  end
-
-  it 'has expected scope in context' do
-    expect(context.scope).to eql(scope)
-  end
-
-  it 'has source path in context' do
-    expect(context.source_path).to eql(source_path)
-  end
-
-  it 'has the correct node type' do
-    expect(node.type).to be(type)
-  end
-end
-
-RSpec.shared_examples_for 'skipped candidate' do
-  before do
-    expected_warnings.each do |warning|
-      expect(env).to receive(:warn).with(warning).and_return(env)
-    end
-  end
-
-  it 'does not emit matcher' do
-    expect(subject).to eql([])
-  end
-end

data/spec/spec_helper.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-if ENV['COVERAGE'] == 'true'
-  require 'simplecov'
-
-  SimpleCov.start do
-    command_name 'spec:unit'
-
-    add_filter 'config'
-    add_filter 'spec'
-    add_filter 'vendor'
-    add_filter 'test_app'
-    add_filter 'lib/mutant.rb' # simplecov bug not seeing default block is executed
-
-    minimum_coverage 100
-  end
-end
-
-require 'tempfile'
-require 'concord'
-require 'anima'
-require 'adamantium'
-require 'devtools/spec_helper'
-require 'unparser/cli'
-require 'mutant'
-require 'mutant/meta'
-
-$LOAD_PATH << File.join(TestApp.root, 'lib')
-
-require 'test_app'
-
-module Fixtures
-  TEST_CONFIG = Mutant::Config::DEFAULT
-    .with(reporter: Mutant::Reporter::Null.new)
-
-  TEST_ENV = Mutant::Bootstrap
-    .apply(Mutant::WORLD, TEST_CONFIG).from_right
-
-end # Fixtures
-
-module ParserHelper
-  def generate(node)
-    Unparser.unparse(node)
-  end
-
-  def parse(string)
-    Unparser::Preprocessor.run(Unparser.parse(string))
-  end
-
-  def parse_expression(string)
-    Mutant::Config::DEFAULT.expression_parser.apply(string).from_right
-  end
-end # ParserHelper
-
-module XSpecHelper
-  def verify_events
-    expectations = raw_expectations
-      .map(&XSpec::MessageExpectation.method(:parse))
-
-    XSpec::ExpectationVerifier.verify(self, expectations) do
-      yield
-    end
-  end
-
-  def undefined
-    double('undefined')
-  end
-end # XSpecHelper
-
-RSpec.configure do |config|
-  config.extend(SharedContext)
-  config.include(ParserHelper)
-  config.include(Mutant::AST::Sexp)
-  config.include(XSpecHelper)
-end

data/spec/support/corpus.rb

@@ -1,318 +0,0 @@
-# frozen_string_literal: true
-
-require 'anima'
-require 'mutant'
-require 'parallel'
-
-# @api private
-module MutantSpec
-  ROOT = Pathname.new(__FILE__).parent.parent.parent
-
-  # Namespace module for corpus testing
-  #
-  # rubocop:disable Metrics/MethodLength
-  module Corpus
-    TMP                 = ROOT.join('tmp').freeze
-    EXCLUDE_GLOB_FORMAT = '{%s}'
-
-    # Not in the docs. Number from chatting with their support.
-    # 2 processors allocated per container, 4 processes works well.
-    CIRCLE_CI_CONTAINER_PROCESSES = 4
-
-    private_constant(*constants(false))
-
-    # Project under corpus test
-    # rubocop:disable Metrics/ClassLength
-    class Project
-      MUTEX = Mutex.new
-
-      MUTATION_GENERATION_MESSAGE = 'Total Mutations/Time/Parse-Errors: %s/%0.2fs - %0.2f/s'
-      START_MESSAGE               = 'Starting - %s'
-      FINISH_MESSAGE              = 'Mutations - %4i - %s'
-      RUBY_GLOB_PATTERN           = '**/*.rb'
-
-      DEFAULT_MUTATION_COUNT = 0
-
-      include Adamantium, Anima.new(
-        :mutation_coverage,
-        :mutation_generation,
-        :integration,
-        :name,
-        :namespace,
-        :repo_uri,
-        :repo_ref,
-        :exclude
-      )
-
-      # Verify mutation coverage
-      #
-      # @return [self]
-      #   if successful
-      #
-      # @raise [Exception]
-      def verify_mutation_coverage
-        checkout
-        Dir.chdir(repo_path) do
-          Bundler.with_clean_env do
-            install_mutant
-            system(
-              %W[
-                bundle exec mutant
-                --use #{integration}
-                --include lib
-                --require #{name}
-                #{namespace}*
-              ] + concurrency_limits
-            )
-          end
-        end
-      end
-
-      # The concurrency limits, if any
-      #
-      # @return [Array<String>]
-      def concurrency_limits
-        if ENV.key?('MUTANT_JOBS')
-          %W[--jobs #{ENV.fetch('MUTANT_JOBS')}]
-        else
-          []
-        end
-      end
-
-      # Verify mutation generation
-      #
-      # @return [self]
-      #   if successful
-      #
-      # @raise [Exception]
-      #   otherwise
-      def verify_mutation_generation
-        checkout
-        start = Mutant::Timer.now
-
-        options = {
-          finish:       method(:finish),
-          start:        method(:start),
-          in_processes: parallel_processes
-        }
-
-        total = Parallel.map(effective_ruby_paths, options, &method(:check_generation))
-          .inject(DEFAULT_MUTATION_COUNT, :+)
-
-        took = Mutant::Timer.now - start
-        puts MUTATION_GENERATION_MESSAGE % [total, took, total / took]
-        self
-      end
-
-      # Checkout repository
-      #
-      # @return [self]
-      def checkout
-        return self if noinstall?
-        TMP.mkdir unless TMP.directory?
-
-        if repo_path.exist?
-          Dir.chdir(repo_path) do
-            system(%w[git fetch origin])
-            system(%w[git reset --hard])
-            system(%w[git clean -f -d -x])
-          end
-        else
-          system(%W[git clone #{repo_uri} #{repo_path}])
-        end
-
-        Dir.chdir(repo_path) do
-          system(%W[git checkout #{repo_ref}])
-          system(%w[git reset --hard])
-          system(%w[git clean -f -d -x])
-        end
-
-        self
-      end
-      memoize :checkout
-
-    private
-
-      # Count mutations and check error results against whitelist
-      #
-      # @param path [Pathname] path responsible for exception
-      #
-      # @return [Integer] mutations generated
-      def check_generation(path)
-        node = Parser::CurrentRuby.parse(path.read)
-        fail "Cannot parse: #{path}" unless node
-
-        mutations = Mutant::Mutator.mutate(node)
-
-        mutations.each do |mutation|
-          check_generation_invariants(node, mutation)
-        end
-
-        mutations.length
-      end
-
-      # Check generation invariants
-      #
-      # @param [Parser::AST::Node] original
-      # @param [Parser::AST::Node] mutation
-      #
-      # @return [undefined]
-      #
-      # @raise [Exception]
-      def check_generation_invariants(original, mutation)
-        return unless ENV['MUTANT_CORPUS_EXPENSIVE']
-
-        original_source = Unparser.unparse(original)
-        mutation_source = Unparser.unparse(mutation)
-
-        Mutant::Diff.build(original_source, mutation_source) and return
-
-        fail Mutant::Reporter::CLI::NO_DIFF_MESSAGE % [
-          original_source,
-          original.inspect,
-          mutation_source,
-          mutation.inspect
-        ]
-      end
-
-      # Install mutant
-      #
-      # @return [undefined]
-      def install_mutant
-        return if noinstall?
-        relative = ROOT.relative_path_from(repo_path)
-        repo_path.join('Gemfile').open('a') do |file|
-          file << "gem 'mutant', path: '#{relative}'\n"
-          file << "gem 'mutant-rspec', path: '#{relative}'\n"
-          file << "gem 'mutant-minitest', path: '#{relative}'\n"
-          file << "eval_gemfile File.expand_path('#{relative.join('Gemfile.shared')}')\n"
-        end
-        lockfile = repo_path.join('Gemfile.lock')
-        lockfile.delete if lockfile.exist?
-        system(%w[bundle])
-      end
-
-      # The effective ruby file paths
-      #
-      # @return [Array<Pathname>]
-      def effective_ruby_paths
-        Pathname
-          .glob(repo_path.join(RUBY_GLOB_PATTERN))
-          .sort_by(&:size)
-          .reverse
-          .reject { |path| exclude.include?(path.relative_path_from(repo_path).to_s) }
-      end
-
-      # Number of parallel processes to use
-      #
-      # @return [Integer]
-      def parallel_processes
-        if ENV.key?('CI')
-          CIRCLE_CI_CONTAINER_PROCESSES
-        else
-          Etc.nprocessors
-        end
-      end
-
-      # Repository path
-      #
-      # @return [Pathname]
-      def repo_path
-        TMP.join(name)
-      end
-
-      # Test if installation should be skipped
-      #
-      # @return [Boolean]
-      def noinstall?
-        ENV.key?('NOINSTALL')
-      end
-
-      # Print start progress
-      #
-      # @param [Pathname] path
-      # @param [Integer] _index
-      #
-      # @return [undefined]
-      #
-      def start(path, _index)
-        MUTEX.synchronize do
-          puts START_MESSAGE % path
-        end
-      end
-
-      # Print finish progress
-      #
-      # @param [Pathname] path
-      # @param [Integer] _index
-      # @param [Integer] count
-      #
-      # @return [undefined]
-      #
-      def finish(path, _index, count)
-        MUTEX.synchronize do
-          puts FINISH_MESSAGE % [count, path]
-        end
-      end
-
-      # Helper method to execute system commands
-      #
-      # @param [Array<String>] arguments
-      #
-      # rubocop:disable Style/GuardClause - guard clause without else does not make sense
-      def system(arguments)
-        return if Kernel.system(*arguments)
-
-        if block_given?
-          yield
-        else
-          fail "System command failed!: #{arguments.join(' ')}"
-        end
-      end
-
-      Transform = Mutant::Transform
-
-      boolean      = Transform::Boolean.new
-      string       = Transform::Primitive.new(String)
-      string_array = Transform::Array.new(string)
-
-      integration = Transform::Sequence.new(
-        [
-          Transform::Hash.new(
-            optional: [],
-            required: [
-              Transform::Hash::Key.new('exclude',             string_array),
-              Transform::Hash::Key.new('integration',         string),
-              Transform::Hash::Key.new('mutation_coverage',   boolean),
-              Transform::Hash::Key.new('mutation_generation', boolean),
-              Transform::Hash::Key.new('name',                string),
-              Transform::Hash::Key.new('namespace',           string),
-              Transform::Hash::Key.new('repo_ref',            string),
-              Transform::Hash::Key.new('repo_uri',            string)
-            ]
-          ),
-          Transform::Hash::Symbolize.new,
-          Transform::Exception.new(RuntimeError, Project.method(:new))
-        ]
-      )
-
-      transform =
-        Transform::Sequence.new(
-          [
-            Transform::Exception.new(SystemCallError, :read.to_proc),
-            Transform::Exception.new(YAML::SyntaxError, YAML.method(:safe_load)),
-            Transform::Array.new(integration)
-          ]
-        )
-
-      path = ROOT.join('spec', 'integrations.yml')
-
-      ALL = Transform::Named
-        .new(path, transform)
-        .apply(path)
-        .lmap(&:compact_message)
-        .lmap(&method(:fail))
-        .from_right
-    end # Project
-  end # Corpus
-end # MutantSpec

data/spec/support/file_system.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module MutantSpec
-  class FileState
-    DEFAULTS = IceNine.deep_freeze(
-      file:     false,
-      contents: nil,
-      requires: []
-    )
-
-    include Adamantium, Anima.new(*DEFAULTS.keys)
-
-    def self.new(attributes = DEFAULTS)
-      super(DEFAULTS.merge(attributes))
-    end
-
-    DOES_NOT_EXIST = new
-
-    alias_method :file?, :file
-  end # FileState
-
-  class FakePathname
-    include Adamantium, Concord.new(:file_system, :pathname)
-
-    def join(*arguments)
-      self.class.new(
-        file_system,
-        pathname.join(*arguments)
-      )
-    end
-
-    def read
-      state.contents
-    end
-
-    def to_s
-      pathname.to_s
-    end
-
-    def file?
-      state.file?
-    end
-
-  private
-
-    def state
-      file_system.state(pathname.to_s)
-    end
-  end # FakePathname
-
-  class FileSystem
-    include Adamantium, Concord.new(:file_states)
-
-    def state(filename)
-      file_states.fetch(filename, FileState::DOES_NOT_EXIST)
-    end
-
-    def path(filename)
-      FakePathname.new(self, Pathname.new(filename))
-    end
-  end # FileSystem
-end # MutantSpec