mutant 0.8.24 → 0.9.0

data/meta/regexp/regexp_eol_anchor.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :regexp_eol_anchor do
-  source '/$/'
-
-  singleton_mutations
-  regexp_mutations
-
-  mutation '/\z/'
-end

data/meta/regexp/regexp_eos_anchor.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :regexp_eos_anchor do
-  source '/\z/'
-
-  singleton_mutations
-  regexp_mutations
-end

data/meta/regexp/regexp_eos_ob_eol_anchor.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :regexp_eos_ob_eol_anchor do
-  source '/\Z/'
-
-  singleton_mutations
-  regexp_mutations
-
-  mutation '/\z/'
-end

data/meta/regexp/regexp_greedy_zero_or_more.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :regexp_greedy_zero_or_more do
-  source '/\d*/'
-
-  singleton_mutations
-  regexp_mutations
-
-  mutation '/\d/'
-  mutation '/\d+/'
-  mutation '/\D*/'
-end

data/meta/regexp/regexp_root_expression.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :regexp_root_expression do
-  source '/^/'
-
-  singleton_mutations
-  regexp_mutations
-
-  mutation '/\\A/'
-end

data/meta/restarg.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :restarg do
-  source 'def foo(*bar); end'
-
-  mutation 'def foo; end'
-  mutation 'def foo(*bar); bar = []; end'
-  mutation 'def foo(*bar); raise; end'
-  mutation 'def foo(*bar); super; end'
-end

data/spec/support/fake_actor.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-require 'mutant/actor'
-
-# A fake actor used from specs
-module FakeActor
-  class Expectation
-    include Concord::Public.new(:name, :message, :block)
-    include Equalizer.new(:name, :message)
-
-    def self.new(_name, _message, _block = nil)
-      super
-    end
-
-    def verify(other)
-      unless eql?(other)
-        fail "Got:\n#{other.inspect}\nExpected:\n#{inspect}"
-      end
-      block&.call(other.message)
-    end
-  end # Expectation
-
-  class MessageSequence
-    include Adamantium::Flat, Concord::Public.new(:messages)
-
-    def self.new
-      super([])
-    end
-
-    def add(name, *message_arguments, &block)
-      messages << Expectation.new(name, Mutant::Actor::Message.new(*message_arguments), block)
-      self
-    end
-
-    def sending(expectation)
-      fail "Unexpected send: #{expectation.inspect}" if messages.empty?
-      expected = messages.shift
-      expected.verify(expectation)
-      self
-    end
-
-    def receiving(name)
-      fail "No message to read for #{name.inspect}" if messages.empty?
-      expected = messages.shift
-      fail "Unexpected message #{expected.inspect} for #{name.inspect}" unless expected.name.eql?(name)
-      expected.message
-    end
-
-    def consumed?
-      messages.empty?
-    end
-  end # MessageSequence
-
-  class Env
-    include Concord.new(:messages, :mailbox_names)
-
-    def spawn
-      mailbox = mailbox(next_name)
-      yield mailbox if block_given?
-      mailbox.sender
-    end
-
-    def mailbox(name)
-      Mailbox.new(name, @messages)
-    end
-
-    def new_mailbox
-      mailbox(:current)
-    end
-
-  private
-
-    def next_name
-      @mailbox_names.shift.tap do |name|
-        name or fail 'Tried to spawn actor when no name available'
-      end
-    end
-  end # Env
-
-  class Mailbox
-    include Concord.new(:name, :messages)
-
-    def receiver
-      Receiver.new(name, messages)
-    end
-
-    def sender
-      Sender.new(name, messages)
-    end
-
-    def bind(sender)
-      Mutant::Actor::Binding.new(self, sender)
-    end
-  end # Mailbox
-
-  class Sender
-    include Concord.new(:name, :messages)
-
-    def call(message)
-      messages.sending(Expectation.new(name, message))
-    end
-  end # Sender
-
-  class Receiver
-    include Concord::Public.new(:name, :messages)
-
-    def call
-      messages.receiving(name)
-    end
-  end # Receiver
-end # FakeActor

data/spec/support/warning.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require 'equalizer'
-require 'memoizable'
-require 'ice_nine'
-
-module MutantSpec
-  class Warning
-    def self.assert_no_warnings
-      return if EXTRACTOR.warnings.empty?
-
-      fail UnexpectedWarnings, EXTRACTOR.warnings.to_a
-    end
-
-    class UnexpectedWarnings < StandardError
-      MSG = 'Unexpected warnings: %s'
-
-      def initialize(warnings)
-        super(MSG % warnings.join("\n"))
-      end
-    end
-
-    class Extractor < DelegateClass(IO)
-      PATTERN = /\A(?:.+):(?:\d+): warning: (?:.+)\n\z/.freeze
-
-      include Equalizer.new(:whitelist, :seen, :io), Memoizable
-
-      def initialize(io, whitelist)
-        @whitelist = whitelist
-        @seen      = Set.new
-        @io        = io
-
-        super(io)
-      end
-
-      def write(message)
-        return super if PATTERN !~ message
-
-        add(message.chomp)
-
-        self
-      end
-
-      def warnings
-        seen.dup
-      end
-      memoize :warnings
-
-    private
-
-      def add(warning)
-        return if whitelist.any?(&warning.public_method(:end_with?))
-
-        seen << warning
-      end
-
-      attr_reader :whitelist, :seen, :io
-    end
-
-    warnings  = Pathname.new(__dir__).join('warnings.yml').freeze
-    whitelist = IceNine.deep_freeze(YAML.load(warnings.read)) # rubocop:disable Security/YAMLLoad
-
-    EXTRACTOR = Extractor.new(STDERR, whitelist)
-  end
-end

data/spec/unit/mutant/actor/binding_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Actor::Binding do
-  let(:actor_a)    { instance_double(Mutant::Actor::Mailbox, sender: sender_a, receiver: receiver_a) }
-  let(:sender_a)   { instance_double(Mutant::Actor::Sender)                                          }
-  let(:sender_b)   { instance_double(Mutant::Actor::Sender)                                          }
-  let(:receiver_a) { instance_double(Mutant::Actor::Receiver)                                        }
-  let(:payload)    { instance_double(Object)                                                         }
-  let(:type)       { instance_double(Symbol)                                                         }
-
-  let(:object) { described_class.new(actor_a, sender_b) }
-
-  describe '#call' do
-    subject { object.call(type) }
-
-    before do
-      expect(sender_b).to receive(:call).with(message(type, sender_a)).ordered
-      expect(receiver_a).to receive(:call).ordered.and_return(message(response_type, payload))
-    end
-
-    context 'when return type equals request type' do
-      let(:response_type) { type }
-      it { should be(payload) }
-    end
-
-    context 'when return type NOT equals request type' do
-      let(:response_type) { double('Other Type') }
-
-      it 'raises error' do
-        expect { subject }.to raise_error(Mutant::Actor::ProtocolError, "Expected #{type} but got #{response_type}")
-      end
-    end
-  end
-end

data/spec/unit/mutant/actor/env_spec.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Actor::Env do
-  let(:thread)      { instance_double(Thread) }
-  let(:thread_root) { class_double(Thread)    }
-
-  let(:object) { described_class.new(thread_root) }
-
-  describe '#spawn' do
-    subject { object.spawn(&block) }
-
-    let!(:mailbox) { Mutant::Actor::Mailbox.new }
-
-    let(:yields) { [] }
-
-    let(:block) { ->(actor) { yields << actor } }
-
-    before do
-      expect(Mutant::Actor::Mailbox).to receive(:new).and_return(mailbox).ordered
-      expect(thread_root).to receive(:new).and_yield.and_return(thread).ordered
-    end
-
-    it 'returns sender' do
-      should be(mailbox.sender)
-    end
-
-    it 'yields actor' do
-      expect { subject }.to change { yields }.from([]).to([mailbox])
-    end
-  end
-end

data/spec/unit/mutant/actor/mailbox_spec.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Actor::Mailbox do
-  let(:mutex)              { instance_double(Mutex)             }
-  let(:condition_variable) { instance_double(ConditionVariable) }
-
-  before do
-    allow(Mutex).to receive(:new).and_return(mutex)
-    allow(ConditionVariable).to receive(:new).and_return(condition_variable)
-  end
-
-  describe '.new' do
-    subject { described_class.new }
-
-    its(:sender) { should eql(Mutant::Actor::Sender.new(condition_variable, mutex, [])) }
-    its(:receiver) { should eql(Mutant::Actor::Receiver.new(condition_variable, mutex, [])) }
-
-  end
-
-  describe '#bind' do
-    let(:object) { described_class.new                    }
-    let(:other)  { instance_double(Mutant::Actor::Sender) }
-
-    subject { object.bind(other) }
-
-    it { should eql(Mutant::Actor::Binding.new(object, other)) }
-  end
-end

data/spec/unit/mutant/actor/message_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Actor::Message do
-
-  let(:type)    { instance_double(Symbol) }
-  let(:payload) { instance_double(Object) }
-
-  describe '.new' do
-    subject { described_class.new(*arguments) }
-
-    context 'with one argument' do
-      let(:arguments) { [type] }
-
-      its(:type)    { should be(type) }
-      its(:payload) { should be(Mutant::Actor::Undefined) }
-    end
-
-    context 'with two arguments' do
-      let(:arguments) { [type, payload] }
-
-      its(:type)    { should be(type)    }
-      its(:payload) { should be(payload) }
-    end
-  end
-end

data/spec/unit/mutant/actor/receiver_spec.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Actor::Receiver do
-  let(:messages)           { instance_double(Array)             }
-  let(:mutex)              { instance_double(Mutex)             }
-  let(:condition_variable) { instance_double(ConditionVariable) }
-  let(:message)            { instance_double(Object)            }
-
-  let(:object) { described_class.new(condition_variable, mutex, messages) }
-
-  describe '#call' do
-    subject { object.call }
-
-    context 'when messages contains a message' do
-      before do
-        expect(mutex).to receive(:synchronize).and_yield.ordered
-        expect(messages).to receive(:empty?).and_return(false).ordered
-        expect(messages).to receive(:shift).and_return(message).ordered
-      end
-
-      it { should be(message) }
-    end
-
-    context 'when messages initially contains no message' do
-      before do
-        # 1rst failing try
-        expect(mutex).to receive(:synchronize).and_yield.ordered
-        expect(messages).to receive(:empty?).and_return(true).ordered
-        expect(condition_variable).to receive(:wait).with(mutex).ordered
-        # 2nd successful try
-        expect(mutex).to receive(:synchronize).and_yield.ordered
-        expect(messages).to receive(:empty?).and_return(false).ordered
-        expect(messages).to receive(:shift).and_return(message).ordered
-      end
-
-      it 'waits for message' do
-        should be(message)
-      end
-    end
-
-    context 'when messages contains no message but thread gets waken without message arrived' do
-      before do
-        # 1rst failing try
-        expect(mutex).to receive(:synchronize).and_yield.ordered
-        expect(messages).to receive(:empty?).and_return(true).ordered
-        expect(condition_variable).to receive(:wait).with(mutex).ordered
-        # 2nd failing try
-        expect(mutex).to receive(:synchronize).and_yield.ordered
-        expect(messages).to receive(:empty?).and_return(true).ordered
-        expect(condition_variable).to receive(:wait).with(mutex).ordered
-      end
-
-      it 'fails with error' do
-        expect { subject }.to raise_error(Mutant::Actor::ProtocolError)
-      end
-    end
-  end
-end

data/spec/unit/mutant/actor/sender_spec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Actor::Sender do
-  let(:object) { described_class.new(condition_variable, mutex, messages) }
-
-  let(:condition_variable) { instance_double(ConditionVariable) }
-  let(:mutex)              { instance_double(Mutex)             }
-  let(:messages)           { instance_double(Array)             }
-  let(:type)               { instance_double(Symbol)            }
-  let(:payload)            { instance_double(Object)            }
-  let(:_message)           { message(type, payload)             }
-
-  describe '#call' do
-    subject { object.call(_message) }
-
-    before do
-      expect(mutex).to receive(:synchronize).ordered.and_yield
-      expect(messages).to receive(:<<).with(_message).ordered
-      expect(condition_variable).to receive(:signal).ordered
-    end
-
-    it_should_behave_like 'a command method'
-  end
-end