mutant 0.7.1 → 0.7.2

data/lib/mutant/reporter/trace.rb

@@ -21,6 +21,18 @@ module Mutant
         end
       end
 
+      REPORT_DELAY = 0.0
+
+      # Return report delay
+      #
+      # @return [Float]
+      #
+      # @api private
+      #
+      def delay
+        REPORT_DELAY
+      end
+
     end # Tracker
   end # reporter
 end # Mutant

data/lib/mutant/result.rb

@@ -28,7 +28,7 @@ module Mutant
       def self.included(host)
         super
 
-        host.memoize :coverage
+        host.memoize(:coverage)
       end
 
     end # Coverage
@@ -52,7 +52,7 @@ module Mutant
         define_method(name) do
           public_send(collection).map(&name).reduce(0, :+)
         end
-        memoize name
+        memoize(name)
       end
     end # ClassMethods
 
@@ -248,7 +248,7 @@ module Mutant
 
     # Mutation result
     class Mutation
-      include Result, Anima.new(:mutation, :test_result, :index)
+      include Result, Anima.new(:mutation, :test_result)
 
       # Return runtime
       #

data/lib/mutant/runner.rb

@@ -22,9 +22,6 @@ module Mutant
       include Adamantium::Flat, Anima.new(:job, :result)
     end
 
-    REPORT_FREQUENCY = 20.0
-    REPORT_DELAY     = 1 / REPORT_FREQUENCY
-
     # Initialize object
     #
     # @return [undefined]
@@ -37,7 +34,7 @@ module Mutant
       reporter.start(env)
       config.integration.setup
 
-      @master = config.actor_env.current.bind(Master.call(env))
+      @master = config.actor_env.new_mailbox.bind(Master.call(env))
 
       status = nil
 
@@ -45,7 +42,7 @@ module Mutant
         status = current_status
         break if status.done
         reporter.progress(status)
-        Kernel.sleep(REPORT_DELAY)
+        Kernel.sleep(reporter.delay)
       end
 
       reporter.progress(status)

data/lib/mutant/runner/worker.rb

@@ -17,7 +17,7 @@ module Mutant
       def self.run(attributes)
         attributes.fetch(:config).actor_env.spawn do |actor|
           worker = new(attributes)
-          worker.send(:run, actor)
+          worker.__send__(:run, actor)
         end
       end
 
@@ -67,22 +67,20 @@ module Mutant
       # @api private
       #
       def handle_job(job)
-        parent.call(Actor::Message.new(:result, JobResult.new(job: job, result: run_mutation(job))))
+        parent.call(Actor::Message.new(:result, JobResult.new(job: job, result: run_mutation(job.mutation))))
       end
 
       # Run mutation
       #
       # @param [Mutation] mutation
       #
-      # @return [Report::Mutation]
+      # @return [Result::Mutation]
       #
       # @api private
       #
-      def run_mutation(job)
-        mutation = job.mutation
+      def run_mutation(mutation)
         test_result = mutation.kill(config.isolation, config.integration)
         Result::Mutation.new(
-          index:       job.index,
           mutation:    mutation,
           test_result: test_result
         )

data/lib/mutant/subject.rb

@@ -13,7 +13,9 @@ module Mutant
     #
     def mutations
       mutations = [neutral_mutation]
-      generate_mutations(mutations)
+      Mutator.each(node) do |mutant|
+        mutations << Mutation::Evil.new(self, wrap_node(mutant))
+      end
       mutations
     end
     memoize :mutations
@@ -56,6 +58,18 @@ module Mutant
       self
     end
 
+    # Return source lines
+    #
+    # @return [Range<Fixnum>]
+    #
+    # @api private
+    #
+    def source_lines
+      expression = node.location.expression
+      expression.line..expression.source_buffer.decompose_position(expression.end_pos).first
+    end
+    memoize :source_lines
+
     # Return source line
     #
     # @return [Fixnum]
@@ -63,7 +77,7 @@ module Mutant
     # @api private
     #
     def source_line
-      node.location.expression.line
+      source_lines.begin
     end
 
     # Return subject identification
@@ -84,7 +98,7 @@ module Mutant
     # @api private
     #
     def source
-      Unparser.unparse(node)
+      Unparser.unparse(wrap_node(node))
     end
     memoize :source
 
@@ -113,21 +127,19 @@ module Mutant
     # @api private
     #
     def neutral_mutation
-      Mutation::Neutral.new(self, node)
+      Mutation::Neutral.new(self, wrap_node(node))
     end
 
-    # Generate mutations
+    # Wrap node into subject specific container
     #
-    # @param [#<<] emitter
+    # @param [Parser::AST::Node] node
     #
-    # @return [undefined]
+    # @return [Parser::AST::Node]
     #
     # @api private
     #
-    def generate_mutations(emitter)
-      Mutator.each(node) do |mutant|
-        emitter << Mutation::Evil.new(self, mutant)
-      end
+    def wrap_node(node)
+      node
     end
 
   end # Subject

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

@@ -25,7 +25,7 @@ module Mutant
         # @api private
         #
         def prepare
-          scope.send(:undef_method, name)
+          scope.__send__(:undef_method, name)
           self
         end
 
@@ -33,17 +33,6 @@ module Mutant
         class Memoized < self
           include AST::Sexp
 
-          # Return source
-          #
-          # @return [String]
-          #
-          # @api private
-          #
-          def source
-            Unparser.unparse(memoizer_node(node))
-          end
-          memoize :source
-
           # Prepare subject for mutation insertion
           #
           # @return [self]
@@ -51,37 +40,13 @@ module Mutant
           # @api private
           #
           def prepare
-            scope.send(:memoized_methods).instance_variable_get(:@memory).delete(name)
+            scope.__send__(:memoized_methods).instance_variable_get(:@memory).delete(name)
             super
             self
           end
 
         private
 
-          # Return mutations
-          #
-          # @param [#<<] emitter
-          #
-          # @return [undefined]
-          #
-          # @api private
-          #
-          def generate_mutations(emitter)
-            Mutator.each(node) do |mutant|
-              emitter << Mutation::Evil.new(self, memoizer_node(mutant))
-            end
-          end
-
-          # Return neutral mutation
-          #
-          # @return [Mutation::Neutral]
-          #
-          # @api private
-          #
-          def neutral_mutation
-            Mutation::Neutral.new(self, memoizer_node(node))
-          end
-
           # Return memoizer node for mutant
           #
           # @param [Parser::AST::Node] mutant
@@ -90,7 +55,7 @@ module Mutant
           #
           # @api private
           #
-          def memoizer_node(mutant)
+          def wrap_node(mutant)
             s(:begin, mutant, s(:send, nil, :memoize, s(:args, s(:sym, name))))
           end
 

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

@@ -25,7 +25,7 @@ module Mutant
         # @api private
         #
         def prepare
-          scope.singleton_class.send(:undef_method, name)
+          scope.singleton_class.__send__(:undef_method, name)
           self
         end
 

data/lib/mutant/version.rb

@@ -1,4 +1,4 @@
 module Mutant
   # The current mutant version
-  VERSION = '0.7.1'.freeze
+  VERSION = '0.7.2'.freeze
 end # Mutant

data/mutant.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |gem|
   gem.extra_rdoc_files = %w[TODO LICENSE]
   gem.executables      = %w[mutant]
 
-  gem.required_ruby_version = '>= 1.9.3'
+  gem.required_ruby_version = '>= 2.0.0'
 
   gem.add_runtime_dependency('parser',        '~> 2.2.pre.7')
   gem.add_runtime_dependency('ast',           '~> 2.0')

data/spec/spec_helper.rb

@@ -11,6 +11,8 @@ if ENV['COVERAGE'] == 'true'
     add_filter 'lib/mutant/meta/*'
     add_filter 'lib/mutant/zombifier'
     add_filter 'lib/mutant/zombifier/*'
+    # Trace points shadow each other under 2.0 (fixed in 2.1)
+    add_filter 'lib/mutant/line_trace.rb' if RUBY_VERSION.eql?('2.0.0')
 
     minimum_coverage 100
   end

data/spec/support/fake_actor.rb

@@ -40,26 +40,32 @@ module FakeActor
   end
 
   class Env
-    include Concord.new(:messages, :actor_names)
+    include Concord.new(:messages, :mailbox_names)
 
     def spawn
-      name = @actor_names.shift
-      raise 'Tried to spawn actor when no name available' unless name
-      actor = actor(name)
-      yield actor if block_given?
-      actor.sender
+      mailbox = mailbox(next_name)
+      yield mailbox if block_given?
+      mailbox.sender
     end
 
-    def current
-      actor(:current)
+    def mailbox(name)
+      Mailbox.new(name, @messages)
     end
 
-    def actor(name)
-      Actor.new(name, @messages)
+    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 Actor
+  class Mailbox
     include Concord.new(:name, :messages)
 
     def receiver

data/spec/support/shared_context.rb

@@ -85,7 +85,6 @@ module SharedContext
 
     let(:mutation_a_result) do
       Mutant::Result::Mutation.new(
-        index:       1,
         mutation:    mutation_a,
         test_result: mutation_a_test_result
       )
@@ -93,7 +92,6 @@ module SharedContext
 
     let(:mutation_b_result) do
       Mutant::Result::Mutation.new(
-        index:       1,
         mutation:    mutation_a,
         test_result: mutation_b_test_result
       )

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

@@ -1,32 +1,13 @@
 RSpec.describe Mutant::Actor::Env do
-  let(:mutex)       { double('Mutex')                           }
-  let(:thread)      { double('Thread')                          }
-  let(:thread_root) { double('Thread Root')                     }
-  let(:actor)       { Mutant::Actor::Actor.new(thread, mailbox) }
+  let(:thread)      { double('Thread')      }
+  let(:thread_root) { double('Thread Root') }
 
   let(:object) { described_class.new(thread_root) }
 
-  before do
-    expect(Mutex).to receive(:new).and_return(mutex)
-  end
-
-  describe '#current' do
-    subject { object.current }
-
-    let!(:mailbox)    { Mutant::Actor::Mailbox.new                }
-
-    before do
-      expect(Mutant::Actor::Mailbox).to receive(:new).and_return(mailbox).ordered
-      expect(thread_root).to receive(:current).and_return(thread)
-    end
-
-    it { should eql(actor) }
-  end
-
   describe '#spawn' do
     subject { object.spawn(&block) }
 
-    let!(:mailbox)    { Mutant::Actor::Mailbox.new                }
+    let!(:mailbox) { Mutant::Actor::Mailbox.new }
 
     let(:yields) { [] }
 
@@ -35,15 +16,14 @@ RSpec.describe Mutant::Actor::Env do
     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
-      expect(thread_root).to receive(:current).and_return(thread).ordered
     end
 
     it 'returns sender' do
-      should eql(actor.sender)
+      should be(mailbox.sender)
     end
 
     it 'yields actor' do
-      expect { subject }.to change { yields }.from([]).to([actor])
+      expect { subject }.to change { yields }.from([]).to([mailbox])
     end
   end
 end

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

@@ -0,0 +1,29 @@
+RSpec.describe Mutant::Actor::Mailbox do
+  let(:mutex)              { double('Mutex') }
+  let(:condition_variable) { double('Mutex') }
+
+  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 }
+
+    let(:object) { described_class.new }
+    let(:thread) { double('Thread')    }
+
+    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)  { double('Sender')    }
+
+    subject { object.bind(other) }
+
+    it { should eql(Mutant::Actor::Binding.new(object, other)) }
+  end
+end

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

@@ -1,36 +1,34 @@
 RSpec.describe Mutant::Actor::Receiver do
-  let(:mailbox) { double('Mailbox') }
-  let(:mutex)   { double('Mutex')   }
-  let(:message) { double('Message') }
+  let(:messages)           { double('Messages')           }
+  let(:mutex)              { double('Mutex')              }
+  let(:condition_variable) { double('Condition Variable') }
+  let(:message)            { double('Message')            }
 
-  let(:object) { described_class.new(mutex, mailbox) }
+  let(:object) { described_class.new(condition_variable, mutex, messages) }
 
   describe '#call' do
     subject { object.call }
 
-    context 'when mailbox contains a message' do
+    context 'when messages contains a message' do
       before do
-        expect(mutex).to receive(:lock).ordered
-        expect(mailbox).to receive(:empty?).and_return(false).ordered
-        expect(mailbox).to receive(:shift).and_return(message).ordered
-        expect(mutex).to receive(:unlock).ordered
+        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 mailbox initially contains no message' do
+    context 'when messages initially contains no message' do
       before do
         # 1rst failing try
-        expect(mutex).to receive(:lock).ordered
-        expect(mailbox).to receive(:empty?).and_return(true).ordered
-        expect(mutex).to receive(:unlock).ordered
-        expect(Thread).to receive(:stop).ordered
+        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(:lock).ordered
-        expect(mailbox).to receive(:empty?).and_return(false).ordered
-        expect(mailbox).to receive(:shift).and_return(message).ordered
-        expect(mutex).to receive(:unlock).ordered
+        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
@@ -38,21 +36,19 @@ RSpec.describe Mutant::Actor::Receiver do
       end
     end
 
-    context 'when mailbox contains no message but thread gets waken without message arrived' do
+    context 'when messages contains no message but thread gets waken without message arrived' do
       before do
         # 1rst failing try
-        expect(mutex).to receive(:lock).ordered
-        expect(mailbox).to receive(:empty?).and_return(true).ordered
-        expect(mutex).to receive(:unlock).ordered
-        expect(Thread).to receive(:stop).ordered
+        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(:lock).ordered
-        expect(mailbox).to receive(:empty?).and_return(true).ordered
-        expect(mutex).to receive(:unlock).ordered
-        expect(Thread).to receive(:stop).ordered
+        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 'waits for message' do
+      it 'fails with error' do
         expect { subject }.to raise_error(Mutant::Actor::ProtocolError)
       end
     end