utilrb 3.1.0 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: dfc6c628c67691e4051455e910ea27774e48d1f8
-  data.tar.gz: 3985cf51ce618e65f82a503ec1d3708a76986c0d
+SHA256:
+  metadata.gz: e7c52ce8cf8f86508f209e723a1dc3db6b0f6715cf16c241a8040513d4be8075
+  data.tar.gz: e9d068b547eed7e0343ca896006546824da96ba5615d8ef90e75a0b5b4856678
 SHA512:
-  metadata.gz: 7c0826bbdc14832b30ee1f08585b04f8ae203bcaca23eebf9b2a8441e2c63599a12e8d9a774c673b01652530f0aff811162dc21840cc3aed36d5950878a70243
-  data.tar.gz: 7a2e844418cc195a2515bb2575f684ed4d264c481a2ed19713e688c7ada8802d06c85feca9b30009e1579b012f87920d444a366487dc1ccb0d0915e19636d95b
+  metadata.gz: a89739a884d6acbb494a868eb93e4b0510deda9f5ce5aae6553ca31810434ba79e5bf267ab9b242e96ac13f9f9bb25cf2e18b83b543fb8bbbbd7a693a0e98d8c
+  data.tar.gz: 8f09934f484ceadaf67c6be2a089f776f94040164e11de00890ed9075818818687f5864a2f6b6d39a1119a9acadb58f01afe2936c27348ce428743f070f27fd7

data/lib/utilrb/event_loop.rb

@@ -4,7 +4,7 @@ require 'utilrb/thread_pool'
 module Utilrb
     # Simple event loop which supports timers and defers blocking operations to
     # a thread pool those results are queued and being processed by the event
-    # loop thread at the end of each step. 
+    # loop thread at the end of each step.
     #
     # All events must be code blocks which will be executed at the end of each step.
     # There is no support for filtering or event propagations.
@@ -13,17 +13,17 @@ module Utilrb
     # can be used.
     #
     # @example Example for using the EventLoop
-    #   event_loop = EventLoop.new 
-    #   event_loop.once do 
+    #   event_loop = EventLoop.new
+    #   event_loop.once do
     #     puts "called once"
     #   end
     #
-    #   event_loop.every(1.0) do 
+    #   event_loop.every(1.0) do
     #     puts "called every second"
     #   end
     #
     #   callback = Proc.new |result|
-    #     puts result 
+    #     puts result
     #   end
     #   event_loop.defer callback do
     #     sleep 2
@@ -31,14 +31,14 @@ module Utilrb
     #   end
     #
     #   event_loop.exec
-    # 
+    #
     # @author Alexander Duda <Alexander.Duda@dfki.de>
     class EventLoop
         # Timer for the {EventLoop} which supports single shot and periodic activation
         #
         # @example
         #       loop = EventLoop.new
-        #       timer = EventLoop.every(0.1) do 
+        #       timer = EventLoop.every(0.1) do
         #                  puts 123
         #               end
         #       loop.exec
@@ -52,15 +52,15 @@ module Utilrb
             # A timer
             #
             # @param [EventLoop] event_loop the {EventLoop} the timer belongs to
-            # @param[Float] period The period of the timer in seconds.
-            # @param[Boolean] single_shot if true the timer will fire only once
-            # @param[#call] block The code block which will be executed each time the timer fires
+            # @param [Float] period The period of the timer in seconds.
+            # @param [Boolean] single_shot if true the timer will fire only once
+            # @param [#call] block The code block which will be executed each time the timer fires
             # @see EventLoop#once
             def initialize(event_loop,period=0,single_shot=false,&block)
                 @block = block
                 @event_loop = event_loop
                 @last_call = Time.now
-                @period = period
+                @period = Float(period)
                 @single_shot = single_shot
                 @stopped = true
                 @doc = Kernel.caller.find do |s|
@@ -75,7 +75,7 @@ module Utilrb
             end
 
             def stopped?
-                @stopped 
+                @stopped
             end
 
             # Returns true if the timer is currently running.
@@ -128,7 +128,7 @@ module Utilrb
                 @single_shot == true
             end
 
-            # Executes the code block tight to the timer and 
+            # Executes the code block tight to the timer and
             # saves a time stamp.
             #
             # @param [Time] time The time stamp
@@ -163,7 +163,7 @@ module Utilrb
             def ignore!
                 @ignore = true
             end
-             
+
             def ignore?
                 @ignore
             end
@@ -242,7 +242,7 @@ module Utilrb
         # queue the call if the task blocks for ever and it will never simultaneously
         # defer the call to more than one worker thread.
         #
-        # @param [Hash] options The options 
+        # @param [Hash] options The options
         # @option options [Float] :period The period
         # @option options [Boolean] :start Starts the timer right away (default = true)
         # @param [#call] work The proc which will be deferred
@@ -286,12 +286,12 @@ module Utilrb
         #               else
         #                  puts r
         #               end
-        #            end 
+        #            end
         # defer({:callback => callback}) do
         #    raise
         # end
         #
-        # @param [Hash] options The options 
+        # @param [Hash] options The options
         # @option (see ThreadPool::Task#initialize)
         # @option options [Proc] :callback The callback
         # @option options [class] :known_errors Known erros which will be rescued
@@ -344,9 +344,7 @@ module Utilrb
                     end
                 end
             end
-            @mutex.synchronize do
-                @thread_pool << task
-            end
+            add_task task
             task
         end
 
@@ -358,6 +356,7 @@ module Utilrb
         # @return [Utilrb::EventLoop::Timer,Event]
         def once(delay=nil,&block)
             raise ArgumentError "no block given" unless block
+
             if delay && delay > 0
                 timer = Timer.new(self,delay,true,&block)
                 timer.start(timer.period, false)
@@ -368,7 +367,7 @@ module Utilrb
 
         # Calls the give block in the event loop thread. If the current thread
         # is the event loop thread it will execute it right a way and returns
-        # the result of the code block call. Otherwise, it returns an handler to 
+        # the result of the code block call. Otherwise, it returns an handler to
         # the Event which was queued.
         #
         #@return [Event,Object]
@@ -387,7 +386,7 @@ module Utilrb
             !@events.empty? || !@errors.empty?
         end
 
-        # Adds a timer to the event loop which will execute 
+        # Adds a timer to the event loop which will execute
         # the given code block with the given period from the
         # event loop thread.
         #
@@ -422,7 +421,7 @@ module Utilrb
         end
 
         # Errors caught during event loop callbacks are forwarded to
-        # registered code blocks. The code blocks are called from 
+        # registered code blocks. The code blocks are called from
         # the event loop thread.
         #
         # @param @error_classes The error classes the block should be called for
@@ -442,7 +441,7 @@ module Utilrb
             raise "current thread is not the event loop thread" if !thread?
         end
 
-        # Returns true if the current thread is the 
+        # Returns true if the current thread is the
         # event loop thread.
         #
         # @return [Boolean]
@@ -487,7 +486,7 @@ module Utilrb
 
         # Cancels the given timer if it is running otherwise
         # it does nothing.
-        # 
+        #
         # @param [Timer] timer The timer
         def cancel_timer(timer)
             @mutex.synchronize do
@@ -495,12 +494,12 @@ module Utilrb
             end
         end
 
-        # Resets all timers to fire not before their hole 
+        # Resets all timers to fire not before their hole
         # period is passed counting from the given point in time.
         #
         # @param [Time] time The time
         def reset_timers(time = Time.now)
-            @mutex.synchronize do 
+            @mutex.synchronize do
                 @timers.each do |timer|
                     timer.reset time
                 end
@@ -529,10 +528,12 @@ module Utilrb
             @stop = true
         end
 
-        # Steps with the given period until the given 
+        class WaitForTimeout < RuntimeError; end
+
+        # Steps with the given period until the given
         # block returns true.
         #
-        # @param [Float] period The period 
+        # @param [Float] period The period
         # @param [Float] timeout The timeout in seconds
         # @yieldreturn [Boolean]
         def wait_for(period=0.05,timeout=nil,&block)
@@ -541,7 +542,7 @@ module Utilrb
             exec period do
                 stop if block.call
                 if timeout && timeout <= (Time.now-start).to_f
-                    raise RuntimeError,"Timeout during wait_for"
+                    raise WaitForTimeout,"timed out during wait_for"
                 end
             end
             @stop = old_stop
@@ -587,7 +588,7 @@ module Utilrb
             validate_thread
             reraise_error(@errors.shift) if !@errors.empty?
 
-            #copy all work otherwise it would not be allowed to 
+            #copy all work otherwise it would not be allowed to
             #call any event loop functions from a timer
             timers,call = @mutex.synchronize do
                                     @every_cylce_events.delete_if(&:ignore?)
@@ -620,7 +621,7 @@ module Utilrb
             end
             handle_errors{call.call} if call
             reraise_error(@errors.shift) if !@errors.empty?
-            
+
             #allow thread pool to take over
             Thread.pass
         end
@@ -655,7 +656,9 @@ module Utilrb
         #
         # @param [ThreadPool::Task] task The task.
         def add_task(task)
-            thread_pool << task
+            @mutex.synchronize do
+                @thread_pool << task
+            end
         end
 
         # Clears all timers, events and errors
@@ -670,29 +673,28 @@ module Utilrb
             end
         end
 
-        # Clears all errors which occurred during the last step and are not marked as known 
+        # Clears all errors which occurred during the last step and are not marked as known
         # If the errors were not cleared they are re raised the next time step is called.
         def clear_errors
             @errors.clear
         end
 
-        def handle_error(error,save = true)
+        def handle_error(error, save = true)
+            @errors << error if save
+
             call do
-                on_error = @mutex.synchronize do
-                    @on_error.find_all{|key,e| error.is_a? key}.map(&:last).flatten
-                end
+                on_error = @on_error.find_all{|key,e| error.is_a? key}.map(&:last).flatten
                 on_error.each do |handler|
                     handler.call error
                 end
-                @errors << error if save == true
             end
         end
 
     private
         # Calls the given block and rescues all errors which can be handled
-        # by the added error handler. If an error cannot be handled it is 
+        # by the added error handler. If an error cannot be handled it is
         # stored and re raised after all events and timers are processed. If
-        # more than one error occurred which cannot be handled they are stored 
+        # more than one error occurred which cannot be handled they are stored
         # until the next step is called and re raised until all errors are processed.
         #
         # @info This method must be called from the event loop thread, otherwise
@@ -741,7 +743,7 @@ module Utilrb
             # accessor.method(*args) but called from a thread pool.  Thereby the code
             # block is used as callback called from the main thread after the
             # call returned. If an error occurred it will be:
-            #  * given to the callback as second argument 
+            #  * given to the callback as second argument
             #  * forwarded to the error handlers of the event loop
             #  * raised at the beginning of the next step if not marked as known error
             #
@@ -759,17 +761,17 @@ module Utilrb
             #    end
             #
             #    ali do |result,exception|
-            #       if exception 
+            #       if exception
             #           :ignore_error
             #       else
             #          puts result
             #       end
             #    end
             #
-            # If the callback accepts only one argument 
+            # If the callback accepts only one argument
             # the callback will not be called in an event of an error but
             # the error will still be forwarded to the error handlers.
-            #    
+            #
             # If the result shall be filtered before returned a filter method can
             # be specified which is called from the event loop thread just before
             # the result is returned.
@@ -816,7 +818,7 @@ module Utilrb
             # @param [Symbol] method The method called on the designated object.
             # @param [Hash] options The options
             # @option options [Symbol] :alias The alias of the method
-            # @option options [Symbol] :sync_key The sync key 
+            # @option options [Symbol] :sync_key The sync key
             # @option options [Symbol] :filter The filter method
             # @option options [Symbol] :on_error Method which is called if an error occured
             # @option options [class] :known_errors Known errors which will be rescued but still be forwarded.
@@ -845,12 +847,12 @@ module Utilrb
 
                 def options(options = Hash.new,&block)
                     @stack << @stack.last.merge(options)
-                        block.call
+                    block.call
                     @stack.pop
                 end
 
                 def thread_safe(&block)
-                    options :sync_key => nil do 
+                    options :sync_key => nil do
                         block.call
                     end
                 end
@@ -949,7 +951,7 @@ module Utilrb
                     end
                 end
 
-                # Defines multiple method as delegator instance methods 
+                # Defines multiple method as delegator instance methods
                 # @see #def_event_loop_delegator
                 def self.def_event_loop_delegators(klass,accessor,event_loop, *methods)
                     methods.flatten!

data/lib/utilrb/exception/full_message.rb

@@ -1,5 +1,6 @@
 require 'utilrb/kernel/options'
 
+unless Exception.method_defined?(:full_message)
 class Exception
     # Returns the full exception message, with backtrace, like the one we get from
     # the Ruby interpreter when the program is aborted (well, almost like that)
@@ -53,4 +54,4 @@ class Exception
 	msg
     end
 end
-
+end

data/lib/utilrb/hash/slice.rb

@@ -1,6 +1,3 @@
-class Hash
-    def slice(*keys)
-	keys.inject({}) { |h, k| h[k] = self[k] if has_key?(k); h }
-    end
-end
+STDERR.puts "[DEPRECATED] utilrb/hash/slice is deprecated, use backports' backports/2.5.0/hash/slice instead or the built-in method in Ruby >= 2.5"
+require 'backports/2.5.0/hash/slice'
 

data/lib/utilrb/kernel/options.rb

@@ -1,5 +1,4 @@
 require 'utilrb/hash/to_sym_keys'
-require 'utilrb/hash/slice'
 module Kernel
     def filter_options_handle_single_entry(known_options, options, key)
         key = key.to_sym
@@ -60,11 +59,11 @@ module Kernel
     end
 
     # Validates an option hash, with default value support. See #filter_options
-    # 
-    # In the first form, +option_hash+ should contain keys which are also 
+    #
+    # In the first form, +option_hash+ should contain keys which are also
     # in known_hash. The non-nil values of +known_hash+ are used as default
     # values. In the second form, +known_array+ is an array of option
-    # keys. +option_hash+ keys shall be in +known_array+. +nil+ is treated 
+    # keys. +option_hash+ keys shall be in +known_array+. +nil+ is treated
     # as an empty option hash, all keys are converted into symbols.
     #
     def validate_options(options, *known_options)

data/lib/utilrb/logger/hierarchy.rb

@@ -1,5 +1,4 @@
 require 'facets/module/spacename'
-require 'facets/kernel/constant'
 require 'utilrb/object/attribute'
 require 'utilrb/logger/forward'
 require 'weakref'
@@ -28,6 +27,16 @@ class Logger
             log_children << WeakRef.new(child)
         end
 
+        def deregister_log_child(child)
+            log_children.delete_if do |ref|
+                begin
+                    ref.__getobj__ == child
+                rescue WeakRef::RefError
+                    true
+                end
+            end
+        end
+
         def each_log_child
             return enum_for(__method__) if !block_given?
 
@@ -41,36 +50,47 @@ class Logger
             end
         end
 
+        # @api private
+        #
+        # Resets the default logger of this context's children
+        #
+        # This is called whenever the context children is reset, since the
+        # cached default logger is now invalid
+        def reset_children_default_logger
+            children = log_children
+            @log_children = Array.new
+            children.each do |ref|
+                begin
+                    ref.__getobj__.reset_default_logger
+                rescue WeakRef::RefError
+                end
+            end
+        end
+
         # Allows to change the logger object at this level of the hierarchy
         #
         # This is usually not used directly: a new logger can be created with
         # Hierarchy#make_own_logger and removed with Hierarchy#reset_own_logger
         def logger=(new_logger)
             @logger = new_logger
-            each_log_child do |child|
-                child.reset_default_logger
-            end
+            reset_children_default_logger
         end
 
         # Removes a logger defined at this level of the module hierarchy. The
         # logging methods will now access the parent's module logger.
         def reset_own_logger
-            @logger = nil
-            each_log_child do |child|
-                child.reset_default_logger
-            end
+            self.logger = nil
         end
 
         def reset_default_logger
             @__utilrb_hierarchy__default_logger = nil
-            each_log_child do |child|
-                child.reset_default_logger
-            end
+            @parent_module.deregister_log_child(self) if @parent_module
+            reset_children_default_logger
         end
 
         def logger
             if defined?(@logger) && @logger
-                return @logger 
+                return @logger
             elsif defined?(@__utilrb_hierarchy__default_logger) && @__utilrb_hierarchy__default_logger
                 return @__utilrb_hierarchy__default_logger
             end
@@ -84,7 +104,7 @@ class Logger
     # attribute.
     #
     # This module is usually used in conjunction with the Logger::Root method:
-    # 
+    #
     #   module First
     #     extend Logger.Root("First", :INFO)
     #
@@ -120,7 +140,7 @@ class Logger
         def self.extended(obj) # :nodoc:
             obj.logger # initialize the default logger. Also does some checking
             if obj.kind_of?(Module) && !obj.spacename.empty?
-                parent_module = constant(obj.spacename)
+                parent_module = const_get(obj.spacename)
                 if (parent_module.singleton_class.ancestors.include?(::Logger::Forward))
                     obj.send(:extend, ::Logger::Forward)
                 end
@@ -141,7 +161,7 @@ class Logger
                         if m.name && !m.spacename.empty?
                             parent_module =
                                 begin
-                                    constant(m.spacename)
+                                    const_get(m.spacename)
                                 rescue NameError
                                 end
                             if parent_module.respond_to?(:logger)
@@ -164,6 +184,7 @@ class Logger
                         raise NoParentLogger, "cannot find a logger for #{self}"
                     end
                     if parent_module.respond_to? :register_log_child
+                        @parent_module = parent_module
                         parent_module.register_log_child(self)
                     end
                     parent_module.logger
@@ -173,5 +194,3 @@ class Logger
         end
     end
 end
-
-

data/lib/utilrb/module/dsl_attribute.rb

@@ -1,10 +1,13 @@
-class Module
+# frozen_string_literal: true
+
+class Module # rubocop:disable Style/Documentation
     # call-seq:
     #   dsl_attribute(name)
     #   dsl_attribute(name,name2,name3)
     #   dsl_attribute(name) { |value| ... }
     #
-    # This defines a +name+ instance method on the given class which accepts zero or one argument
+    # This defines a +name+ instance method on the given class which accepts
+    # zero or one argument
     #
     # Without any argument, it acts as a getter for the +@name+ attribute. With
     # one argument, it acts instead as a setter for the same attribute and
@@ -13,8 +16,8 @@ class Module
     # instance variable.  This block can therefore both filter the value
     # (convert it to a desired form) and validate it.
     #
-    # The goal of this method is to have a nicer way to handle attribute in DSLs: instead
-    # of 
+    # The goal of this method is to have a nicer way to handle attribute in
+    # DSLs: instead of
     #
     #    model = create_model do
     #	    self.my_model_attribute = 'bla'
@@ -35,37 +38,46 @@ class Module
     #	 end
     #
     def dsl_attribute(*names, &filter_block)
-        if names.size > 1 && filter_block
-            raise ArgumentError, "multiple names as argument are only supported if no block is given"
+        if names.size > 1
+            if filter_block
+                raise ArgumentError,
+                      "multiple names as argument are only supported if no block is given"
+            end
+
+            names.each { |name| dsl_attribute(name) }
+            return
         end
-        names.each do |name|
-	class_eval do
+
+        name = names.first
+
+        class_eval do
             if filter_block
                 define_method("__dsl_attribute__#{name}__filter__", &filter_block)
             end
 
-	    define_method(name) do |*value|
-		if value.empty?
-		    instance_variable_get("@#{name}")
-		elsif filter_block
-                    if filter_block.arity >= 0 && value.size != filter_block.arity
-                        raise ArgumentError, "too many arguments. Got #{value.size}, expected #{filter_block.arity}"
-                    end
-
-		    filtered_value = send("__dsl_attribute__#{name}__filter__", *value)
-		    instance_variable_set("@#{name}", filtered_value)
-		    self
-		else
+            define_method(name) do |*value, **kw|
+                if value.empty? && kw.empty?
+                    instance_variable_get("@#{name}")
+                elsif filter_block
+                    # Ruby 2.7 madness. The second version would pass {} as
+                    # second argument
+                    filtered_value =
+                        if kw.empty?
+                            send("__dsl_attribute__#{name}__filter__", *value)
+                        else
+                            send("__dsl_attribute__#{name}__filter__", *value, **kw)
+                        end
+                    instance_variable_set("@#{name}", filtered_value)
+                    self
+                else
                     if value.size == 1
                         instance_variable_set("@#{name}", value.first)
                     else
                         instance_variable_set("@#{name}", value)
                     end
-		    self
-		end
-	    end
-	end
+                    self
+                end
+            end
         end
     end
 end
-

data/lib/utilrb/object/address.rb

@@ -1,8 +1,20 @@
 
 class Object
-    # Return the object address (for non immediate
-    # objects). 
-    def address; Object.address_from_id(object_id) end
+    if RUBY_VERSION < "2.7.0"
+        # Return the object address (for non immediate
+        # objects).
+        def address
+            Object.address_from_id(object_id)
+        end
+    else
+        BUILTIN_OBJECT_TO_S = Object.instance_method(:to_s)
+        def address
+            to_s = BUILTIN_OBJECT_TO_S.bind(self).call
+            if (m = /:(0x[0-9a-f]+)/.match(to_s))
+                Integer(m[1])
+            end
+        end
+    end
 
     # Converts the object_id of a non-immediate object
     # to its memory address

data/lib/utilrb/object/attribute.rb

@@ -27,6 +27,8 @@ class Object
         class_eval <<-EOD, __FILE__, __LINE__+1
         def #{name}
             if instance_variable_defined?(:@#{name}) then @#{name}
+            elsif frozen?
+                #{name}_defval
             else @#{name} = #{name}_defval
             end
         end
@@ -40,4 +42,3 @@ class Object
 	singleton_class.class_eval { attribute(attr_def, &init) }
     end
 end
-