utilrb 3.0.1 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 30f3b27613076cc9f327bccee358f2bc55bcd826
-  data.tar.gz: ef980585fef480c37de10056afec1bd714df4683
+SHA256:
+  metadata.gz: e7c52ce8cf8f86508f209e723a1dc3db6b0f6715cf16c241a8040513d4be8075
+  data.tar.gz: e9d068b547eed7e0343ca896006546824da96ba5615d8ef90e75a0b5b4856678
 SHA512:
-  metadata.gz: df1fab4bfabbe73e7d657a7564022042d3f16c84293474ed441c1c9b1452481c2393aa76d38b820a398731fc605aa5d0a8ea6e30c089b7ef3b2ca2279145bbd2
-  data.tar.gz: 1efd86909aff5ea2802c1ff9a04db0e5eb052cbed3412858d1d051245b47baf82d329a200102318e8067396f1175f319247062942bd4bab4d22a72818ac06408
+  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/arity.rb

@@ -1,15 +1,20 @@
 module Kernel
     # Raises if +object+ can accept calls with exactly +arity+ arguments. 
     # object should respond to #arity
-    def check_arity(object, arity)
-        if object.respond_to?(:lambda?) # For ruby 1.9 compatibility on blocks without arguments
-            if !object.lambda? && object.arity == 0
-                return
+    def check_arity(object, arity, strict: nil)
+        if strict.nil?
+            if object.respond_to?(:lambda?)
+                strict = object.lambda?
+            else strict = true
             end
         end
 
-        unless object.arity == arity || (object.arity < 0 && object.arity > - arity - 2)
-            raise ArgumentError, "#{object} does not accept to be called with #{arity} argument(s)", caller(2)
+        if strict
+            if object.arity >= 0 && object.arity != arity
+                raise ArgumentError, "#{object} requests #{object.arity} arguments, but #{arity} was requested"
+            elsif -object.arity-1 > arity
+                raise ArgumentError, "#{object} requests at least #{object.arity} arguments, but #{arity} was requested"
+            end
         end
     end
 end

data/lib/utilrb/kernel/load_dsl_file.rb

@@ -116,13 +116,13 @@ module Kernel
     # The caller of this method should call it at the end of its definition
     # file, or the translation method may not be robust at all
     def eval_dsl_file(file, proxied_object, context, full_backtrace, *exceptions, &block)
+        file = File.expand_path(file)
         if !File.readable?(file)
             raise ArgumentError, "#{file} does not exist"
         end
 
-        loaded_file = file.gsub(/^#{Regexp.quote(Dir.pwd)}\//, '')
         file_content = File.read(file)
-        eval_dsl_file_content(loaded_file, file_content, proxied_object, context, full_backtrace, *exceptions, &block)
+        eval_dsl_file_content(file, file_content, proxied_object, context, full_backtrace, *exceptions, &block)
     end
 
     # Same than eval_dsl_file, but will not load the same file twice

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/forward.rb

@@ -15,6 +15,16 @@ class Logger
             EOF
         end
 
+        # The logger level
+        def log_level
+            logger.level
+        end
+
+        # Sets the logger's level
+        def log_level=(level)
+            logger.level = level
+        end
+
         # Forwarded to {Logger#silent}
         def log_silent(&block)
             logger.silent(&block)

data/lib/utilrb/logger/hierarchy.rb

@@ -1,7 +1,7 @@
 require 'facets/module/spacename'
-require 'facets/kernel/constant'
 require 'utilrb/object/attribute'
 require 'utilrb/logger/forward'
+require 'weakref'
 
 class Logger
     module HierarchyElement
@@ -23,36 +23,74 @@ class Logger
             self.logger = new_logger
         end
 
+        def register_log_child(child)
+            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?
+
+            log_children.delete_if do |ref|
+                begin
+                    yield(ref.__getobj__)
+                    false
+                rescue WeakRef::RefError
+                    true
+                end
+            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
-            log_children.each 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
-            log_children.each do |child|
-                child.reset_default_logger
-            end
+            self.logger = nil
         end
 
         def reset_default_logger
             @__utilrb_hierarchy__default_logger = nil
-            log_children.each 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
@@ -66,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)
     #
@@ -102,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
@@ -123,15 +161,20 @@ 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)
                                 break
                             end
                         end
+
                         if m.respond_to?(:superclass)
                             m = m.superclass
+                            if m.respond_to?(:logger)
+                                parent_module = m
+                                break
+                            end
                         else
                             m = nil; break
                         end
@@ -140,8 +183,9 @@ class Logger
                     if !m
                         raise NoParentLogger, "cannot find a logger for #{self}"
                     end
-                    if parent_module.respond_to? :log_children
-                        parent_module.log_children << self
+                    if parent_module.respond_to? :register_log_child
+                        @parent_module = parent_module
+                        parent_module.register_log_child(self)
                     end
                     parent_module.logger
                 else
@@ -150,5 +194,3 @@ class Logger
         end
     end
 end
-
-

data/lib/utilrb/logger/root.rb

@@ -1,19 +1,19 @@
 require 'utilrb/logger/hierarchy'
+
 class Logger
-    HAS_COLOR =
+    LEVEL_TO_COLOR =
         begin
-            require 'highline'
-            @console = HighLine.new
+            require 'pastel'
+            colorizer = Pastel.new
+            { 'DEBUG' => ->(t) { t },
+              'INFO' =>  ->(t) { t },
+              'WARN' =>  colorizer.magenta.detach,
+              'ERROR' => colorizer.red.detach,
+              'FATAL' => colorizer.red.bold.detach }
         rescue LoadError
+            Hash.new
         end
 
-    LEVEL_TO_COLOR =
-        { 'DEBUG' => [],
-          'INFO' => [],
-          'WARN' => [:magenta],
-          'ERROR' => [:red],
-          'FATAL' => [:red, :bold] }
-
     # Defines a logger on a module, allowing to use that module as a root in a
     # hierarchy (i.e. having submodules use the Logger::Hierarchy support)
     #
@@ -56,9 +56,9 @@ class Logger
         console = @console
         formatter =
             if block then lambda(&block)
-            elsif HAS_COLOR
+            elsif !LEVEL_TO_COLOR.empty?
                 lambda do |severity, time, name, msg|
-                    console.color("#{name}[#{severity}]: #{msg}\n", *LEVEL_TO_COLOR[severity])
+                    LEVEL_TO_COLOR[severity].call("#{name}[#{severity}]: #{msg}\n")
                 end
             else lambda { |severity, time, name, msg| "#{name}[#{severity}]: #{msg}\n" }
             end