mutant 0.8.10 → 0.8.11

data/TODO

@@ -1,21 +0,0 @@
-Code:
-  * Test mutant with dynamically created zombie.
-
-Mutations:
-  * Add true masgn mutations
-  * Add some kind of a "do not touch me object" that raises on all messages.
-    It can be used to make sure each literal value is touched.
-  * Replace nil or add "do not touch me object" to literal mutations.
-  * Mutate options on Regexp literals
-  * Add mutations for dynamic regexp symbol and string literals
-  * Add timeout to terminate infinite loops
-
-Loader:
-  * Make sure loader does not change visibility of injected mutants
-
-Matcher:
-  * Allow matches on attr_reader with literal name argument(s)?
-  * Allow matches on define_method with literal name argument?
-
-jruby-support:
-  * Create a runtime per mutation to kill mutations in isolation

data/lib/mutant/mutator/node/blockarg.rb

@@ -1,13 +0,0 @@
-module Mutant
-  class Mutator
-    class Node
-
-      # Blockarg mutator
-      class Blockarg < Generic
-
-        handle(:blockarg)
-
-      end # Blockarg
-    end # Node
-  end # Mutator
-end # Mutant

data/lib/mutant/mutator/node/restarg.rb

@@ -1,13 +0,0 @@
-module Mutant
-  class Mutator
-    class Node
-
-      # Restarg mutator
-      class Restarg < Generic
-
-        handle(:restarg)
-
-      end # Restarg
-    end # Node
-  end # Mutator
-end # Mutant

data/lib/mutant/mutator/registry.rb

@@ -1,49 +0,0 @@
-module Mutant
-  class Mutator
-    # Registry for mutators
-    class Registry
-
-      # Initialize object
-      #
-      # @return [undefined]
-      def initialize
-        @registry = {}
-      end
-
-      # Raised when the type is an invalid type
-      RegistryError = Class.new(TypeError)
-
-      # Register mutator class for AST node class
-      #
-      # @param [Symbol] type
-      # @param [Class:Mutator] mutator
-      #
-      # @return [self]
-      def register(type, mutator)
-        fail RegistryError, "Invalid type registration: #{type}" unless AST::Types::ALL.include?(type)
-        fail RegistryError, "Duplicate type registration: #{type}" if @registry.key?(type)
-        @registry[type] = mutator
-        self
-      end
-
-      # Lookup mutator class for node
-      #
-      # @param [Parser::AST::Node] node
-      #
-      # @return [Class]
-      #
-      # @raise [ArgumentError]
-      #   raises argument error when mutator class cannot be found
-      def lookup(node)
-        type = node.type
-        @registry.fetch(type) do
-          fail RegistryError, "No mutator to handle: #{type.inspect}"
-        end
-      end
-
-    end # Registry
-
-    REGISTRY = Registry.new
-
-  end # Mutator
-end # Mutant

data/meta/boolean.rb

@@ -1,13 +0,0 @@
-Mutant::Meta::Example.add do
-  source 'true'
-
-  mutation 'nil'
-  mutation 'false'
-end
-
-Mutant::Meta::Example.add do
-  source 'false'
-
-  mutation 'nil'
-  mutation 'true'
-end

data/meta/regex.rb

@@ -1,19 +0,0 @@
-Mutant::Meta::Example.add do
-  source '/foo/'
-
-  singleton_mutations
-  mutation '//'    # match all
-  mutation '/a\A/' # match nothing
-end
-
-Mutant::Meta::Example.add do
-  source '/#{foo.bar}n/'
-
-  singleton_mutations
-  mutation '//' # match all
-  mutation '/#{foo}n/'
-  mutation '/a\A/'         # match nothing
-  mutation '/#{self.bar}n/'
-  mutation '/#{nil}n/'
-  mutation '/#{self}n/'
-end

data/spec/unit/mutant/isolation_spec.rb

@@ -1,104 +0,0 @@
-RSpec.describe Mutant::Isolation::None do
-  before do
-    @initial = 1
-  end
-
-  describe '.run' do
-    let(:object) { described_class }
-
-    it 'does not isolate side effects' do
-      object.call { @initial = 2 }
-      expect(@initial).to be(2)
-    end
-
-    it 'return block value' do
-      expect(object.call { :foo }).to be(:foo)
-    end
-
-    it 'wraps *all* exceptions' do
-      expect { object.call { fail  } }.to raise_error(Mutant::Isolation::Error)
-    end
-
-  end
-end
-
-RSpec.describe Mutant::Isolation::Fork do
-  before do
-    @initial = 1
-  end
-
-  describe '.run' do
-    let(:object) { described_class }
-
-    it 'does isolate side effects' do
-      object.call { @initial = 2  }
-      expect(@initial).to be(1)
-    end
-
-    it 'return block value' do
-      expect(object.call { :foo }).to be(:foo)
-    end
-
-    it 'wraps exceptions' do
-      expect { object.call { fail } }.to raise_error(Mutant::Isolation::Error, 'marshal data too short')
-    end
-
-    it 'wraps exceptions caused by crashing ruby' do
-      expect do
-        object.call do
-          fail RbBug.call
-        end
-      end.to raise_error(Mutant::Isolation::Error)
-    end
-
-    it 'redirects $stderr of children to /dev/null' do
-      begin
-        Tempfile.open('mutant-test') do |file|
-          $stderr = file
-          object.call { $stderr.puts('test') }
-          file.rewind
-          expect(file.read).to eql('')
-        end
-      ensure
-        $stderr = STDERR
-      end
-    end
-
-    context 'uses primitives in correct order' do
-      let(:reader) { instance_double(IO) }
-      let(:writer) { instance_double(IO) }
-
-      before do
-        expect(IO).to receive(:pipe).with(binmode: true).ordered do |&block|
-          block.call([reader, writer])
-        end
-        expect(writer).to receive(:binmode).ordered
-      end
-
-      it 'when fork succeeds' do
-        pid = instance_double(Fixnum)
-        expect(Process).to receive(:fork).ordered.and_yield.and_return(pid)
-        file = instance_double(File)
-        expect(File).to receive(:open).ordered
-          .with(File::NULL, File::WRONLY).and_yield(file)
-        expect($stderr).to receive(:reopen).ordered.with(file)
-        expect(reader).to receive(:close).ordered
-        expect(writer).to receive(:write).ordered.with(Marshal.dump(:foo))
-        expect(writer).to receive(:close).ordered
-        expect(writer).to receive(:close).ordered
-        expect(reader).to receive(:read).ordered.and_return(Marshal.dump(:foo))
-        expect(Process).to receive(:waitpid).with(pid)
-
-        expect(object.call { :foo }).to be(:foo)
-      end
-
-      it 'when fork fails' do
-        expect(Process).to receive(:fork).ordered.and_return(nil)
-        expect(Process).to_not receive(:waitpid)
-        expect(writer).to receive(:close).ordered
-        expect(reader).to receive(:read).ordered.and_return(Marshal.dump(:foo))
-        expect(object.call).to be(:foo)
-      end
-    end
-  end
-end

data/spec/unit/mutant/mutator/registry_spec.rb

@@ -1,57 +0,0 @@
-RSpec.describe Mutant::Mutator::Registry do
-  describe '#lookup' do
-    subject { Mutant::Mutator::REGISTRY.lookup(node) }
-
-    context 'on registered node' do
-      let(:node) { s(:true) }
-
-      it { should eql(Mutant::Mutator::Node::Literal::Boolean) }
-    end
-
-    context 'on unknown node' do
-      let(:node) { s(:unknown) }
-
-      it 'raises error' do
-        expect { subject }.to raise_error(described_class::RegistryError, 'No mutator to handle: :unknown')
-      end
-    end
-  end
-
-  describe '#register' do
-    let(:object) { described_class.new }
-
-    let(:mutator) { instance_double(Mutant::Mutator) }
-
-    subject { object.register(type, mutator) }
-
-    context 'when registering an invalid node type' do
-      let(:type) { :invalid }
-
-      it 'raises error' do
-        expect { subject }.to raise_error(described_class::RegistryError, 'Invalid type registration: invalid')
-      end
-    end
-
-    context 'when registering a valid node type' do
-      let(:type) { :true }
-
-      it 'allows to lookup mutator' do
-        subject
-        expect(object.lookup(s(type))).to be(mutator)
-      end
-
-      it_behaves_like 'a command method'
-    end
-
-    context 'when duplicate the registration of a valid node type' do
-      let(:type) { :true }
-
-      it 'allows to lookup mutator' do
-        object.register(type, mutator)
-        expect { subject }.to raise_error(described_class::RegistryError, 'Duplicate type registration: true')
-      end
-
-      it_behaves_like 'a command method'
-    end
-  end
-end