mutant 0.9.2 → 0.9.7

data/lib/mutant/variable.rb

@@ -1,282 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  # Lightweight shared variables
-  #
-  # ignore :reek:TooManyMethods
-  class Variable
-    EMPTY = Class.new do
-      const_set(:INSPECT, 'Mutant::Variable::EMPTY')
-    end.new.freeze
-
-    TIMEOUT = Class.new do
-      const_set(:INSPECT, 'Mutant::Variable::TIMEOUT')
-    end.new.freeze
-
-    # Result of operation that may time out
-    class Result
-      include AbstractType, Adamantium::Flat
-
-      # Test if take resulted in a timeout
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      def timeout?
-        instance_of?(Timeout)
-      end
-
-      abstract_method :value
-
-      # Instance returned on timeouts
-      class Timeout < self
-        include Equalizer.new
-
-        INSTANCE = new
-
-        # Construct new object
-        #
-        # @return [Timeout]
-        def self.new
-          INSTANCE
-        end
-      end # Timeout
-
-      # Instance returned without timeouts
-      class Value < self
-        include Concord::Public.new(:value)
-      end # Value
-    end # Result
-
-    private_constant(*constants(false))
-
-    # Initialize object
-    #
-    # @param [Object] value
-    #   the initial value
-    #
-    # @return [undefined]
-    def initialize(condition_variable:, mutex:, value: EMPTY)
-      @full  = condition_variable.new
-      @mutex = mutex.new
-      @value = value
-    end
-
-    # Take value from mvar, block on empty
-    #
-    # @return [Object]
-    def take
-      synchronize do
-        wait_full
-        perform_take
-      end
-    end
-
-    # Take value from mvar, with timeout
-    #
-    # @param [Float] Timeout
-    #
-    # @return [Result::Timeout]
-    #   in case take resulted in a timeout
-    #
-    # @return [Result::Value]
-    #   in case take resulted in a value
-    def take_timeout(timeout)
-      synchronize do
-        if wait_timeout(@full, timeout, &method(:full?))
-          Result::Timeout.new
-        else
-          Result::Value.new(perform_take)
-        end
-      end
-    end
-
-    # Read value from variable
-    #
-    # @return [Object]
-    #   the contents of the mvar
-    def read
-      synchronize do
-        wait_full
-        @value
-      end
-    end
-
-    # Try put value into the variable, non blocking
-    #
-    # @param [Object] value
-    #
-    # @return [self]
-    def try_put(value)
-      synchronize do
-        perform_put(value) if empty?
-      end
-
-      self
-    end
-
-    # Execute block with value, blocking
-    #
-    # @yield [Object]
-    #
-    # @return [Object]
-    #   the blocks return value
-    def with
-      synchronize do
-        wait_full
-        yield @value
-      end
-    end
-
-  private
-
-    # Perform the put
-    #
-    # @param [Object] value
-    def perform_put(value)
-      (@value = value).tap { @full.signal }
-    end
-
-    # Execute block under mutex
-    #
-    # @return [self]
-    def synchronize(&block)
-      @mutex.synchronize(&block)
-    end
-
-    # Wait for block predicate
-    #
-    # @param [ConditionVariable] event
-    #
-    # @return [undefined]
-    def wait(event)
-      event.wait(@mutex) until yield
-    end
-
-    # Wait with timeout for block predicate
-    #
-    # @param [ConditionVariable] event
-    #
-    # @return [Boolean]
-    #   if wait was terminated due a timeout
-    #
-    # @return [undefined]
-    #   otherwise
-    def wait_timeout(event, timeout)
-      loop do
-        break true if timeout <= 0
-        break if yield
-        timeout -= Timer.elapsed { event.wait(@mutex, timeout) }
-      end
-    end
-
-    # Wait till mvar is full
-    #
-    # @return [undefined]
-    def wait_full
-      wait(@full, &method(:full?))
-    end
-
-    # Test if state is full
-    #
-    # @return [Boolean]
-    def full?
-      !empty?
-    end
-
-    # Test if state is empty
-    #
-    # @return [Boolean]
-    def empty?
-      @value.equal?(EMPTY)
-    end
-
-    # Shared variable that can be written at most once
-    #
-    # ignore :reek:InstanceVariableAssumption
-    class IVar < self
-
-      # Exception raised on ivar errors
-      class Error < RuntimeError; end
-
-      # Put valie into the mvar, raises if already full
-      #
-      # @param [Object] value
-      #
-      # @return [self]
-      #
-      # @raise Error
-      #   if already full
-      def put(value)
-        synchronize do
-          fail Error, 'is immutable' if full?
-          perform_put(value)
-        end
-
-        self
-      end
-
-    private
-
-      # Perform take operation
-      #
-      # @return [Object]
-      def perform_take
-        @value
-      end
-    end # IVar
-
-    # Shared variable that can be written multiple times
-    #
-    # ignore :reek:InstanceVariableAssumption
-    class MVar < self
-
-      # Initialize object
-      #
-      # @param [Object] value
-      #   the initial value
-      #
-      # @return [undefined]
-      def initialize(condition_variable:, mutex:, value: EMPTY)
-        super
-        @empty = condition_variable.new
-      end
-
-      # Put value into mvar, block on full
-      #
-      # @param [Object] value
-      #
-      # @return [self]
-      def put(value)
-        synchronize do
-          wait(@empty, &method(:empty?))
-          perform_put(value)
-        end
-
-        self
-      end
-
-      # Modify mvar
-      #
-      # @return [Object]
-      def modify
-        synchronize do
-          wait_full
-          perform_put(yield(@value))
-        end
-      end
-
-    private
-
-      # Empty the mvar
-      #
-      # @return [Object]
-      def perform_take
-        @value.tap do
-          @value = EMPTY
-          @empty.signal
-        end
-      end
-    end # MVar
-  end # Variable
-end # Mutant

data/spec/unit/mutant/either_spec.rb

@@ -1,247 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Either do
-  describe '.wrap_error' do
-    def apply
-      described_class.wrap_error(error, &block)
-    end
-
-    let(:error) { TestError }
-
-    class TestError < RuntimeError; end
-
-    context 'when block returns' do
-      let(:value) { instance_double(Object, 'value') }
-      let(:block) { -> { value }                     }
-
-      it 'returns right wrapping block value' do
-        expect(apply).to eql(described_class::Right.new(value))
-      end
-    end
-
-    context 'when block raises' do
-      let(:exception) { error.new             }
-      let(:block)     { -> { fail exception } }
-
-      context 'with covered exception' do
-        it 'returns left wrapping exception' do
-          expect(apply).to eql(described_class::Left.new(exception))
-        end
-      end
-
-      context 'with uncovered exception' do
-        let(:exception) { StandardError.new }
-
-        it 'returns raises error' do
-          expect { apply }.to raise_error(StandardError)
-        end
-      end
-    end
-  end
-end
-
-RSpec.describe Mutant::Either::Left do
-  subject { described_class.new(value) }
-
-  let(:block_result) { instance_double(Object, 'block result') }
-  let(:value)        { instance_double(Object, 'value')        }
-  let(:yields)       { []                                      }
-
-  let(:block) do
-    lambda do |value|
-      yields << value
-      block_result
-    end
-  end
-
-  class TestError < RuntimeError; end
-
-  describe '#fmap' do
-    def apply
-      subject.fmap(&block)
-    end
-
-    include_examples 'no block evaluation'
-    include_examples 'requires block'
-    include_examples 'returns self'
-  end
-
-  describe '#apply' do
-    def apply
-      subject.apply(&block)
-    end
-
-    include_examples 'no block evaluation'
-    include_examples 'requires block'
-    include_examples 'returns self'
-  end
-
-  describe '#from_left' do
-    def apply
-      subject.from_left(&block)
-    end
-
-    it 'returns left value' do
-      expect(apply).to be(value)
-    end
-
-    include_examples 'no block evaluation'
-  end
-
-  describe '#from_right' do
-    def apply
-      subject.from_right(&block)
-    end
-
-    context 'without block' do
-      let(:block) { nil }
-
-      it 'raises RuntimeError error' do
-        expect { apply }.to raise_error(
-          RuntimeError,
-          "Expected right value, got #{subject.inspect}"
-        )
-      end
-    end
-
-    context 'with block' do
-      let(:yields)       { []                                      }
-      let(:block_return) { instance_double(Object, 'block-return') }
-
-      let(:block) do
-        lambda do |value|
-          yields << value
-          block_return
-        end
-      end
-
-      it 'calls block with left value' do
-        expect { apply }.to change(yields, :to_a).from([]).to([value])
-      end
-
-      it 'returns block value' do
-        expect(apply).to be(block_return)
-      end
-    end
-  end
-
-  describe '#lmap' do
-    def apply
-      subject.lmap(&block)
-    end
-
-    include_examples 'requires block'
-    include_examples 'Functor#fmap block evaluation'
-  end
-
-  describe '#either' do
-    def apply
-      subject.either(block, -> { fail })
-    end
-
-    include_examples '#apply block evaluation'
-  end
-end
-
-RSpec.describe Mutant::Either::Right do
-  subject { described_class.new(value) }
-
-  let(:block_result) { instance_double(Object, 'block result') }
-  let(:value)        { instance_double(Object, 'value')        }
-  let(:yields)       { []                                      }
-
-  let(:block) do
-    lambda do |value|
-      yields << value
-      block_result
-    end
-  end
-
-  describe '#fmap' do
-    def apply
-      subject.fmap(&block)
-    end
-
-    include_examples 'requires block'
-    include_examples 'Functor#fmap block evaluation'
-  end
-
-  describe '#apply' do
-    def apply
-      subject.apply(&block)
-    end
-
-    include_examples 'requires block'
-    include_examples '#apply block evaluation'
-  end
-
-  describe '#from_left' do
-    def apply
-      subject.from_left(&block)
-    end
-
-    context 'without block' do
-      let(:block) { nil }
-
-      it 'raises RuntimeError error' do
-        expect { apply }.to raise_error(
-          RuntimeError,
-          "Expected left value, got #{subject.inspect}"
-        )
-      end
-    end
-
-    context 'with block' do
-      let(:yields)       { []                                      }
-      let(:block_return) { instance_double(Object, 'block-return') }
-
-      let(:block) do
-        lambda do |value|
-          yields << value
-          block_return
-        end
-      end
-
-      it 'calls block with right value' do
-        expect { apply }.to change(yields, :to_a).from([]).to([value])
-      end
-
-      it 'returns block value' do
-        expect(apply).to be(block_return)
-      end
-    end
-  end
-
-  describe '#from_right' do
-    def apply
-      subject.from_right(&block)
-    end
-
-    it 'returns right value' do
-      expect(apply).to be(value)
-    end
-
-    include_examples 'no block evaluation'
-  end
-
-  describe '#lmap' do
-    def apply
-      subject.lmap(&block)
-    end
-
-    include_examples 'requires block'
-    include_examples 'no block evaluation'
-
-    it 'returns self' do
-      expect(apply).to be(subject)
-    end
-  end
-
-  describe '#either' do
-    def apply
-      subject.either(-> { fail }, block)
-    end
-
-    include_examples '#apply block evaluation'
-  end
-end