console 1.19.0 → 1.29.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e68f107945b1831b98497a3a7d6a251b030788dfb0f85e212af7da334816f791
-  data.tar.gz: 0460616df8b87571a01eba8d41cdfa2c30ae2efb4c7847c322273cc1de8d74fd
+  metadata.gz: 1fa166f5900ef3a9c90b337ce6dd57faa99527fd9746a47aa61bb7f7535e606d
+  data.tar.gz: c6d7d06fdd475006e000c3da6d65fdcd3a5c58e10c90afa8b380f795d45a16d1
 SHA512:
-  metadata.gz: 9d7f4c0af841a44c643e24dec336bb1a71642fe292fe204382282e6ef1766a6fe6ec4390486c6e9b3bc6d841b5d603739711ed14848fc4024f6d9c2b169e2e09
-  data.tar.gz: 65399cb6f4c81c5bbe67a746797fa37a96d8a01f1b540abdb01cccad73ea174439a2c27131db84fa2ee80b6860a69150ed77a19e9d3a298cc22dc1e6ed4a97bf
+  metadata.gz: 620b134d260d72d3b69a57e455584d556d611aa8a441fbd7624722b1cfaf3541015335717b82da8ea2aa0682f94e2898c9f28c4162fa5b5842297035f81bd5c0
+  data.tar.gz: be9318b5f775a9bd33f5c8951ffae4b921dbe0618f209080645a3eb12dcd096ef092d94f1239564e03497961ebbfbbb926d43294b8b524a94486e6b62a835b1a

data/bake/console.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2020-2022, by Samuel Williams.
+# Copyright, 2020-2024, by Samuel Williams.
 
 # Increase the verbosity of the logger to info.
 def info
-	require_relative '../lib/console'
+	require_relative "../lib/console"
 	
 	Console.logger.info!
 end
 
 # Increase the verbosity of the logger to debug.
 def debug
-	require_relative '../lib/console'
+	require_relative "../lib/console"
 	
 	Console.logger.debug!
 end

data/lib/console/adapter.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2023, by Samuel Williams.
+# Copyright, 2023-2024, by Samuel Williams.
 
 module Console
+	# This namespace is reserved for logging adapters provided by other gems.
 	module Adapter
 	end
 end

data/lib/console/capture.rb

@@ -1,35 +1,54 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2019-2022, by Samuel Williams.
+# Copyright, 2019-2024, by Samuel Williams.
 
-require_relative 'filter'
+require_relative "filter"
+require_relative "output/failure"
 
 module Console
 	# A general sink which captures all events into a buffer.
 	class Capture
 		def initialize
-			@buffer = []
+			@records = []
 			@verbose = false
 		end
 		
-		attr :buffer
+		attr :records
+		
+		# @deprecated Use {#records} instead of {#buffer}.
+		alias buffer records
+		
+		alias to_a records
+		
 		attr :verbose
 		
-		def last
-			@buffer.last
+		def include?(pattern)
+			@records.any? do |record|
+				record[:subject].to_s&.match?(pattern) or record[:message].to_s&.match?(pattern)
+			end
 		end
 		
-		def include?(pattern)
-			JSON.dump(@buffer).include?(pattern)
+		def each(&block)
+			@records.each(&block)
+		end
+		
+		include Enumerable
+		
+		def first
+			@records.first
+		end
+		
+		def last
+			@records.last
 		end
 		
 		def clear
-			@buffer.clear
+			@records.clear
 		end
 		
 		def empty?
-			@buffer.empty?
+			@records.empty?
 		end
 		
 		def verbose!(value = true)
@@ -40,32 +59,42 @@ module Console
 			@verbose
 		end
 		
-		def call(subject = nil, *arguments, severity: UNKNOWN, **options, &block)
-			message = {
+		def call(subject = nil, *arguments, severity: UNKNOWN, event: nil, **options, &block)
+			record = {
 				time: ::Time.now.iso8601,
 				severity: severity,
 				**options,
 			}
 			
 			if subject
-				message[:subject] = subject
+				record[:subject] = subject
+			end
+			
+			if event
+				record[:event] = event.to_hash
 			end
 			
 			if arguments.any?
-				message[:arguments] = arguments
+				record[:arguments] = arguments
+			end
+			
+			if annotation = Fiber.current.annotation
+				record[:annotation] = annotation
 			end
 			
 			if block_given?
 				if block.arity.zero?
-					message[:message] = yield
+					record[:message] = yield
 				else
 					buffer = StringIO.new
 					yield buffer
-					message[:message] = buffer.string
+					record[:message] = buffer.string
 				end
+			else
+				record[:message] = arguments.join(" ")
 			end
 			
-			@buffer << message
+			@records << record
 		end
 	end
 end

data/lib/console/compatible/logger.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2022, by Samuel Williams.
+# Copyright, 2022-2024, by Samuel Williams.
 
-require 'logger'
+require "logger"
 
 module Console
 	module Compatible
+		# A compatible interface for {::Logger} which can be used with {Console}.
 		class Logger < ::Logger
 			class LogDevice
 				def initialize(subject, output)
@@ -29,7 +30,7 @@ module Console
 				end
 			end
 
-			def initialize(subject, output)
+			def initialize(subject, output = Console)
 				super(nil)
 				
 				@progname = subject

data/lib/console/event/failure.rb

@@ -1,73 +1,77 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2019-2022, by Samuel Williams.
+# Copyright, 2019-2024, by Samuel Williams.
 # Copyright, 2021, by Robert Schulze.
+# Copyright, 2024, by Patrik Wenger.
 
-require_relative 'generic'
+require_relative "generic"
 
 module Console
 	module Event
+		# Represents a failure event.
+		#
+		# ```ruby
+		# Console::Event::Failure.for(exception).emit(self)
+		# ```
 		class Failure < Generic
-			def self.current_working_directory
+			def self.default_root
 				Dir.getwd
 			rescue # e.g. Errno::EMFILE
 				nil
 			end
 			
 			def self.for(exception)
-				self.new(exception, self.current_working_directory)
+				self.new(exception, self.default_root)
 			end
 			
-			def initialize(exception, root = nil)
-				@exception = exception
-				@root = root
+			def self.log(subject, exception, **options)
+				Console.error(subject, **self.for(exception).to_hash, **options)
 			end
 			
-			attr :exception
-			attr :root
+			attr_reader :exception
 			
-			def self.register(terminal)
-				terminal[:exception_title] ||= terminal.style(:red, nil, :bold)
-				terminal[:exception_detail] ||= terminal.style(:yellow)
-				terminal[:exception_backtrace] ||= terminal.style(:red)
-				terminal[:exception_backtrace_other] ||= terminal.style(:red, nil, :faint)
-				terminal[:exception_message] ||= terminal.style(:default)
+			def initialize(exception, root = Dir.getwd)
+				@exception = exception
+				@root = root
 			end
 			
-			def to_h
-				{exception: @exception, root: @root}
+			def to_hash
+				Hash.new.tap do |hash|
+					hash[:type] = :failure
+					hash[:root] = @root if @root
+					extract(@exception, hash)
+				end
 			end
 			
-			def format(output, terminal, verbose)
-				format_exception(@exception, nil, output, terminal, verbose)
+			def emit(*arguments, **options)
+				options[:severity] ||= :error
+				
+				super
 			end
 			
-			def format_exception(exception, prefix, output, terminal, verbose)
-				lines = exception.message.lines.map(&:chomp)
-				
-				output.puts "  #{prefix}#{terminal[:exception_title]}#{exception.class}#{terminal.reset}: #{lines.shift}"
-				
-				lines.each do |line|
-					output.puts "  #{terminal[:exception_detail]}#{line}#{terminal.reset}"
-				end
-				
-				root_pattern = /^#{@root}\// if @root
+			private
+			
+			def extract(exception, hash)
+				hash[:class] = exception.class.name
 				
-				exception.backtrace&.each_with_index do |line, index|
-					path, offset, message = line.split(":")
-					style = :exception_backtrace
+				if exception.respond_to?(:detailed_message)
+					message = exception.detailed_message
 					
-					# Make the path a bit more readable
-					if root_pattern and path.sub!(root_pattern, "").nil?
-						style = :exception_backtrace_other
-					end
+					# We want to remove the trailling exception class as we format it differently:
+					message.sub!(/\s*\(.*?\)$/, "")
 					
-					output.puts "  #{index == 0 ? "→" : " "} #{terminal[style]}#{path}:#{offset}#{terminal[:exception_message]} #{message}#{terminal.reset}"
+					hash[:message] = message
+				else
+					hash[:message] = exception.message
 				end
 				
-				if exception.cause
-					format_exception(exception.cause, "Caused by ", output, terminal, verbose)
+				hash[:backtrace] = exception.backtrace
+				
+				if cause = exception.cause
+					hash[:cause] = Hash.new.tap do |cause_hash|
+						extract(cause, cause_hash)
+					end
 				end
 			end
 		end

data/lib/console/event/generic.rb

@@ -1,22 +1,25 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2019-2022, by Samuel Williams.
+# Copyright, 2019-2024, by Samuel Williams.
 
 module Console
 	module Event
 		class Generic
-			def self.register(terminal)
+			def as_json(...)
+				to_hash
 			end
 			
-			def to_h
+			def to_json(...)
+				JSON.generate(as_json, ...)
 			end
 			
-			def to_json(*arguments)
-				JSON.generate([self.class, to_h], *arguments)
+			def to_s
+				to_json
 			end
 			
-			def format(buffer, terminal)
+			def emit(*arguments, **options)
+				Console.call(*arguments, event: self, **options)
 			end
 		end
 	end

data/lib/console/event/spawn.rb

@@ -1,12 +1,21 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2019-2022, by Samuel Williams.
+# Copyright, 2019-2024, by Samuel Williams.
 
-require_relative 'generic'
+require_relative "generic"
+require_relative "../clock"
 
 module Console
 	module Event
+		# Represents a spawn event.
+		#
+		# ```ruby
+		# Console.info(self, **Console::Event::Spawn.for("ls", "-l"))
+		#
+		# event = Console::Event::Spawn.for("ls", "-l")
+		# event.status = Process.wait
+		# ```
 		class Spawn < Generic
 			def self.for(*arguments, **options)
 				# Extract out the command environment:
@@ -22,44 +31,43 @@ module Console
 				@environment = environment
 				@arguments = arguments
 				@options = options
+				
+				@start_time = Clock.now
+				
+				@end_time = nil
+				@status = nil
 			end
 			
-			attr :environment
-			attr :arguments
-			attr :options
-			
-			def chdir_string(options)
-				if options and chdir = options[:chdir]
-					" in #{chdir}"
+			def duration
+				if @end_time
+					@end_time - @start_time
 				end
 			end
 			
-			def self.register(terminal)
-				terminal[:shell_command] ||= terminal.style(:blue, nil, :bold)
-			end
-			
-			def to_h
+			def to_hash
 				Hash.new.tap do |hash|
+					hash[:type] = :spawn
 					hash[:environment] = @environment if @environment&.any?
 					hash[:arguments] = @arguments if @arguments&.any?
 					hash[:options] = @options if @options&.any?
+					
+					hash[:status] = @status.to_i if @status
+					
+					if duration = self.duration
+						hash[:duration] = duration
+					end
 				end
 			end
 			
-			def format(output, terminal, verbose)
-				arguments = @arguments.flatten.collect(&:to_s)
-				
-				output.puts "  #{terminal[:shell_command]}#{arguments.join(' ')}#{terminal.reset}#{chdir_string(options)}"
-				
-				if verbose and @environment
-					@environment.each do |key, value|
-						output.puts "    export #{key}=#{value}"
-					end
-				end
+			def emit(*arguments, **options)
+				options[:severity] ||= :info
+				super
+			end
+			
+			def status=(status)
+				@end_time = Time.now
+				@status = status
 			end
 		end
 	end
-	
-	# Deprecated.
-	Shell = Event::Spawn
 end

data/lib/console/event.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2019-2022, by Samuel Williams.
+# Copyright, 2019-2024, by Samuel Williams.
 
-require_relative 'event/spawn'
-require_relative 'event/failure'
-require_relative 'event/progress'
+require_relative "event/spawn"
+require_relative "event/failure"

data/lib/console/filter.rb

@@ -1,17 +1,26 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2019-2022, by Samuel Williams.
+# Copyright, 2019-2024, by Samuel Williams.
 # Copyright, 2019, by Bryan Powell.
 # Copyright, 2020, by Michael Adams.
 # Copyright, 2021, by Robert Schulze.
 
-require_relative 'buffer'
-
 module Console
-	UNKNOWN = 'unknown'
+	UNKNOWN = :unknown
 	
 	class Filter
+		if Object.const_defined?(:Ractor) and RUBY_VERSION >= "3.1"
+			def self.define_immutable_method(name, &block)
+				block = Ractor.make_shareable(block)
+				self.define_method(name, &block)
+			end
+		else
+			def self.define_immutable_method(name, &block)
+				define_method(name, &block)
+			end
+		end
+		
 		def self.[] **levels
 			klass = Class.new(self)
 			minimum_level, maximum_level = levels.values.minmax
@@ -24,17 +33,17 @@ module Console
 				levels.each do |name, level|
 					const_set(name.to_s.upcase, level)
 					
-					define_method(name) do |subject = nil, *arguments, **options, &block|
+					define_immutable_method(name) do |subject = nil, *arguments, **options, &block|
 						if self.enabled?(subject, level)
-							self.call(subject, *arguments, severity: name, **options, **@options, &block)
+							@output.call(subject, *arguments, severity: name, **@options, **options, &block)
 						end
 					end
 					
-					define_method("#{name}!") do
+					define_immutable_method("#{name}!") do
 						@level = level
 					end
 					
-					define_method("#{name}?") do
+					define_immutable_method("#{name}?") do
 						@level <= level
 					end
 				end
@@ -134,8 +143,13 @@ module Console
 			@subjects.delete(subject)
 		end
 		
-		def call(*arguments, **options, &block)
-			@output.call(*arguments, **options, &block)
+		def call(subject, *arguments, **options, &block)
+			severity = options[:severity] || UNKNOWN
+			level = self.class::LEVELS[severity]
+			
+			if self.enabled?(subject, level)
+				@output.call(subject, *arguments, **options, &block)
+			end
 		end
 	end
 end

data/lib/console/format/safe.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023-2024, by Samuel Williams.
+
+require "json"
+
+module Console
+	module Format
+		# This class is used to safely dump objects.
+		# It will attempt to dump the object using the given format, but if it fails, it will generate a safe version of the object.
+		class Safe
+			def initialize(format: ::JSON, limit: 8, encoding: ::Encoding::UTF_8)
+				@format = format
+				@limit = limit
+				@encoding = encoding
+			end
+			
+			def dump(object)
+				@format.dump(object, @limit)
+			rescue SystemStackError, StandardError => error
+				@format.dump(safe_dump(object, error))
+			end
+			
+			private
+			
+			def filter_backtrace(error)
+				frames = error.backtrace
+				filtered = {}
+				filtered_count = nil
+				skipped = nil
+				
+				frames = frames.filter_map do |frame|
+					if filtered[frame]
+						if filtered_count == nil
+							filtered_count = 1
+							skipped = frame.dup
+						else
+							filtered_count += 1
+							nil
+						end
+					else
+						if skipped
+							if filtered_count > 1
+								skipped.replace("[... #{filtered_count} frames skipped ...]")
+							end
+							
+							filtered_count = nil
+							skipped = nil
+						end
+						
+						filtered[frame] = true
+						frame
+					end
+				end
+				
+				if skipped && filtered_count > 1
+					skipped.replace("[... #{filtered_count} frames skipped ...]")
+				end
+				
+				return frames
+			end
+			
+			def safe_dump(object, error)
+				object = safe_dump_recurse(object)
+				
+				object[:truncated] = true
+				object[:error] = {
+					class: safe_dump_recurse(error.class.name),
+					message: safe_dump_recurse(error.message),
+					backtrace: safe_dump_recurse(filter_backtrace(error)),
+				}
+				
+				return object
+			end
+			
+			def replacement_for(object)
+				case object
+				when Array
+					"[...]"
+				when Hash
+					"{...}"
+				else
+					"..."
+				end
+			end
+			
+			def default_objects
+				Hash.new.compare_by_identity
+			end
+			
+			# This will recursively generate a safe version of the object.
+			# Nested hashes and arrays will be transformed recursively.
+			# Strings will be encoded with the given encoding.
+			# Primitive values will be returned as-is.
+			# Other values will be converted using `as_json` if available, otherwise `to_s`.
+			def safe_dump_recurse(object, limit = @limit, objects = default_objects)
+				if limit <= 0 || objects[object]
+					return replacement_for(object)
+				end
+				
+				case object
+				when Hash
+					objects[object] = true
+					
+					object.to_h do |key, value|
+						[
+							String(key).encode(@encoding, invalid: :replace, undef: :replace),
+							safe_dump_recurse(value, limit - 1, objects)
+						]
+					end
+				when Array
+					objects[object] = true
+					
+					object.map do |value|
+						safe_dump_recurse(value, limit - 1, objects)
+					end
+				when String
+					object.encode(@encoding, invalid: :replace, undef: :replace)
+				when Numeric, TrueClass, FalseClass, NilClass
+					object
+				else
+					objects[object] = true
+					
+					# We could do something like this but the chance `as_json` will blow up.
+					# We'd need to be extremely careful about it.
+					# if object.respond_to?(:as_json)
+					# 	safe_dump_recurse(object.as_json, limit - 1, objects)
+					# else
+					
+					safe_dump_recurse(object.to_s, limit - 1, objects)
+				end
+			end
+		end
+	end
+end

data/lib/console/format.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023-2024, by Samuel Williams.
+
+require_relative "format/safe"
+
+module Console
+	module Format
+		def self.default
+			Safe.new(format: ::JSON)
+		end
+	end
+end