pantheios-ruby 0.22.2 → 0.22.3

data/lib/pantheios/util/reflection_util.rb

@@ -6,27 +6,27 @@ module Util
 # reflection utilities
 module ReflectionUtil
 
-	module ReflectionUtil_Constants
+  module ReflectionUtil_Constants
 
-		ROOT_CLASSES = [ ::Object, ::BasicObject ]
-	end
+    ROOT_CLASSES = [ ::Object, ::BasicObject ]
+  end
 
-	# Obtains a list of all classes pertaining to +o+, excepting root
-	# objects (+::Object+ and +::BaseObject+).
-	def self.non_root_classes o
+  # Obtains a list of all classes pertaining to +o+, excepting root
+  # objects (+::Object+ and +::BaseObject+).
+  def self.non_root_classes o
 
-		return [] if o.nil?
+    return [] if o.nil?
 
-		return self.non_root_classes o.class unless ::Class === o
+    return self.non_root_classes o.class unless ::Class === o
 
-		return [] if ReflectionUtil_Constants::ROOT_CLASSES.any? { |c| c == o }
+    return [] if ReflectionUtil_Constants::ROOT_CLASSES.any? { |c| c == o }
 
-		s = o.superclass
+    s = o.superclass
 
-		return [ o ] if ::Object == s
+    return [ o ] if ::Object == s
 
-		[ o ] + self.non_root_classes(s)
-	end
+    [ o ] + self.non_root_classes(s)
+  end
 
 end # module ProcessUtil
 

data/lib/pantheios/util/thread_util.rb

@@ -6,77 +6,77 @@ module Util
 # threading utilities
 module ThreadUtil
 
-	# Creates (if necessary) and sets the given thread's +thread_name+
-	# attribute to the given name
-	#
-	# === Signature
-	#
-	# * *Parameters:*
-	#  - +t+ [Thread, nil] The thread to be named, or +nil+ if it should
-	#    operate on the current (invoking) thread
-	#  - +name+ [String] The thread's name
-	def self.set_thread_name t, name
+  # Creates (if necessary) and sets the given thread's +thread_name+
+  # attribute to the given name
+  #
+  # === Signature
+  #
+  # * *Parameters:*
+  #  - +t+ [Thread, nil] The thread to be named, or +nil+ if it should
+  #    operate on the current (invoking) thread
+  #  - +name+ [String] The thread's name
+  def self.set_thread_name t, name
 
-		t ||= Thread.current
+    t ||= Thread.current
 
-		class << t; attr_accessor :thread_name; end unless t.respond_to? :thread_name
+    class << t; attr_accessor :thread_name; end unless t.respond_to? :thread_name
 
-		t.thread_name = name
-	end
+    t.thread_name = name
+  end
 
-	# Obtains the name of the calling thread
-	def self.get_thread_name t
+  # Obtains the name of the calling thread
+  def self.get_thread_name t
 
-		t ||= Thread.current
+    t ||= Thread.current
 
-		return t.thread_name if t.respond_to? :thread_name
+    return t.thread_name if t.respond_to? :thread_name
 
-		t.to_s
-	end
+    t.to_s
+  end
 
-	# Inclusion module for giving the included type the +thread_name+
-	# attribute
-	#
-	# If included into a thread type, or a thread instance, then
-	module ThreadName
+  # Inclusion module for giving the included type the +thread_name+
+  # attribute
+  #
+  # If included into a thread type, or a thread instance, then
+  module ThreadName
 
-		def self.included receiver
+    def self.included receiver
 
-			if receiver < ::Thread
+      if receiver < ::Thread
 
-				receiver.instance_eval do
+        receiver.instance_eval do
 
-					define_method(:thread_name) { @thread_name || self.to_s }
-					define_method(:thread_name=) { |name| @thread_name = name }
-				end
-			else
+          define_method(:thread_name) { defined?(@thread_name) && @thread_name || self.to_s }
+          define_method(:thread_name=) { |name| @thread_name = name }
+        end
+      else
 
-				receiver.instance_eval do
+        receiver.instance_eval do
 
-					define_method :thread_name do |name = (name_not_given_ = true)|
+          define_method :thread_name do |name = (name_not_given_ = true)|
 
-						t = Thread.current
+            t = Thread.current
 
-						has_tn = t.respond_to? :thread_name
+            has_tn = t.respond_to? :thread_name
 
-						if name_not_given_
+            if name_not_given_
 
-							return t.thread_name if has_tn
+              return t.thread_name if has_tn
 
-							t.to_s
-						else
+              t.to_s
+            else
 
-							class << t; attr_accessor :thread_name; end unless has_tn
+              class << t; attr_accessor :thread_name; end unless has_tn
 
-							t.thread_name = name
-						end
-					end
+              t.thread_name = name
+            end
+          end
 
-					define_method(:thread_name=) { |name| thread_name name }
-				end
-			end
-		end
-	end
+          define_method(:thread_name=) { |name| thread_name name }
+        end
+      end
+    end
+  end
 
 end # module ThreadUtil
 

data/lib/pantheios/util/version_util.rb

@@ -6,39 +6,39 @@ module Util
 # version utilities
 module VersionUtil
 
-	# Compares two version designators and returns a spaceship comparison
-	# result
-	#
-	# === Signature
-	#
-	# * *Parameters:*
-	#  - +lhs+ [String, Array[Integer|String]] The left-hand comparand
-	#  - +rhs+ [String, Array[Integer|String]] The right-hand comparand
-	#
-	# * *Returns:*
-	#  - 0 if the two version designators represent exactly the same version
-	#  - <0 if the +lhs+ version designator represents an earlier version
-	#    than the +rhs+ version designator
-	#  - >0 if the +lhs+ version designator represents a later version
-	#    than the +rhs+ version designator
-	def self.version_compare lhs, rhs
-
-		lhs	=	lhs.split('.') if String === lhs
-		rhs	=	rhs.split('.') if String === rhs
-
-		lhs	=	lhs.map { |n| n.to_i }
-		rhs	=	rhs.map { |n| n.to_i }
-
-		if lhs.size < rhs.size
-
-			lhs += [ 0 ] * (rhs.size - lhs.size)
-		else
-
-			rhs += [ 0 ] * (lhs.size - rhs.size)
-		end
-
-		lhs <=> rhs
-	end
+  # Compares two version designators and returns a spaceship comparison
+  # result
+  #
+  # === Signature
+  #
+  # * *Parameters:*
+  #  - +lhs+ [String, Array[Integer|String]] The left-hand comparand
+  #  - +rhs+ [String, Array[Integer|String]] The right-hand comparand
+  #
+  # * *Returns:*
+  #  - 0 if the two version designators represent exactly the same version
+  #  - <0 if the +lhs+ version designator represents an earlier version
+  #    than the +rhs+ version designator
+  #  - >0 if the +lhs+ version designator represents a later version
+  #    than the +rhs+ version designator
+  def self.version_compare lhs, rhs
+
+    lhs  =  lhs.split('.') if String === lhs
+    rhs  =  rhs.split('.') if String === rhs
+
+    lhs  =  lhs.map { |n| n.to_i }
+    rhs  =  rhs.map { |n| n.to_i }
+
+    if lhs.size < rhs.size
+
+      lhs += [ 0 ] * (rhs.size - lhs.size)
+    else
+
+      rhs += [ 0 ] * (lhs.size - rhs.size)
+    end
+
+    lhs <=> rhs
+  end
 end # module VersionUtil
 
 end # module Util

data/lib/pantheios/version.rb

@@ -5,7 +5,7 @@
 # Purpose:  Version for Pantheios.Ruby library
 #
 # Created:  2nd April 2011
-# Updated:  27th August 2026
+# Updated:  30th August 2026
 #
 # Home:     https://github.com/synesissoftware/Pantheios.Ruby
 #
@@ -50,18 +50,18 @@
 
 module Pantheios
 
-	# Current version of the Pantheios.Ruby library
-	VERSION				=	'0.22.2'
+  # Current version of the Pantheios.Ruby library
+  VERSION           = '0.22.3'
 
-	private
-	VERSION_PARTS_		=	VERSION.split(/[.]/).collect { |n| n.to_i } # :nodoc:
-	public
-	# Major version of the Pantheios.Ruby library
-	VERSION_MAJOR		=	VERSION_PARTS_[0] # :nodoc:
-	# Minor version of the Pantheios.Ruby library
-	VERSION_MINOR		=	VERSION_PARTS_[1] # :nodoc:
-	# Revision version of the Pantheios.Ruby library
-	VERSION_REVISION	=	VERSION_PARTS_[2] # :nodoc:
+  private
+  VERSION_PARTS_    = VERSION.split(/[.]/).collect { |n| n.to_i } # :nodoc:
+  public
+  # Major version of the Pantheios.Ruby library
+  VERSION_MAJOR     = VERSION_PARTS_[0] # :nodoc:
+  # Minor version of the Pantheios.Ruby library
+  VERSION_MINOR     = VERSION_PARTS_[1] # :nodoc:
+  # Revision version of the Pantheios.Ruby library
+  VERSION_REVISION  = VERSION_PARTS_[2] # :nodoc:
 
 end # module Pantheios
 

data/lib/pantheios.rb

@@ -19,21 +19,21 @@ require 'pantheios/version'
 
 module Pantheios
 
-	# @!visibility private
-	def self.included receiver # :nodoc:
+  # @!visibility private
+  def self.included receiver # :nodoc:
 
-		if ::Pantheios::Globals.HAS_CASCADED_INCLUDES
+    if ::Pantheios::Globals.HAS_CASCADED_INCLUDES
 
-			receiver.class_eval do
+      receiver.class_eval do
 
-				include ::Pantheios::API
-				include ::Pantheios::ApplicationLayer
-				include ::Pantheios::Util
-			end
-		end
+        include ::Pantheios::API
+        include ::Pantheios::ApplicationLayer
+        include ::Pantheios::Util
+      end
+    end
 
-		::Pantheios::Core.register_include self, receiver
-	end
+    ::Pantheios::Core.register_include self, receiver
+  end
 
 end # module Pantheios
 

data/test/performance/test_perf_simple_statements.rb

@@ -6,7 +6,7 @@
 # Purpose:      COMPLETE_ME
 #
 # Created:      22nd January 2018
-# Updated:      22nd January 2018
+# Updated:      28th August 2026
 #
 # Author:       Matthew Wilson
 #
@@ -31,102 +31,102 @@ N = 5000000
 
 def severity_logged? severity
 
-	return false
+  return false
 end
 
 
 Benchmark.benchmark(Benchmark::CAPTION, 24, Benchmark::FORMAT, 'total:', 'avg:') do |r|
 
-	totals	=	[]
+  totals  =  []
 
-	totals << r.report("arguments (1-arg)") do
+  totals << r.report("arguments (1-arg)") do
 
-		for i in (0...N) do
+    N.times do
 
-			log :notice, 'the cat in the hat.'
-		end
-	end
+      log :notice, 'the cat in the hat.'
+    end
+  end
 
-	totals << r.report("blocks (1-arg)") do
+  totals << r.report("blocks (1-arg)") do
 
-		for i in (0...N) do
+    N.times do
 
-			log(:notice) { 'the cat in the hat!' }
-		end
-	end
+      log(:notice) { 'the cat in the hat!' }
+    end
+  end
 
-	totals << r.report("args-if (1-arg)") do
+  totals << r.report("args-if (1-arg)") do
 
-		for i in (0...N) do
+    N.times do
 
-			log :notice, 'the cat in the hat.' if severity_logged? :notice
-		end
-	end
+      log :notice, 'the cat in the hat.' if severity_logged? :notice
+    end
+  end
 
 
-	totals << r.report("arguments (simple)") do
+  totals << r.report("arguments (simple)") do
 
-		for i in (0...N) do
+    N.times do
 
-			log :notice, 'the ', 'cat ', 'in ', 'the ', 'hat.'
-		end
-	end
+      log :notice, 'the ', 'cat ', 'in ', 'the ', 'hat.'
+    end
+  end
 
-	totals << r.report("blocks (simple)") do
+  totals << r.report("blocks (simple)") do
 
-		for i in (0...N) do
+    N.times do
 
-			log(:notice) { 'the ' + 'cat ' + 'in ' + 'the ' + 'hat!' }
-		end
-	end
+      log(:notice) { 'the ' + 'cat ' + 'in ' + 'the ' + 'hat!' }
+    end
+  end
 
-	totals << r.report("args-if (simple)") do
+  totals << r.report("args-if (simple)") do
 
-		for i in (0...N) do
+    N.times do
 
-			log :notice, 'the ', 'cat ', 'in ', 'the ', 'hat.' if severity_logged? :notice
-		end
-	end
+      log :notice, 'the ', 'cat ', 'in ', 'the ', 'hat.' if severity_logged? :notice
+    end
+  end
 
 
-	totals << r.report("arguments (complex)") do
+  totals << r.report("arguments (complex)") do
 
-		cat	=	'cat'
-		hat	=	:hat
-		t	=	Time.now
+    cat  =  'cat'
+    hat  =  :hat
+    t  =  Time.now
 
-		for i in (0...N) do
+    N.times do
 
-			log :notice, "the #{cat} in the #{hat} (#{t})"
-		end
-	end
+      log :notice, "the #{cat} in the #{hat} (#{t})"
+    end
+  end
 
-	totals << r.report("blocks (complex)") do
+  totals << r.report("blocks (complex)") do
 
-		cat	=	'cat'
-		hat	=	:hat
-		t	=	Time.now
+    cat  =  'cat'
+    hat  =  :hat
+    t  =  Time.now
 
-		for i in (0...N) do
+    N.times do
 
-			log(:notice) { "the #{cat} in the #{hat} (#{t})" }
-		end
-	end
+      log(:notice) { "the #{cat} in the #{hat} (#{t})" }
+    end
+  end
 
-	totals << r.report("args-if (complex)") do
+  totals << r.report("args-if (complex)") do
 
-		cat	=	'cat'
-		hat	=	:hat
-		t	=	Time.now
+    cat  =  'cat'
+    hat  =  :hat
+    t  =  Time.now
 
-		for i in (0...N) do
+    N.times do
 
-			log :notice, "the #{cat} in the #{hat} (#{t})" if severity_logged? :notice
-		end
-	end
+      log :notice, "the #{cat} in the #{hat} (#{t})" if severity_logged? :notice
+    end
+  end
 
 
-	[ totals.inject(:+), totals.inject(:+) / totals.size ]
+  [ totals.inject(:+), totals.inject(:+) / totals.size ]
 end
 
 

data/test/performance/test_perf_trace_variants.rb

@@ -1,19 +1,5 @@
 #!/usr/bin/env ruby
 
-#############################################################################
-# File:         test/performance/test_perf_trace_variants.rb
-#
-# Purpose:      COMPLETE_ME
-#
-# Created:      22nd January 2018
-# Updated:      22nd January 2018
-#
-# Author:       Matthew Wilson
-#
-# Copyright:    <<TBD>>
-#
-#############################################################################
-
 $:.unshift File.join(File.dirname(__FILE__), *(['..'] * 2), 'lib')
 
 require 'pantheios/globals'
@@ -32,100 +18,100 @@ T = Time.now
 
 def severity_logged? severity
 
-	return ::Pantheios::Core.severity_logged? severity
+  return ::Pantheios::Core.severity_logged? severity
 end
 
 
 def blank_trace p0, p1, p2, p3, t
 
-	trace
+  trace
 end
 
 def anonymous_trace p0, p1, p2, p3, t
 
-	trace p0, p1, p2, p3, t
+  trace p0, p1, p2, p3, t
 end
 
 def parameter_trace p0, p1, p2, p3, t
 
-	trace ParamNames[ :p0, :p1, :p2, :p3, :t ], p0, p1, p2, p3, t
+  trace ParamNames[ :p0, :p1, :p2, :p3, :t ], p0, p1, p2, p3, t
 end
 
 def parameter_cond p0, p1, p2, p3, t
 
-	trace ParamNames[ :p0, :p1, :p2, :p3, :t ], p0, p1, p2, p3, t if severity_logged? :trace
+  trace ParamNames[ :p0, :p1, :p2, :p3, :t ], p0, p1, p2, p3, t if severity_logged? :trace
 end
 
 def names_in_block p0, p1, p2, p3, t
 
-	trace(p0, p1, p2, p3, t) { ParamNames[ :p0, :p1, :p2, :p3, :t ] }
+  trace(p0, p1, p2, p3, t) { ParamNames[ :p0, :p1, :p2, :p3, :t ] }
 end
 
 def all_in_block p0, p1, p2, p3, t
 
-	trace { [ ParamNames[ :p0, :p1, :p2, :p3, :t ], p0, p1, p2, p3, t ] }
+  trace { [ ParamNames[ :p0, :p1, :p2, :p3, :t ], p0, p1, p2, p3, t ] }
 end
 
 
 Benchmark.benchmark(Benchmark::CAPTION, 24, Benchmark::FORMAT, 'total:', 'avg:') do |r|
 
-	t_log = r.report('plain log') do
+  r.report('plain log') do
 
-		for i in (0...N) do
+    N.times do
 
-			log :abc, 'd', 'ef', 't=', T
-		end
-	end
+      log :abc, 'd', 'ef', 't=', T
+    end
+  end
 
-	t_blank_trace = r.report('blank_trace') do
+  r.report('blank_trace') do
 
-		for i in (0...N) do
+    N.times do
 
-			blank_trace :abc, 'd', 'ef', 't=', T
-		end
-	end
+      blank_trace :abc, 'd', 'ef', 't=', T
+    end
+  end
 
-	t_anonymous_trace = r.report('anonymous_trace') do
+  r.report('anonymous_trace') do
 
-		for i in (0...N) do
+    N.times do
 
-			anonymous_trace :abc, 'd', 'ef', 't=', T
-		end
-	end
+      anonymous_trace :abc, 'd', 'ef', 't=', T
+    end
+  end
 
-	t_parameter_trace = r.report('parameter_trace') do
+  r.report('parameter_trace') do
 
-		for i in (0...N) do
+    N.times do
 
-			parameter_trace :abc, 'd', 'ef', 't=', T
-		end
-	end
+      parameter_trace :abc, 'd', 'ef', 't=', T
+    end
+  end
 
-	t_parameter_cond = r.report('parameter_cond') do
+  r.report('parameter_cond') do
 
-		for i in (0...N) do
+    N.times do
 
-			parameter_cond :abc, 'd', 'ef', 't=', T
-		end
-	end
+      parameter_cond :abc, 'd', 'ef', 't=', T
+    end
+  end
 
-	t_names_in_block = r.report('names_in_block') do
+  r.report('names_in_block') do
 
-		for i in (0...N) do
+    N.times do
 
-			names_in_block :abc, 'd', 'ef', 't=', T
-		end
-	end
+      names_in_block :abc, 'd', 'ef', 't=', T
+    end
+  end
 
-	t_all_in_block = r.report('all_in_block') do
+  r.report('all_in_block') do
 
-		for i in (0...N) do
+    N.times do
 
-			all_in_block :abc, 'd', 'ef', 't=', T
-		end
-	end
+      all_in_block :abc, 'd', 'ef', 't=', T
+    end
+  end
 
-#	[ at_0 + at_1 + at_2 + bt_0 + bt_1 + bt_2, (at_0 + at_1 + at_2 + bt_0 + bt_1 + bt_2) / 2 ]
+#  [ at_0 + at_1 + at_2 + bt_0 + bt_1 + bt_2, (at_0 + at_1 + at_2 + bt_0 + bt_1 + bt_2) / 2 ]
 end
 
 

data/test/scratch/log_rolling_by_period_daily.rb

@@ -6,7 +6,7 @@
 # Purpose:      Tests the log-rolling functionality of SimpleFileLogService
 #
 # Created:      4th February 2018
-# Updated:      4th February 2018
+# Updated:      28th August 2026
 #
 # Author:       Matthew Wilson
 #
@@ -33,9 +33,9 @@ log(:notice) { 'program started' }
 
 (0..1000).each do |n|
 
-	log :informational, "increment #{n}: '#{'*' * 10 * n}'"
+  log :informational, "increment #{n}: '#{'*' * 10 * n}'"
 
-	sleep 100
+  sleep 100
 end
 
 at_exit { log :notice, 'program ending ...' }