mutant 0.10.21 → 0.10.26

data/lib/mutant/selector.rb

@@ -3,7 +3,7 @@
 module Mutant
   # Abstract base class for test selectors
   class Selector
-    include AbstractType, Adamantium::Flat
+    include AbstractType, Adamantium
 
     # Tests for subject
     #

data/lib/mutant/subject.rb

@@ -3,10 +3,8 @@
 module Mutant
   # Subject of a mutation
   class Subject
-    include AbstractType, Adamantium::Flat, Enumerable
-    include Anima.new(:context, :node, :warnings)
-
-    private :warnings
+    include AbstractType, Adamantium, Enumerable
+    include Anima.new(:context, :node)
 
     # Mutations for this subject
     #

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

@@ -13,9 +13,7 @@ module Mutant
         #
         # @return [self]
         def prepare
-          warnings.call do
-            scope.public_send(:undef_method, name)
-          end
+          scope.undef_method(name)
           self
         end
 
@@ -23,59 +21,22 @@ module Mutant
         class Memoized < self
           include AST::Sexp
 
-          FREEZER_OPTION_VALUES = {
-            Adamantium::Freezer::Deep => :deep,
-            Adamantium::Freezer::Flat => :flat,
-            Adamantium::Freezer::Noop => :noop
-          }.freeze
-
-          private_constant(*constants(false))
-
           # Prepare subject for mutation insertion
           #
           # @return [self]
           def prepare
-            memory.delete(name)
+            scope
+              .instance_variable_get(:@memoized_methods)
+              .delete(name)
+
             super()
           end
 
         private
 
           def wrap_node(mutant)
-            s(:begin, mutant, s(:send, nil, :memoize, s(:sym, name), *options))
-          end
-
-          # The optional AST node for adamantium memoization options
-          #
-          # @return [Array(Parser::AST::Node), nil]
-          def options
-            # rubocop:disable Style/GuardClause
-            if FREEZER_OPTION_VALUES.key?(freezer)
-              [
-                s(:hash,
-                  s(:pair,
-                    s(:sym, :freezer),
-                    s(:sym, FREEZER_OPTION_VALUES.fetch(freezer))))
-              ]
-            end
-            # rubocop:enable Style/GuardClause
+            s(:begin, mutant, s(:send, nil, :memoize, s(:sym, name)))
           end
-
-          # The freezer used for memoization
-          #
-          # @return [Object]
-          def freezer
-            memory.fetch(name).instance_variable_get(:@freezer)
-          end
-          memoize :freezer, freezer: :noop
-
-          # The memory used for memoization
-          #
-          # @return [ThreadSafe::Cache]
-          def memory
-            scope.__send__(:memoized_methods).instance_variable_get(:@memory)
-          end
-
         end # Memoized
       end # Instance
     end # Method

data/lib/mutant/timer.rb

@@ -14,8 +14,8 @@ module Mutant
     class Deadline
       include Anima.new(:timer, :allowed_time)
 
-      def initialize(**arguments)
-        super(**arguments)
+      def initialize(*arguments)
+        super(*arguments)
         @start_at = timer.now
       end
 

data/lib/mutant/transform.rb

@@ -73,6 +73,31 @@ module Mutant
       end
     end # Named
 
+    class Block < self
+      include Anima.new(:block, :name)
+
+      def self.capture(name, &block)
+        new(block: block, name: name)
+      end
+
+      def call(input)
+        block
+          .call(input)
+          .lmap do |message|
+            Error.new(
+              cause:     nil,
+              input:     input,
+              message:   message,
+              transform: self
+            )
+          end
+      end
+
+      def slug
+        name
+      end
+    end
+
   private
 
     def error(cause: nil, input:, message: nil)

data/lib/mutant/variable.rb

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+module Mutant
+  # Lightweight concurrency variables
+  #
+  # These are inspired by Haskells MVar and IVar types.
+  class Variable
+    EMPTY = Class.new do
+      const_set(:INSPECT, 'Variable::EMPTY')
+    end.new.freeze
+
+    TIMEOUT = Class.new do
+      const_set(:INSPECT, 'Variable::TIMEOUT')
+    end.new.freeze
+
+    # Result of operation that may time out
+    class Result
+      include Equalizer.new(:value)
+      attr_reader :value
+
+      # Initialize result
+      #
+      # @return [undefined]
+      def initialize(value)
+        @value = value
+        freeze
+      end
+
+      # Test if take resulted in a timeout
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def timeout?
+        instance_of?(Timeout)
+      end
+
+      # Instance returned on timeouts
+      class Timeout < self
+        INSTANCE = new(nil)
+
+        # Construct new object
+        #
+        # @return [Timeout]
+        def self.new
+          INSTANCE
+        end
+      end # Timeout
+
+      # Instance returned without timeouts
+      class Value < self
+      end # Value
+    end # Result
+
+    private_constant(*constants(false))
+
+    module Timer
+      # Monotonic elapsed time of block execution
+      #
+      # @return [Float]
+      def self.elapsed
+        start = now
+        yield
+        now - start
+      end
+
+      # The now monotonic time
+      #
+      # @return [Float]
+      def self.now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+      private_class_method :now
+    end # Timer
+
+    # 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, block on empty
+    #
+    # @return [Object]
+    def take
+      synchronize do
+        wait_full
+        perform_take
+      end
+    end
+
+    # Take value, 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, block on empty
+    #
+    # @return [Object]
+    #   the variable value
+    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 value, 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
+
+      # Populate and return value, use block to compute value if empty
+      #
+      # The block is guaranteed to be executed at max once.
+      #
+      # Subsequent reads are guaranteed to return the block value.
+      #
+      # @return [Object]
+      def populate_with
+        return @value if full?
+
+        synchronize do
+          perform_put(yield) if empty?
+        end
+
+        @value
+      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, block on full
+      #
+      # @param [Object] value
+      #
+      # @return [self]
+      def put(value)
+        synchronize do
+          wait(@empty, &method(:empty?))
+          perform_put(value)
+        end
+
+        self
+      end
+
+      # Modify value, blocks if empty
+      #
+      # @return [Object]
+      def modify
+        synchronize do
+          wait_full
+          perform_put(yield(@value))
+        end
+      end
+
+    private
+
+      # Empty the variable
+      #
+      # @return [Object]
+      def perform_take
+        @value.tap do
+          @value = EMPTY
+          @empty.signal
+        end
+      end
+    end # MVar
+  end # Variable
+end # Mutant