ruby_smart-simple_logger 1.0.0

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RubySmart
+  module SimpleLogger
+    module Extensions
+      module Mask
+        def self.included(base)
+          base.extend ClassMethods
+          base.include InstanceMethods
+          base.class_eval do
+            # defines the default mask to be used
+            #
+            # @option [String] :char - the character to be used as mask
+            # @option [Integer] :length - the mask length (amount of mask chars be line)
+            # @option [Symbol] :clr - the color to be used by printing the mask
+            self.mask = { char: '=', length: 100, clr: :blue }
+          end
+        end
+
+        module ClassMethods
+          def mask
+            class_variable_get('@@mask')
+          end
+
+          def mask=(mask)
+            class_variable_set('@@mask', mask)
+          end
+        end
+
+        module InstanceMethods
+          # combined getter & setter for instances mask
+          # new mask is merged with existing
+          #
+          # @example
+          #   mask
+          #   > {char: '=', length: 100}
+          #
+          #   mask(clr: :blue, length: 10)
+          #   mask
+          #   > {char: '=', length: 10, clr: :blue}
+          #
+          # @param [nil, Hash] mask
+          # @return [Hash] mask
+          def mask(mask = nil)
+            return (@mask || self.class.mask) if mask.nil?
+
+            @mask = (@mask || self.class.mask).merge(mask)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RubySmart
+  module SimpleLogger
+    module Extensions
+      module Scene
+        def self.included(base)
+          base.extend ClassMethods
+          base.include InstanceMethods
+          base.class_eval do
+            # holds the default scene options
+            # [Hash] scenes
+            self.scenes = {}
+          end
+        end
+
+        module ClassMethods
+          # returns all registered scene default options
+          # @return [Hash] scenes
+          def scenes
+            class_variable_get('@@scenes')
+          end
+
+          # sets scene options
+          # @param [Hash] scenes
+          def scenes=(scenes)
+            class_variable_set('@@scenes', scenes)
+          end
+
+          # registers a new scene by provided key & options
+          # also defines this method by provided block
+          #
+          # @example
+          #   scene :line, { level: :debug } do |data, opts = {}|
+          #     self.log data, _scene_opt(:line, opts)
+          #   end
+          #
+          # @param [Symbol] key - name of the scene method
+          # @param [Hash] opts - scene default options
+          # @param [Proc] block - scene block to define a appropriate method
+          # @return [Boolean] created result
+          def scene(key, opts = {}, &block)
+            # protect overwrite existing methods
+            # but allow all severities (levels)
+            return false if instance_methods.include?(key) && !self::LEVEL.key?(key)
+
+            # register scene default options
+            self.scenes[key] = opts
+
+            # define (or overwrite) this method, if a block was provided
+            define_method(key, &block) if block_given?
+
+            # returns success result
+            true
+          end
+        end
+
+        module InstanceMethods
+          # returns all registered scene default options
+          # @return [Hash] scenes
+          def scenes
+            self.class.scenes
+          end
+
+          private
+
+          # resolves scene options by provided key & merges them with additional options
+          # @param [Symbol] key
+          # @param [Array<Hash>] opts
+          def _scene_opt(key, *opts)
+            _opt((scenes[key] || {}), *opts)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module RubySmart
+  module SimpleLogger
+    module Extensions
+      module Severity
+        # include log level constants from original logger severity
+        include ::Logger::Severity
+
+        # add severity success (sub-kind of info = 1)
+        SUCCESS = 1.1
+
+        # creates an severity hash
+        # {
+        #   0   => 'DEBUG',
+        #   1   => 'INFO',
+        #   1.1 => 'SUCCESS',
+        #   2   => 'WARN',
+        #   ...
+        # }
+        SEVERITIES = %w(DEBUG INFO SUCCESS WARN ERROR FATAL UNKNOWN).map { |sev| [const_get(sev), sev] }.to_h.freeze
+
+        # creates an level hash from SEVERITIES
+        LEVEL = SEVERITIES.reduce({}) { |m, (lvl, sev)| m[sev.downcase.to_sym] = lvl; m }.freeze
+
+        private
+
+        # overwrite original method to provide additional severities
+        #
+        # @example
+        #   format_severity(1.1)
+        #   > 'SUCCESS'
+        #
+        # @param [Numeric] severity
+        # @return [String (frozen)] severity name
+        def format_severity(severity)
+          self.class::SEVERITIES[severity] || 'UNKNOWN'
+        end
+
+        # resolves the severity level by provided Number, Symbol or String
+        #
+        # @param [Numeric, String, Symbol] sev - severity to resolve
+        # @return [Numeric,nil] severity level
+        def _level(sev)
+          # no sev provided
+          return UNKNOWN if sev.nil?
+          # numeric and valid
+          return sev if sev.is_a?(Numeric) && SEVERITIES.key?(sev)
+
+          key = sev.to_s.downcase.to_sym
+          # symbol (:success) and valid
+          return LEVEL[key] if LEVEL.key?(key)
+
+          # fallback to unknown
+          UNKNOWN
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,224 @@
+# frozen_string_literal: false
+
+module RubySmart
+  module SimpleLogger
+    module Extensions
+      module SimpleLog
+        def self.included(base)
+          base.extend ClassMethods
+          base.include InstanceMethods
+          base.class_eval do
+            # defines the default inspector to be used
+            #
+            # :auto
+            self.inspector = :auto
+
+            # this will overwrite the default log method from the Ruby Logger
+            # but makes it still accessible through: #_log
+            alias_method :_log, :log
+            alias_method :log, :simple_log
+          end
+        end
+
+        module ClassMethods
+          def inspector
+            class_variable_get('@@inspector')
+          end
+
+          def inspector=(inspector)
+            class_variable_set('@@inspector', inspector)
+          end
+        end
+
+        module InstanceMethods
+          # Acts as the MAIN logging method and sends the data to the device
+          # - checks provided level before logging
+          # - creates & formats payload
+          #
+          # @param [Object] data
+          # @param [Hash] opts
+          # @option opts [Symbol, Numeric, String] :level - which level is logging
+          # @option opts [Array] :payload - payload for logging multilines (scene)
+          # @option opts [Symbol] :inspect - inspection method for data
+          # @option opts [Symbol] :formatter - formatter type
+          # @option opts [Hash] :mask - mask data
+          # @return [Boolean] logging result
+          def simple_log(data, opts = {})
+            # resolve & check level
+            level = _level(opts[:level])
+            return false if level < self.level
+
+            # prevents data from being transformed into payload
+            if ignore_payload? || opts[:payload].is_a?(FalseClass)
+              # prevent logging nil data
+              return false if data.nil?
+
+              add level, data
+              return true
+            end
+
+            # create a default payload, if nothing was provided
+            # :_ -> alias for log data
+            opts[:payload] ||= [self.class::PAYLOAD_DATA_KEY]
+
+            # create a default mask, if nothing was provided
+            opts[:mask] ||= self.mask
+
+            # create payloads and log each payload
+            # returns the payload boolean result
+            _payloads(opts.delete(:payload), opts, data) do |p|
+              add level, p
+            end
+
+            # returns true as logging result
+            true
+          end
+
+          # returns true if no payload should be created - instead the data will be send directly to the logdev
+          # forces the *simple_log* method to prevent building payloads from schemes - it just forwards the level & data to the logdev
+          #
+          # @return [Boolean]
+          def ignore_payload?
+            !!@ignore_payload
+          end
+
+          # resolve an inspector method for data inspection
+          # @return [Symbol, nil]
+          def inspector
+            # return or resolve inspector
+            @inspector ||= if self.class.inspector == :auto
+                             # provide awesome_print support
+                             Object.respond_to?(:ai) ? :ai : :inspect
+                           else
+                             self.class.inspector || :inspect
+                           end
+          end
+
+          private
+
+          # parses each payload and creates a callback
+          #
+          # @param [Array] payloads
+          # @param [Hash] opts
+          # @param [Object] data
+          def _payloads(payloads, opts, data)
+            payloads.each do |payload|
+              # IMPORTANT: Do NOT remove this - prevents frozen string literal problem on other file sources
+              str = ''
+              if payload == self.class::PAYLOAD_DATA_KEY
+                # checks, if we should inspect the data
+                str << _parse_data(data, (opts[:inspect] ? (opts[:inspector] || self.inspector) : nil))
+              else
+                str << _parse_payload(payload, opts)
+              end
+
+              # always append newline - except it is forced excluded
+              str << "\n" if opts[:nl] != false
+
+              yield str
+            end
+
+            true
+          end
+
+          # just parses the data and calls an inspection method, if provided
+          #
+          # @param [Object] data
+          # @param [Symbol, nil] inspector - the inspection method to be called (e.g. :ai, :inspect, :to_s) - if not provided it tries to auto-resolve
+          # @return [String] stringified data
+          def _parse_data(data, inspector = nil)
+            (inspector ? data.send(inspector) : data).to_s
+          end
+
+          # parses a single payload with provided options
+          #
+          # @example
+          #   _parse_payload(:mask, opts)
+          #
+          #   _parse_payload({mask: ' [%{subject}] '}, opts)
+          #
+          #   _parse_payload([:mask, ' [%{subject}] '], opts)
+          #
+          # @param [Array, Hash, Symbol, String] payload
+          # @param [Hash] opts
+          # @return [String] str
+          def _parse_payload(payload, opts)
+            # resolve type & additional sub-payloads (fraction)
+            payload        = payload.to_a[0] if payload.is_a?(Hash)
+            type, fraction = (payload.is_a?(Array) ? payload : [payload, nil])
+
+            # prevent type case - type is the fraction
+            return type if type.is_a?(String)
+
+            case type
+            when :mask, :_mask
+              # resolve mask data
+              mask = self.mask.merge(opts[:mask])
+
+              # resolve text from fraction
+              # this could also be a payload
+              txt = _parse_payload({ _txt: fraction }, opts)
+
+              # clean possible colored text - sucks but necessary :(
+              txt.gsub!(/\e\[[\d;]+m?/, '')
+
+              # check for provided txt length - this will decide if it's a full-line mask
+              if txt.length == 0
+                _clr((mask[:char] * mask[:length]), mask[:clr])
+              else
+                # text size is to large for mask
+                txt    = txt[0, (mask[:length] - 1)] if txt.length > mask[:length]
+                txt_lh = (txt.length / 2).floor
+
+                left_mask  = mask[:char] * ((mask[:length] / 2) - txt_lh)
+                right_mask = mask[:char] * (mask[:length] - left_mask.length - txt.length)
+
+                _clr("#{left_mask}#{txt}#{right_mask}", mask[:clr])
+                # _clr(left_mask, mask[:clr]) + _clr(txt, mask[:clr]) + _clr(right_mask, mask[:clr])
+              end
+            when :txt, :_txt
+              txt = _parse_payload(fraction, opts)
+              txt = _parse_opts(txt, opts)
+              return '' if txt.length == 0
+
+              # force string to exact length
+              txt = txt.ljust(opts[:length], ' ')[0..(opts[:length] - 1)] if opts[:length]
+
+              _clr(txt, opts[:clr])
+            when :concat
+              fraction = [fraction] unless fraction.is_a?(Array)
+              fraction.map { |f| _parse_payload(f, opts) }.join
+            when :blank, :_blank
+              ''
+            else
+              # unknown type will be resolved by returning as string
+              fraction.nil? ? type.to_s : fraction.to_s
+            end
+          end
+
+          # parses wildcards ( %{xyz} ) from provided text by using the option keys
+          #
+          # @param [String] str
+          # @param [Hash] opts
+          # @return [String] parsed txt
+          def _parse_opts(str, opts = {})
+            mask           = opts[:mask] || { length: 0 }
+            str            = str.to_s
+            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]
+
+            str.scan(/%\{(\w+)\}/) do |mm|
+              next unless mm.length > 0 && mm[0]
+              m = mm[0].to_sym
+              txt.gsub!("%{#{m}}", (opts[m] ? opts[m].to_s : ''))
+            end
+
+            txt
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RubySmart
+  module SimpleLogger
+    module Extensions
+      module Timer
+        def timer(action, key = :default, opts = {})
+          @timers      ||= {}
+          @timers[key] ||= {
+            start:   nil,
+            stop:    nil,
+            measure: 0
+          }
+
+          case action
+          when :restart
+            @timers[key][:start]   = Time.now
+            @timers[key][:stop]    = nil
+            @timers[key][:measure] = 0
+
+            true
+          when :start, :continue
+            @timers[key][:start] = Time.now
+            @timers[key][:stop]  = nil
+
+            true
+          when :stop
+            return false if !@timers[key][:start] || @timers[key][:stop]
+            @timers[key][:stop]    = Time.now
+            @timers[key][:measure] += @timers[key][:stop] - @timers[key][:start]
+
+            true
+          when :pause
+            return false if !@timers[key][:start] || @timers[key][:stop]
+
+            @timers[key][:measure] += Time.now - @timers[key][:start]
+            @timers[key][:start]   = nil
+            @timers[key][:stop]    = nil
+
+            true
+          when :clear
+            self.timer(:stop, key)
+            current = self.timer(:current, key)
+            @timers.delete(key)
+
+            # time_ago_in_words in only available if activesupport & actionview gems are loaded
+            if opts[:humanized] && respond_to?(:time_ago_in_words)
+              time_ago_in_words(current.to_i.seconds.from_now, include_seconds: true)
+            else
+              current
+            end
+          when :current
+            current = @timers[key][:measure]
+            current += Time.now - @timers[key][:start] if @timers[key][:start] && @timers[key][:stop].nil?
+            current
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_smart/simple_logger/formatter.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: false
+
+module RubySmart
+  module SimpleLogger
+    class Formatter
+      class << self
+        # returns all registered formats
+        # @return [Hash] formats
+        def formats
+          class_variable_get('@@formats')
+        end
+
+        # sets formats
+        # @param [Hash] formats
+        def formats=(formats)
+          class_variable_set('@@formats', formats)
+        end
+      end
+
+      # 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)] }
+        },
+        # 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)] }
+        }
+      }
+
+      # defines the severity colors
+      SEVERITY_COLORS = {
+        'DEBUG'   => :blue,
+        'INFO'    => :cyan,
+        'WARN'    => :yellow,
+        'ERROR'   => :red,
+        'FATAL'   => :bg_red,
+        'SUCCESS' => :green
+      }
+
+      # initialize with options
+      # @param [Hash] opts
+      # @option opts [Symbol] :format - define other format
+      # @option opts [Boolean] :nl - create newline after each call (default: true)
+      # @option opts [Boolean] :clr - colorizes the whole output (default: false)
+      def initialize(opts = {})
+        # set default opts
+        opts[:nl]     = true if opts[:nl].nil?
+        opts[:format] = :default if opts[:format].nil?
+
+        @opts = opts
+      end
+
+      # standard call method - used to format provided terms
+      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
+      end
+
+      # returns all formats
+      # @return [Hash] formats
+      def formats
+        self.class.formats
+      end
+
+      # combined getter & setter for options
+      # new options are merged with existing
+      #
+      # @example
+      #   opts
+      #   > {formatter: :default, nl: true}
+      #
+      #   opts(nl: false, test: 45)
+      #   opts
+      #   > {formatter: :default, nl: false, test: 45}
+      #
+      # @param [nil, Hash] opts
+      # @return [Hash] opts
+      def opts(opts = nil)
+        return @opts if opts.nil?
+
+        clear!
+
+        @opts.merge!(opts)
+      end
+
+      # clears auto-generated / cached data
+      def clear!
+        @current_format = nil
+      end
+
+      private
+
+      def current_format
+        @current_format ||= self.formats.key?(opts[:format]) ? self.formats[opts[:format]] : self.formats.values.first
+      end
+
+      def current_format_str
+        current_format[:str]
+      end
+
+      def current_format_cb
+        current_format[:cb]
+      end
+
+      def format_datetime(time, short = false)
+        if short
+          time.strftime("%Y-%m-%d %H:%M:%S")
+        else
+          time.strftime("%Y-%m-%dT%H:%M:%S.%6N")
+        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")
+        else
+          msg.inspect
+        end
+      end
+    end
+  end
+end

data/lib/ruby_smart/simple_logger/gem_version.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RubySmart
+  module SimpleLogger
+    # Returns the version of the currently loaded module as a <tt>Gem::Version</tt>
+    def self.gem_version
+      Gem::Version.new VERSION::STRING
+    end
+
+    module VERSION
+      MAJOR = 1
+      MINOR = 0
+      TINY  = 0
+      PRE   = nil
+
+      STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+
+      def self.to_s
+        STRING
+      end
+    end
+  end
+end

data/lib/ruby_smart/simple_logger/klass_logger.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: false
+
+module RubySmart
+  module SimpleLogger
+    module KlassLogger
+      def self.extended(base)
+        base.send(:include, RubySmart::SimpleLogger::Logger::Severity)
+        base.class_eval do
+          self.klass_logger_opts = {}
+        end
+      end
+
+      def klass_logger_opts
+        class_variable_get('@@klass_logger_opts')
+      end
+
+      def klass_logger_opts=(opts)
+        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
+        RubySmart::SimpleLogger::Logger.new(*args)
+      end
+
+      def klass_logger
+        @klass_logger ||= self.new
+      end
+
+      def clear!
+        @klass_logger = nil
+      end
+
+      def method_missing(name, *args, &block)
+        return self.klass_logger.send(name, *args) if self.klass_logger.respond_to? name
+        super
+      end
+
+      def respond_to?(method_name, _include_private = false)
+        self.klass_logger.respond_to? method_name
+      end
+    end
+  end
+end