mutant 0.8.24 → 0.9.0

data/lib/mutant/variable.rb

@@ -0,0 +1,282 @@
+# 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/lib/mutant/version.rb

@@ -2,5 +2,5 @@
 
 module Mutant
   # Current mutant version
-  VERSION = '0.8.24'
+  VERSION = '0.9.0'
 end # Mutant

data/lib/mutant/warnings.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Mutant
+  # Class to capture warnings generated by Kernel#warn and Ruby itself.
+  #
+  # @example
+  #   capture = Mutant::Warnings.new(Warning)
+  #
+  #   # Note that this test case shows we can capture warnings generated from C
+  #   def ruby_warning
+  #     Class.new do
+  #       undef :initialize
+  #     end
+  #   end
+  #
+  #   messages = capture.call do
+  #     ruby_warning
+  #   end
+  #
+  #   messages # => ["some_file.rb:44: warning: undefining `initialize' may cause serious problems\n"]
+  #
+  # Note this API is fundamentally impure:
+  #
+  # * Unlike almost all of classes in the mutant code base it has internal
+  #   mutable state
+  # * Its therefore NOT thread safe
+  # * And worst: Each instance, even after its not referenced anymore by user
+  #   code: Leaks permanent global state as instances of this class hook
+  #   itself into the `Warning` module.
+  #
+  # So ideally only make *one* instance, and re-use it.
+  #
+  # Also note, a more canonical implementation would prepend modules and simply
+  # call `super` in the event the capture is disabled. This sadly does not
+  # work as it would inference with various bad players in the ruby ecosystem
+  # that do not adhere to the semantics outlined in the documentation.
+  #
+  # See: https://ruby-doc.org/core-2.6.3/Warning.html
+  #
+  # For example in case rubygems is active it adds its own hook to warnings,
+  # that would in case of the super implementation cause infinite recursion.
+  #
+  # Reproduction for this case is as simple as:
+  #
+  # ```
+  # require 'rubygems'
+  #
+  # module Warning
+  #   def warn(*)
+  #     super
+  #   end
+  # end
+  # ```
+  #
+  # For that reason we do have to use the original method capture to dispatch
+  # in disabled state.
+  #
+  # :reek:ignore RepeatedConditional
+  class Warnings
+    # Error raised when warning capture is used recursively
+    class RecursiveUseError < RuntimeError; end
+
+    # Initialize object
+    #
+    # @param [Module] warning
+    #   the module to integrate against
+    #
+    # @return [undefined]
+    def initialize(warning)
+      @disabled = true
+      @messages = []
+      @original = warning.public_method(:warn)
+
+      capture = method(:capture)
+      warning.module_eval do
+        module_function define_method(:warn, &capture)
+      end
+    end
+
+    # Run a block with warning collection enabled
+    #
+    # @return [Array<String>]
+    def call
+      assert_no_recursion
+      @disabled = nil
+      yield
+      IceNine.deep_freeze(@messages.dup)
+    ensure
+      @disabled = true
+      @messages.clear
+    end
+
+  private
+
+    # Hook called when capturing a warning
+    #
+    # @return [undefined]
+    def capture(*arguments)
+      if @disabled
+        @original.call(*arguments)
+      else
+        @messages << arguments
+      end
+    end
+
+    # Assert warnings capture does not call itself
+    #
+    # Its currently not supported nor intended to be supported.
+    def assert_no_recursion
+      fail RecursiveUseError unless @disabled
+    end
+  end # Warnings
+end # Mutant

data/meta/case.rb

@@ -31,6 +31,7 @@ Mutant::Meta::Example.add :case do
   RUBY
 end
 
+# rubocop:disable Metrics/BlockLength
 Mutant::Meta::Example.add :case do
   source <<-RUBY
     case condition

data/meta/class.rb

@@ -5,17 +5,8 @@ Mutant::Meta::Example.add :class do
 
   mutation 'class Foo; nil; end'
   mutation 'class Foo; self; end'
-  mutation 'module Foo; bar; end'
 end
 
 Mutant::Meta::Example.add :class do
   source 'class Foo; end'
-
-  mutation 'module Foo; end'
-end
-
-Mutant::Meta::Example.add :class do
-  source 'class Foo < Baz; end'
-
-  mutation 'module Foo; end'
 end

data/meta/def.rb

@@ -7,31 +7,6 @@ Mutant::Meta::Example.add :def do
   mutation 'def foo; super; end'
 end
 
-Mutant::Meta::Example.add :def do
-  source 'def foo(a, *b); nil; end'
-
-  mutation 'def foo(_a, *b); nil; end'
-  mutation 'def foo; nil; end'
-  mutation 'def foo(a, *b); end'
-  mutation 'def foo(a, *b); raise; end'
-  mutation 'def foo(a); nil; end'
-  mutation 'def foo(*b); nil; end'
-  mutation 'def foo(a, *b); b = []; nil; end'
-  mutation 'def foo(a, *b); super; end'
-end
-
-Mutant::Meta::Example.add :def do
-  source 'def foo(a, *); nil; end'
-
-  mutation 'def foo(_a, *); nil; end'
-  mutation 'def foo; nil; end'
-  mutation 'def foo(a, *); end'
-  mutation 'def foo(a, *); raise; end'
-  mutation 'def foo(a); nil; end'
-  mutation 'def foo(*); nil; end'
-  mutation 'def foo(a, *); super; end'
-end
-
 Mutant::Meta::Example.add :def do
   source 'def foo; foo; rescue; end'
 
@@ -132,7 +107,7 @@ Mutant::Meta::Example.add :def do
   mutation 'def foo(a, b = nil); super; end'
 end
 
-Mutant::Meta::Example.add :def do
+Mutant::Meta::Example.add :def, :arg do
   source 'def foo(_unused); end'
 
   mutation 'def foo(_unused); raise; end'