ruby_smart-simple_logger 1.0.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b775a10b017444f9047871d41db7c386bb6510b2321c4cf71444eb6a33f8e22
-  data.tar.gz: c4f786468dcf26311e72f4860c6859942cea284370ba733c5e80b5a4c5a47dfa
+  metadata.gz: c9d250fc038e12f5d76ede43d6714efb039be7b6093bd4ea8abca6dfc937d8cc
+  data.tar.gz: 52d4bc7495fea29db91b336161b7af454d55b9f22e76f1e83291264844686df7
 SHA512:
-  metadata.gz: 460b10c4d0f27a6ab678bd2ad589b2f9986348a596e88b1f5c580bd08fd9c310af75b710758693902bbe76a7e838a6f9231fb37824e627677ca44ca65d52bc27
-  data.tar.gz: 1c7ea37910757a6748a230a4579a5b848e78ffb03dd40c01f55c9cc035e91853a30e9230735e28627aa67bf549028320f35bb6ff9b0f1b579923699b47411742
+  metadata.gz: cf60c99604f5da1abd4bc4ffa5c536c233728c242c7c198849fd1838cacf856a0abaaef39f6cb1aa46fc9adbd85be329637f01e0844c39e43bdac660db311a20
+  data.tar.gz: 7c618af918fd6a19228f152fd456a8a4f2d99bbeceae1aec4d2aa6706f11f2138ba575390d68076f2d07e29fe09fbcdce75c64baed06a887becb752662f391bd

data/.gitignore

@@ -6,6 +6,7 @@ Gemfile.lock
 # testing
 .rspec_status
 /spec/reports/
+/log
 
 # documentation & coverage
 /.yardoc

data/README.md

@@ -4,7 +4,7 @@
 [![Documentation](https://img.shields.io/badge/docs-rdoc.info-blue.svg)](http://rubydoc.info/gems/ruby_smart-simple_logger)
 
 [![Gem Version](https://badge.fury.io/rb/ruby_smart-simple_logger.svg?kill_cache=1)](https://badge.fury.io/rb/ruby_smart-simple_logger)
-[![License](https://img.shields.io/github/license/ruby-smart/simple_logger)](docs/LICENSE.txt)
+[![License](https://img.shields.io/badge/license-MIT-green)](docs/LICENSE.txt)
 
 [![Coverage Status](https://coveralls.io/repos/github/ruby-smart/simple_logger/badge.svg?branch=main&kill_cache=1)](https://coveralls.io/github/ruby-smart/simple_logger?branch=main)
 [![Tests](https://github.com/ruby-smart/simple_logger/actions/workflows/ruby.yml/badge.svg)](https://github.com/ruby-smart/simple_logger/actions/workflows/ruby.yml)
@@ -147,7 +147,7 @@ MyCustomLogger.info "Very nice here"
 # => creates a logfile @ log/my_app/tasks/special_task.log
 ```
 
-This is already done for the `SimpleLogger` module - so you can directly access the methods:
+This is already done for the `SimpleLogger` _(or `Debugger`)_ module - so you can directly access the methods:
 ```ruby
 require 'simple_logger'
 
@@ -171,6 +171,14 @@ other_logger2 = SimpleLogger.new :rails
 other_logger2.info "directly logs to the rails logger"
 ```
 
+Alternatives with 'Debugger':
+```ruby
+require 'debugger'
+
+Debugger.debug "some debug"
+Debugger.error "that failed ..."
+```
+
 -----
 
 ## Builtins
@@ -294,7 +302,7 @@ noformat_logger.debug "some debug without color and mask - uses the default form
 
 ### Module Builtin
 
-Providing a ```Module``` will also create and write to a new logfile.
+Providing a ```module``` will also create and write to a new logfile.
 The path depends on the provided module name.
 
 **Example:**
@@ -335,7 +343,9 @@ logger.debug "debug message"
 ### passthrough Format
 
 The **passthrough** format is mostly used to just 'passthrough' all args to the device _(proc, memory, file, etc.)_ without formatting anything.
-This will just provide an array of args.
+This will simply provide an array of args.
+
+_Using this format will prevent **newlines** and does not recognize the `:nl` / `:clr` option._
 
 ```ruby
 logger = ::SimpleLogger.new(:stdout, format: :passthrough, payload: false)
@@ -349,6 +359,8 @@ logger.debug "debug message"
 The **plain** format is only used to forward the provided **data**, without severity, time, etc.
 This is the default behaviour of the SimpleLogger - which is used to build `scene`, masks, ...
 
+_Using this format will prevent **newlines** and does not recognize the `:nl` / `:clr` option._
+
 ```ruby
 logger = ::SimpleLogger.new(:stdout, format: :plain, payload: false)
 
@@ -368,6 +380,8 @@ payload_logger.debug "debug message"
 
 The **memory** format is only used by the memory-device to store severity, time & data as an array.
 
+_Using this format will prevent **newlines** and does not recognize the `:nl` / `:clr` option._
+
 ```ruby
 logger = ::SimpleLogger.new(:stdout, format: :memory, payload: false)
 
@@ -419,7 +433,7 @@ logger = ::SimpleLogger.new(payload: false)
 logger = ::SimpleLogger.new(:stdout, payload: false)
 ```
 
-### format _(for default formatter ONLY)_
+### format
 
 Provide a other format.
 Possible values: ```:default, :passthrough, :plain, :memory, :datalog```
@@ -428,7 +442,7 @@ logger = ::SimpleLogger.new(format: :default)
 logger = ::SimpleLogger.new(:memory, format: :passthrough)
 ```
 
-### nl _(for default formatter ONLY)_
+### nl
 
 Enable / disable NewLine for formatter.
 ```ruby
@@ -445,7 +459,7 @@ Provide a callback for the ```:proc``` builtin.
 logger = ::SimpleLogger.new(:proc, proc: lambda{|data| ... })
 ```
 
-### stdout _(:memory-builtin ONLY)_
+### stdout _(:memory & Module-builtin ONLY)_
 
 Enable STDOUT as MultiDevice for the memory builtin.
 ```ruby
@@ -454,8 +468,8 @@ logger = ::SimpleLogger.new(:memory, stdout: true)
 # same as above
 logger = ::SimpleLogger.new(
   ::SimpleLogger::Devices::MultiDevice.new.
-    register(::SimpleLogger::Devices::MemoryDevice.new, ::SimpleLogger::Formatter.new(format: :memory, nl: false)).
-    register(STDOUT, ::SimpleLogger::Formatter.new(format: :default, nl: true, clr: (opts[:clr] != nil)))
+    register(::SimpleLogger::Devices::MemoryDevice.new, ::SimpleLogger::Formatter.new(format: :memory)).
+    register(STDOUT, ::SimpleLogger::Formatter.new(format: :default, nl: true, clr: opts[:clr]))
 )
 ```
 
@@ -491,24 +505,6 @@ Provide a custom formatter instance.
 logger = ::SimpleLogger.new(formatter: My::Custom::Formatter.new)
 ```
 
-### clr
-
-Disable color for payload and formatter.
-
-```ruby
-logger = ::SimpleLogger.new(clr: false)
-```
-
-### payload
-
-Disable payload _(mask & scenes)_ for logger
-
-```ruby
-logger = ::SimpleLogger.new(payload: false)
-logger.debug "some debug without payload"
-# some debug without payload
-```
-
 ### inspect
 
 Disable inspect for logger
@@ -711,6 +707,51 @@ The following PRE-defined scenes are available. _(You can define your own scenes
 #                                                 50 chars -> __________________________________________________
 ```
 
+### processed(name, opts)
+```ruby
+require 'simple_logger'
+l = SimpleLogger.new(:stdout, payload: false)
+
+l.processed("Process Alpha", timer: true) do
+  l.info "find files"
+  l.info "found 34 files"
+  
+  l.processed("extracting ...", timer: true) do
+    l.info "10% done"
+    l.info "20% done"
+    l.info "100% done"
+    
+    # returns true to the processed state
+    true
+  end
+
+  l.processed("transforming ...") do
+    l.error "bad memory"
+    l.info "rolling back"
+    # returns false to the processed state
+    false
+  end
+
+  # returns nil to the processed state
+  nil
+end
+
+
+# ╔ START - Process Alpha
+# ╟ find files
+# ╟ found 34 files
+# ║ ┌ START - extracting ...
+# ║ ├ 10% done
+# ║ ├ 20% done
+# ║ ├ 100% done
+# ║ └ END   - SUCCESS (duration: 0.000267545)
+# ║ ┌ START - transforming ...
+# ║ ├ bad memory
+# ║ ├ rolling back
+# ║ └ END   - FAILED
+# ╚ END   - Process Alpha (duration: 0.001040807)
+```
+
 ### _other useful methods_
 
 - line

data/docs/CHANGELOG.md

@@ -1,5 +1,18 @@
 # RubySmart::SimpleLogger - CHANGELOG
 
+## [1.1.1] - 2023-02-07
+* **[fix]** 'ruby 2.6.x' kwargs for `::Logger::LogDevice` messed up with 'binmode'
+
+## [1.1.0] - 2023-02-07
+* **[add]** `#processed` method for logger
+* **[ref]** `Debugger` to enforce a 'DEBUG' severity
+* **[ref]** `RubySmart::SimpleLogger::Formatter` with simplified formats
+* **[ref]** 'default' format to only 
+* **[ref]** builtin for 'modules' to directly work with 'stdout' option
+* **[ref]** handling of logger-newlines 'nl'-option
+* **[fix]** 'inspector' detection
+* **[fix]** `RubySmart::SimpleLogger::KlassLogger.new` not 'dup' klass_logger_opts (now prevents reference manipulation)
+
 ## [1.0.0] - 2023-01-29
 * **[add]** full documentation
 * **[add]** add colors, if gem `awesome_print` ist missing

data/docs/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2022 Ruby Smart
+Copyright (c) 2023 Ruby Smart
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/lib/debugger.rb

@@ -12,6 +12,9 @@ GemInfo.safe_require 'awesome_print'
 class Debugger
   extend ::RubySmart::SimpleLogger::KlassLogger
 
+  # force debugger to 'DEBUG' severity
+  self.klass_logger_opts = {level: ::RubySmart::SimpleLogger::Logger::DEBUG}
+
   # overwrite existing "debug" method (if Debase was loaded)
   def self.debug(*args)
     return false if args.none?

data/lib/ruby_smart/simple_logger/devices/multi_device.rb

@@ -8,6 +8,10 @@ module RubySmart
         attr_reader :devices
         attr_reader :status
 
+        def self.register(*args)
+          new.register(*args)
+        end
+
         def initialize
           @devices = []
           @status  = true

data/lib/ruby_smart/simple_logger/extensions/helper.rb

@@ -13,23 +13,22 @@ module RubySmart
 
         # prepare builtin defaults
         # @param [Hash] opts
-        def _opts_builtin(opts)
-          builtin = opts.delete(:builtin)
+        # @param [Object] builtin
+        def _opts_builtin(opts, builtin = nil)
+          builtin ||= opts.delete(:builtin)
 
           case builtin
           when nil
             # device is nil - resolve optimal device
-            opts[:device] ||= if ::ThreadInfo.stdout?
-                                # colorize output
-                                opts[:clr] = true if opts[:clr].nil?
-
-                                STDOUT
-                              elsif ::ThreadInfo.rails? && ::Rails.logger
-                                ::RubySmart::SimpleLogger::Devices::MultiDevice.new.register(::Rails.logger.instance_variable_get(:@logdev).dev)
-                              else
-                                ::RubySmart::SimpleLogger::Devices::MemoryDevice.new
-                              end
+            if ::ThreadInfo.stdout?
+              _opts_builtin(opts, :stdout)
+            elsif ::ThreadInfo.rails? && ::Rails.logger
+              _opts_builtin(opts, :rails)
+            else
+              _opts_builtin(opts, :memory)
+            end
           when :stdout
+            # set device ONLY if unset in opts
             opts[:device] ||= STDOUT
             # colorize output
             opts[:clr]    = true if opts[:clr].nil?
@@ -38,31 +37,67 @@ module RubySmart
             # colorize output
             opts[:clr]    = true if opts[:clr].nil?
           when :rails
-            opts[:device] ||= ::RubySmart::SimpleLogger::Devices::MultiDevice.new.register(::Rails.logger.instance_variable_get(:@logdev).dev)
+            # set device ONLY if unset in opts
+            opts[:device] ||= ::RubySmart::SimpleLogger::Devices::MultiDevice.register(::Rails.logger.instance_variable_get(:@logdev).dev)
           when :proc
             # auto sets related opts for proc device
             opts[:payload] = false
+            opts[:nl]      = false
             opts[:format]  ||= :passthrough
 
-            # force set device
+            # set device ONLY if unset in opts
             opts[:device] ||= ::RubySmart::SimpleLogger::Devices::ProcDevice.new(opts[:proc])
           when :memory
             # auto sets related opts for memory device
             opts[:payload] = false
 
-            # set device
+            # set device ONLY if unset in opts
             opts[:device] ||= if opts[:stdout]
-                                # IMPORTANT: There will be a 'default' formatter created, which will passthrough all data to the device
-                                opts[:format] ||= :passthrough
+                                # store original format
+                                stdout_format = opts[:format] || :plain
+
+                                # force 'passthrough', as format, since this is required for multi-devices
+                                opts[:format] = :passthrough
 
                                 # special case handling to additionally stdout logs
-                                ::RubySmart::SimpleLogger::Devices::MultiDevice.new.
-                                  register(::RubySmart::SimpleLogger::Devices::MemoryDevice.new, ::RubySmart::SimpleLogger::Formatter.new(format: :memory, nl: false)).
-                                  register(STDOUT, ::RubySmart::SimpleLogger::Formatter.new(format: :default, nl: true, clr: (opts[:clr] != nil)))
+                                ::RubySmart::SimpleLogger::Devices::MultiDevice.new
+                                                                               .register(::RubySmart::SimpleLogger::Devices::MemoryDevice.new, ::RubySmart::SimpleLogger::Formatter.new(format: :memory))
+                                                                               .register(STDOUT, ::RubySmart::SimpleLogger::Formatter.new(format: stdout_format, nl: _nl(opts), clr: opts[:clr]))
                               else
                                 opts[:format] ||= :memory
                                 ::RubySmart::SimpleLogger::Devices::MemoryDevice.new
                               end
+          when Module
+            # set device ONLY if unset in opts
+            opts[:device] ||= if opts[:stdout]
+                                # store original format
+                                device_format = opts[:format] || :plain
+
+                                # force 'passthrough', as format, since this is required for multi-devices
+                                opts[:format] = :passthrough
+
+                                # colorize output
+                                opts[:clr]    = true if opts[:clr].nil?
+
+                                # special case handling to additionally stdout logs
+                                ::RubySmart::SimpleLogger::Devices::MultiDevice.register(
+                                  if GemInfo.match?(RUBY_VERSION, '< 2.7')
+                                    ::Logger::LogDevice.new(_logdev(builtin),
+                                                            shift_age:           opts[:shift_age] || 0,
+                                                            shift_size:          opts[:shift_size] || 1048576,
+                                                            shift_period_suffix: opts[:shift_period_suffix])
+                                  else
+                                    ::Logger::LogDevice.new(_logdev(builtin),
+                                                            shift_age:           opts[:shift_age] || 0,
+                                                            shift_size:          opts[:shift_size] || 1048576,
+                                                            shift_period_suffix: opts[:shift_period_suffix],
+                                                            binmode:             opts[:binmode])
+                                  end,
+                                  ::RubySmart::SimpleLogger::Formatter.new(format: device_format, nl: _nl(opts), clr: false))
+                                                                               .register(STDOUT, ::RubySmart::SimpleLogger::Formatter.new(format: device_format, nl: _nl(opts), clr: opts[:clr]))
+                              else
+                                builtin
+                              end
           else
             # forward provided device ONLY if unset in opts
             opts[:device] ||= builtin
@@ -141,25 +176,36 @@ module RubySmart
           # clean & rewrite level (possible symbols) to real level
           opts[:level] = _level(opts[:level] || :debug)
 
+          # clean & rewrite nl
+          opts[:nl] = _nl(opts)
+
+          # rewrite format
+          opts[:format] ||= :plain
+
           # provide custom formatter and forward special opts (format, nl, clr)
-          opts[:formatter] ||= ::RubySmart::SimpleLogger::Formatter.new({ format: :plain, nl: false, clr: false }.merge(opts.slice(:format, :nl, :clr)))
+          opts[:formatter] ||= ::RubySmart::SimpleLogger::Formatter.new(opts)
 
           # ignore payload and send data directly to the logdev
           @ignore_payload  = true if opts[:payload].is_a?(FalseClass)
 
-          # set the inspector to be used for data inspection
-          @inspector = opts[:inspector]
-
-          # disable inspector
-          @inspector = :to_s if opts[:inspect] == false
-
-          # # build logdev
-          # opts[:logdev] = _logdev(opts[:device])
+          # set the inspector to be used for data inspection.
+          # 'disable' inspector, if false was provided - which simply results in +#to_s+
+          @inspector = (opts[:inspect] === false) ? :to_s : opts[:inspector]
 
           # simple return opts
           opts
         end
 
+        # returns the +nl+ (new line) flag, depending on the provided options.
+        # recognizes +:nl+ and +:payload+ options.
+        # @param [Hash] opts
+        # @return [Boolean]
+        def _nl(opts)
+          return opts[:nl] unless opts[:nl].nil?
+
+          opts[:payload].is_a?(FalseClass)
+        end
+
         # merge all provided hashes into one single hash
         #
         # @example

data/lib/ruby_smart/simple_logger/extensions/logs.rb

@@ -20,6 +20,12 @@ module RubySmart
             m
           end
         end
+
+        # returns a hash with total amounts per logged type (key)
+        # @return [Hash]
+        def log_stats
+          logs_to_h.reduce({}) { |m, (sev, logs)| m[sev] = logs.count; m }
+        end
       end
     end
   end

data/lib/ruby_smart/simple_logger/extensions/processed.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module RubySmart
+  module SimpleLogger
+    module Extensions
+      module Processed
+        def self.included(base)
+          base.extend ClassMethods
+          base.include InstanceMethods
+          base.class_eval do
+            # set default box chars
+            self.box_chars = {
+              __default__:   %w(╟ ├),
+              __processed__: %w(║ │),
+              start:         %w(╔ ┌),
+              end:           %w(╚ └)
+            }.freeze
+          end
+        end
+
+        module ClassMethods
+          def box_chars
+            class_variable_get('@@box_chars')
+          end
+
+          def box_chars=(chars)
+            class_variable_set('@@box_chars', chars)
+          end
+        end
+
+        module InstanceMethods
+          # returns the current processed level.
+          # by providing a handle it will either increase or decrease the current level.
+          # @param [nil, Symbol] handle - optional handle to increase or decrease the current lvl (+:up+ / +:down+)
+          # @return [Integer]
+          def processed_lvl(handle = nil)
+            @processed_lvl ||= -1
+
+            case handle
+            when :up
+              @processed_lvl += 1
+            when :down
+              @processed_lvl -= 1 if @processed_lvl >= 0
+            else
+              # nothing here ...
+            end
+
+            @processed_lvl
+          end
+
+          # returns true if the processed state is active.
+          # @return [Boolean]
+          def processed?
+            processed_lvl >= 0
+          end
+
+          private
+
+          # transforms the provided data into a 'processed' string and forces the data to be transformed to string.
+          # simple returns the provided data, if currently not processed.
+          # @param [Object] data
+          # @param [Hash] opts
+          # @return [Object,String]
+          def _pcd(data, opts)
+            # check for active pcd (processed)
+            return data if opts[:pcd] == false || !processed?
+
+            # resolve lvl, once
+            lvl = opts[:lvl] || processed_lvl
+
+            # create final string
+            lvl.times.map { |i| "#{_pcd_box_char(:__processed__, i)} " }.join + _pcd_box_char(opts[:pcd], lvl) + " #{data}"
+          end
+
+          # returns the processed box character for provided key and position.
+          # returns the +:__default__+, if provided key was not found.
+          # returns the max-pos char, if current pos was not found.
+          # @param [Symbol] key
+          # @param [Integer] pos
+          # @return [String]
+          def _pcd_box_char(key, pos = 0)
+            chars = self.class.box_chars[key] || self.class.box_chars[:__default__]
+            chars[pos] || chars[-1]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_smart/simple_logger/extensions/simple_log.rb

@@ -53,7 +53,7 @@ module RubySmart
               # prevent logging nil data
               return false if data.nil?
 
-              add level, data
+              add level, _pcd(data, opts)
               return true
             end
 
@@ -207,7 +207,7 @@ module RubySmart
             txt            = str.dup
 
             # SPECIAL: prevent subject being parsed longer as the mask#length
-            opts[:subject] = opts[:subject][0, (mask[:length] - 4 - mask[:char].length * 2)] if opts[:subject] && mask[:length] && opts[:subject].length > mask[:length]
+            opts[:subject] = opts[:subject].to_s[0, (mask[:length] - 4 - mask[:char].length * 2)] if opts[:subject] && mask[:length] && opts[:subject].to_s.length > mask[:length]
 
             str.scan(/%\{(\w+)\}/) do |mm|
               next unless mm.length > 0 && mm[0]

data/lib/ruby_smart/simple_logger/formatter.rb

@@ -19,30 +19,25 @@ module RubySmart
 
       # set default formats
       self.formats = {
-        # the ruby default's logging format (except to format the severity to 7-chars)
-        default: {
-          str: "%s, [%s #%d] %7s -- %s: %s",
-          cb:  lambda { |severity, time, progname, data| [severity[0], format_datetime(time), $$, severity, progname, msg2str(data)] }
+        # the ruby default's logging format -except the reformatted severity to 7-chars (instead of 5)
+        default: -> (severity, time, progname, data) {
+          _nl data2array(data, false).map { |str|
+            str == '' ? str : _clr(format('%s, [%s #%d] %7s -- %s: ', severity[0], format_datetime(time), $$, severity, progname), severity) + _declr(str)
+          }
         },
-        # all provided args as array
-        passthrough: {
-          str: false, # no formatting
-          cb: lambda { |*args| args }
-        },
-        # the plain data (msg) only, no severity, etc.
-        plain: {
-          str: false, # no formatting
-          cb: lambda { |_severity, _time, _progname, data| data }
-        },
-        # special array data for memory-logging
-        memory: {
-          str: false, # no formatting
-          cb: lambda { |severity, time, _progname, data| [severity.downcase.to_sym, time, data] }
-        },
-        # special datalog data with all provided data in additional brackets -> [data] [data] [data]
-        datalog: {
-          str: "[%7s] [%s] [#%d] [%s]",
-          cb:  lambda { |severity, time, _progname, data| [severity, format_datetime(time, true), $$, msg2str(data, true)] }
+
+        # simply 'passthrough' all args, without any formatting
+        passthrough: -> (*args) { args },
+
+        # just forward the formatted data, without any other args (no severity, time, progname)
+        plain: -> (_severity, _time, _progname, data) { _nl _declr(data.to_s) },
+
+        # specialized array for memory-logging
+        memory: -> (severity, time, _progname, data) { [severity.downcase.to_sym, time, data] },
+
+        # specialized string as datalog with every provided data in additional brackets -> [data] [data] [data]
+        datalog: -> (severity, time, _progname, data) {
+          _nl _declr(format('[#%d] [%s] [%s] [%s]', $$, format_datetime(time, true), severity, data2datalog(data)))
         }
       }
 
@@ -66,23 +61,16 @@ module RubySmart
         opts[:nl]     = true if opts[:nl].nil?
         opts[:format] = :default if opts[:format].nil?
 
-        @opts = opts
+        # only store required options
+        @opts = opts.slice(:nl, :format, :clr)
       end
 
-      # standard call method - used to format provided terms
+      # standard call method - used to format provided params
       def call(severity, time, progname, data)
-        if current_format_str
-          str = current_format_str % instance_exec(severity, time, progname, data, &current_format_cb)
-          str << "\n" if opts[:nl]
-
-          # check for colorized output
-          (opts[:clr] && SEVERITY_COLORS[severity]) ? str.send(SEVERITY_COLORS[severity]) : str
-        else
-          instance_exec(severity, time, progname, data, &current_format_cb)
-        end
+        instance_exec(severity, time, progname, data, &current_formatter)
       end
 
-      # returns all formats
+      # returns all class formats
       # @return [Hash] formats
       def formats
         self.class.formats
@@ -109,25 +97,72 @@ module RubySmart
         @opts.merge!(opts)
       end
 
-      # clears auto-generated / cached data
+      # clears current formatter
       def clear!
-        @current_format = nil
+        @current_formatter = nil
       end
 
       private
 
-      def current_format
-        @current_format ||= self.formats.key?(opts[:format]) ? self.formats[opts[:format]] : self.formats.values.first
+      # returns the current formatter callback
+      # @return [Proc]
+      def current_formatter
+        @current_formatter ||= self.formats[opts[:format]] || self.formats.values.first
+      end
+
+      # splits-up the provided data into a flat array.
+      # each will be split by new-line char +\n+.
+      # @param [Object] data
+      # @param [Boolean] allow_array
+      # @return [Array<String>]
+      def data2array(data, allow_array = true)
+        case data
+        when ::String
+          data.split("\n", -1)
+        when ::Array
+          # prevent to split-up arrays into multiple lines for this format:
+          # a array should +not+ be multi-lined
+          return data2array(data.inspect) unless allow_array
+
+          data.map { |item| data2array(item) }.flatten
+        when ::Exception
+          [
+            "exception: #{data.class}",
+            data2array(data.message),
+            data.backtrace || []
+          ].flatten
+        else
+          data2array(data.inspect)
+        end
       end
 
-      def current_format_str
-        current_format[:str]
+      # splits-up the provided data into a single string with each data item in brackets -> [data] [data] [data]
+      # @param [Object] data
+      # @return [String]
+      def data2datalog(data)
+        data2array(data).join('] [')
       end
 
-      def current_format_cb
-        current_format[:cb]
+      # formats the provided format string with args.
+      # @param [String] format
+      # @param [Array] args
+      # @return [String]
+      def format(format, *args)
+        format % args
       end
 
+      # def current_format_str
+      #   current_format[:str]
+      # end
+      #
+      # def current_format_cb
+      #   current_format[:cb]
+      # end
+      #
+      # def current_format_data(data)
+      #   (current_format[:data] ? current_format[:data].(data) : data).to_s.split("\n")
+      # end
+
       def format_datetime(time, short = false)
         if short
           time.strftime("%Y-%m-%d %H:%M:%S")
@@ -136,16 +171,41 @@ module RubySmart
         end
       end
 
-      def msg2str(msg, join = false)
-        case msg
-        when ::String
-          msg
-        when ::Array
-          join ? msg.join('] [') : msg.inspect
-        when ::Exception
-          "#{ msg.message } (#{ msg.class })\n" + (msg.backtrace || []).join("\n")
+      # returns the formatted string with a new-line.
+      # depends, on the +:nl+ option.
+      # @param [String, Array] data
+      # @return [String]
+      def _nl(data)
+        # convert to string
+        data = data.join("\n") if data.is_a?(Array)
+
+        # check for +nl+ flag
+        return data unless opts[:nl]
+
+        data + "\n"
+      end
+
+      # returns the formatted string with a color-code
+      # depends, on the +:clr+ option.
+      # @param [String] str
+      # @param [String<uppercase>] severity
+      # @return [String]
+      def _clr(str, severity)
+        if opts[:clr] && (clr = SEVERITY_COLORS[severity])
+          str.send(clr)
+        else
+          _declr(str)
+        end
+      end
+
+      # de-colorizes provided string
+      # @param [String] str
+      # @return [String]
+      def _declr(str)
+        if opts[:clr]
+          str
         else
-          msg.inspect
+          str.gsub(/\e\[[\d;]+m/, '')
         end
       end
     end

data/lib/ruby_smart/simple_logger/gem_version.rb

@@ -9,8 +9,8 @@ module RubySmart
 
     module VERSION
       MAJOR = 1
-      MINOR = 0
-      TINY  = 0
+      MINOR = 1
+      TINY  = 1
       PRE   = nil
 
       STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

data/lib/ruby_smart/simple_logger/klass_logger.rb

@@ -15,12 +15,13 @@ module RubySmart
       end
 
       def klass_logger_opts=(opts)
+        clear!
         class_variable_set('@@klass_logger_opts', opts)
       end
 
       # delegate new method to logger
       def new(*args)
-        args = [nil, self.klass_logger_opts] if args.length == 0
+        args = [nil, self.klass_logger_opts.dup] if args.length == 0
         RubySmart::SimpleLogger::Logger.new(*args)
       end
 

data/lib/ruby_smart/simple_logger/logger.rb

@@ -3,6 +3,7 @@
 require_relative 'extensions/helper'
 require_relative 'extensions/logs'
 require_relative 'extensions/mask'
+require_relative 'extensions/processed'
 require_relative 'extensions/scene'
 require_relative 'extensions/severity'
 require_relative 'extensions/simple_log'
@@ -25,6 +26,7 @@ module RubySmart
       include Extensions::Helper
       include Extensions::Logs
       include Extensions::Mask
+      include Extensions::Processed
       include Extensions::Scene
       include Extensions::Severity
       include Extensions::SimpleLog
@@ -36,7 +38,7 @@ module RubySmart
       attr_reader :logdev
 
       # defines a uniq key to parse the data
-      PAYLOAD_DATA_KEY = :_data
+      PAYLOAD_DATA_KEY = :__data__
 
       # initialize new Logger
       # @param [Object, Symbol, nil] builtin

data/lib/ruby_smart/simple_logger/scenes.rb

@@ -11,7 +11,7 @@ module RubySmart
         # > ================================================= [Debug] ================================================
         # > "DEBUGGED DATA" <- analyzed by awesome_print#ai method
         # > ==========================================================================================================
-        base.scene :debug, { level: :debug, inspect: true, payload: [[:mask, ' [%{subject}] '], :_data, :mask] } do |data, subject = 'Debug', opts = {}|
+        base.scene :debug, { level: :debug, inspect: true, payload: [[:mask, ' [%{subject}] '], :__data__, :mask] } do |data, subject = 'Debug', opts = {}|
           self.log data, _scene_opt(:debug, { subject: subject }, opts)
         end
 
@@ -22,7 +22,7 @@ module RubySmart
         # > ================================================= [Info] =================================================
         # > DATA
         # > ==========================================================================================================
-        base.scene :info, { level: :info, mask: { clr: :cyan }, payload: [[:mask, ' [%{subject}] '], :_data, :mask] } do |data, subject = 'Info', opts = {}|
+        base.scene :info, { level: :info, mask: { clr: :cyan }, payload: [[:mask, ' [%{subject}] '], :__data__, :mask] } do |data, subject = 'Info', opts = {}|
           self.log data, _scene_opt(:info, { subject: subject }, opts)
         end
 
@@ -33,7 +33,7 @@ module RubySmart
         # > ================================================= [Warn] =================================================
         # > DATA
         # > ==========================================================================================================
-        base.scene :warn, { level: :warn, mask: { clr: :yellow }, payload: [[:mask, ' [%{subject}] '], :_data, :mask] } do |data, subject = 'Warn', opts = {}|
+        base.scene :warn, { level: :warn, mask: { clr: :yellow }, payload: [[:mask, ' [%{subject}] '], :__data__, :mask] } do |data, subject = 'Warn', opts = {}|
           self.log data, _scene_opt(:warn, { subject: subject }, opts)
         end
 
@@ -44,7 +44,7 @@ module RubySmart
         # > ================================================ [Error] =================================================
         # > DATA
         # > ==========================================================================================================
-        base.scene :error, { level: :error, mask: { clr: :red }, payload: [[:mask, ' [%{subject}] '], :_data, :mask] } do |data, subject = 'Error', opts = {}|
+        base.scene :error, { level: :error, mask: { clr: :red }, payload: [[:mask, ' [%{subject}] '], :__data__, :mask] } do |data, subject = 'Error', opts = {}|
           self.log data, _scene_opt(:error, { subject: subject }, opts)
         end
 
@@ -55,7 +55,7 @@ module RubySmart
         # > ================================================ [Fatal] =================================================
         # > DATA
         # > ==========================================================================================================
-        base.scene :fatal, { level: :fatal, mask: { clr: :bg_red }, payload: [[:mask, ' [%{subject}] '], :_data, :mask] } do |data, subject = 'Fatal', opts = {}|
+        base.scene :fatal, { level: :fatal, mask: { clr: :bg_red }, payload: [[:mask, ' [%{subject}] '], :__data__, :mask] } do |data, subject = 'Fatal', opts = {}|
           self.log data, _scene_opt(:fatal, { subject: subject }, opts)
         end
 
@@ -66,7 +66,7 @@ module RubySmart
         # > ================================================ [Success] ================================================
         # > DATA
         # > ===========================================================================================================
-        base.scene :success, { level: :success, mask: { clr: :green }, payload: [[:mask, ' [%{subject}] '], :_data, :mask] } do |data, subject = 'Success', opts = {}|
+        base.scene :success, { level: :success, mask: { clr: :green }, payload: [[:mask, ' [%{subject}] '], :__data__, :mask] } do |data, subject = 'Success', opts = {}|
           self.log data, _scene_opt(:success, { subject: subject }, opts)
         end
 
@@ -273,15 +273,50 @@ module RubySmart
           perc = 0 if perc < 0
           perc = 100 if perc > 100
 
-          pmask_left_length = (pmask_length * perc / 100)
+          pmask_left_length  = (pmask_length * perc / 100)
           # reduce 1 char for the arrow '>'
-          pmask_left_length -= 1 if pmask_left_length > 0
+          pmask_left_length  -= 1 if pmask_left_length > 0
           pmask_right_length = pmask_length - pmask_left_length - 1
 
           progress_string = _clr(('=' * pmask_left_length) + '>', :green) + _clr('-' * pmask_right_length, :red)
-          perc_string = perc.to_s.rjust(3,' ')
+          perc_string     = perc.to_s.rjust(3, ' ')
           self.log nil, _scene_opt(:progress, { name: _clr(_lgth(name, 48), :cyan), perc: perc_string, progress: progress_string }, opts)
         end
+
+        # processed method
+        # log level @ info
+        # prints: a processed output with unicode box-chars (e.g. ║ )
+        #
+        # ╔ START job
+        # ╟ doing some cool log
+        # ╟ doing some extra log
+        # ╚ END job (duration: 4.34223)
+        base.scene :processed, { level: :info } do |name, opts = {}, &block|
+          # resolve the current process-level
+          lvl = processed_lvl(:up)
+
+          # start the timer, if it should - directly sets a timer key to be reused in the +:clear+ method
+          if (timer_key = (opts[:timer] ? "processed_#{lvl}" : nil))
+            self.timer(:start, timer_key) if timer_key
+          end
+
+          self.log("START - #{name}", _scene_opt(:processed, { pcd: :start }))
+
+          end_str = case block.call
+                    when true
+                      "END   - SUCCESS"
+                    when false
+                      "END   - FAILED"
+                    else
+                      "END   - #{name}"
+                    end
+
+          self.log("#{end_str} #{(timer_key ? "(duration: #{self.timer(:clear, timer_key, :humanized => true)})" : '')}", _scene_opt(:processed, { pcd: :end }))
+
+          processed_lvl(:down)
+
+          true
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_smart-simple_logger
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Tobias Gonsior
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-29 00:00:00.000000000 Z
+date: 2023-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby_smart-support
@@ -124,6 +124,7 @@ files:
 - lib/ruby_smart/simple_logger/extensions/helper.rb
 - lib/ruby_smart/simple_logger/extensions/logs.rb
 - lib/ruby_smart/simple_logger/extensions/mask.rb
+- lib/ruby_smart/simple_logger/extensions/processed.rb
 - lib/ruby_smart/simple_logger/extensions/scene.rb
 - lib/ruby_smart/simple_logger/extensions/severity.rb
 - lib/ruby_smart/simple_logger/extensions/simple_log.rb
@@ -160,7 +161,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: A simple, multifunctional logging library for Ruby.