hanami-utils 2.0.0.alpha6 → 2.0.0.rc1

data/lib/hanami/logger/colorizer.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-require "logger"
-require "hanami/utils/shell_color"
-
-module Hanami
-  class Logger < ::Logger
-    # Null colorizer for logger streams that aren't a TTY (eg. files)
-    #
-    # @since 1.2.0
-    # @api private
-    class NullColorizer
-      # @since 1.2.0
-      # @api private
-      def call(app, severity, datetime, _progname)
-        ::Hash[
-          app: app,
-          severity: severity,
-          time: datetime,
-        ]
-      end
-    end
-
-    # Hanami::Logger Default Colorizer
-    #
-    # This colorizer takes in parts of the log message and returns them with
-    # proper shellcode to colorize when displayed to a tty.
-    #
-    # @since 1.2.0
-    # @api private
-    class Colorizer < NullColorizer
-      def initialize(colors: COLORS)
-        @colors = colors
-      end
-
-      # Colorize the inputs
-      #
-      # @param app [#to_s] the app name
-      # @param severity [#to_s] log severity
-      # @param datetime [#to_s] timestamp
-      # @param _progname [#to_s] program name - ignored, accepted for
-      #   compatibility with Ruby's Logger
-      #
-      # @return [::Hash] an Hash containing the keys `:app`, `:severity`, and `:time`
-      def call(app, severity, datetime, _progname)
-        ::Hash[
-          app: app(app),
-          severity: severity(severity),
-          time: datetime(datetime),
-        ]
-      end
-
-      private
-
-      # The colors defined for the three parts of the log message
-      #
-      # @since 1.2.0
-      # @api private
-      COLORS = ::Hash[
-        app: :blue,
-        datetime: :cyan,
-      ].freeze
-
-      # @since 1.2.0
-      # @api private
-      LEVELS = ::Hash[
-        Hanami::Logger::DEBUG => :cyan,
-        Hanami::Logger::INFO => :magenta,
-        Hanami::Logger::WARN => :yellow,
-        Hanami::Logger::ERROR => :red,
-        Hanami::Logger::FATAL => :red,
-        Hanami::Logger::UNKNOWN => :blue,
-      ].freeze
-
-      attr_reader :colors
-
-      # @since 1.2.0
-      # @api private
-      def app(input)
-        colorize(input, color: colors.fetch(:app, nil))
-      end
-
-      # @since 1.2.0
-      # @api private
-      def severity(input)
-        color = LEVELS.fetch(Hanami::Logger.level(input), :gray)
-        colorize(input, color: color)
-      end
-
-      # @since 1.2.0
-      # @api private
-      def datetime(input)
-        colorize(input, color: colors.fetch(:datetime, nil))
-      end
-
-      # @since 1.2.0
-      # @api private
-      def colorize(message, color:)
-        return message if color.nil?
-
-        Hanami::Utils::ShellColor.call(message, color: color)
-      end
-    end
-  end
-end

data/lib/hanami/logger/filter.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require "logger"
-
-module Hanami
-  class Logger < ::Logger
-    # Filtering logic
-    #
-    # @since 1.1.0
-    # @api private
-    class Filter
-      # @since 1.3.7
-      # @api private
-      FILTERED_VALUE = "[FILTERED]"
-
-      def initialize(filters = [], mask: FILTERED_VALUE)
-        @filters = filters
-        @mask = mask
-      end
-
-      # @since 1.1.0
-      # @api private
-      def call(params)
-        _filter(_copy_params(params))
-      end
-
-      private
-
-      # @since 1.1.0
-      # @api private
-      attr_reader :filters
-
-      # @since 1.3.7
-      # @api private
-      attr_reader :mask
-
-      # This is a simple deep merge to merge the original input
-      # with the filtered hash which contains '[FILTERED]' string.
-      #
-      # It only deep-merges if the conflict values are both hashes.
-      #
-      # @since 1.3.7
-      # @api private
-      def _deep_merge(original_hash, filtered_hash)
-        original_hash.merge(filtered_hash) do |_key, original_item, filtered_item|
-          if original_item.is_a?(Hash) && filtered_item.is_a?(Hash)
-            _deep_merge(original_item, filtered_item)
-          elsif filtered_item == FILTERED_VALUE
-            filtered_item
-          else
-            original_item
-          end
-        end
-      end
-
-      # @since 1.1.0
-      # @api private
-      def _filtered_keys(hash)
-        _key_paths(hash).select { |key| filters.any? { |filter| key =~ %r{(\.|\A)#{filter}(\.|\z)} } }
-      end
-
-      # @since 1.1.0
-      # @api private
-      def _key_paths(hash, base = nil)
-        hash.inject([]) do |results, (k, v)|
-          results + (_key_paths?(v) ? _key_paths(v, _build_path(base, k)) : [_build_path(base, k)])
-        end
-      end
-
-      # @since 1.1.0
-      # @api private
-      def _build_path(base, key)
-        [base, key.to_s].compact.join(".")
-      end
-
-      # @since 1.1.0
-      # @api private
-      def _actual_keys(hash, keys)
-        search_in = hash
-
-        keys.inject([]) do |res, key|
-          correct_key = search_in.key?(key.to_sym) ? key.to_sym : key
-          search_in = search_in[correct_key]
-          res + [correct_key]
-        end
-      end
-
-      # Check if the given value can be iterated (`Enumerable`) and that isn't a `File`.
-      # This is useful to detect closed `Tempfiles`.
-      #
-      # @since 1.3.5
-      # @api private
-      #
-      # @see https://github.com/hanami/utils/pull/342
-      def _key_paths?(value)
-        value.is_a?(Enumerable) && !value.is_a?(File)
-      end
-
-      # @since 1.3.7
-      # @api private
-      def _deep_dup(hash)
-        hash.transform_values do |value|
-          if value.is_a?(Hash)
-            _deep_dup(value)
-          else
-            _key_paths?(value) ? value.dup : value
-          end
-        end
-      end
-
-      # @since 1.3.7
-      # @api private
-      def _copy_params(params)
-        case params
-        when Hash
-          _deep_dup(params)
-        when Array
-          params.map { |hash| _deep_dup(hash) }
-        end
-      end
-
-      # @since 1.3.7
-      # @api private
-      def _filter_hash(hash)
-        _filtered_keys(hash).each do |key|
-          *keys, last = _actual_keys(hash, key.split("."))
-          keys.inject(hash, :fetch)[last] = mask
-        end
-        hash
-      end
-
-      # @since 1.3.7
-      # @api private
-      def _filter(params)
-        case params
-        when Hash
-          _filter_hash(params)
-        when Array
-          params.map { |hash| _filter_hash(hash) }
-        end
-      end
-    end
-  end
-end

data/lib/hanami/logger/formatter.rb

@@ -1,183 +0,0 @@
-# frozen_string_literal: true
-
-require "set"
-require "json"
-require "logger"
-require "hanami/utils/json"
-require "hanami/utils/class_attribute"
-require "hanami/utils/query_string"
-
-module Hanami
-  class Logger < ::Logger
-    # Hanami::Logger default formatter.
-    # This formatter returns string in key=value format.
-    #
-    # @since 0.5.0
-    # @api private
-    #
-    # @see http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc/Logger/Formatter.html
-    class Formatter < ::Logger::Formatter
-      require "hanami/logger/filter"
-      require "hanami/logger/colorizer"
-
-      # @since 0.8.0
-      # @api private
-      SEPARATOR = " "
-
-      # @since 0.8.0
-      # @api private
-      NEW_LINE = $/
-
-      # @since 1.0.0
-      # @api private
-      RESERVED_KEYS = %i[app severity time].freeze
-
-      include Utils::ClassAttribute
-
-      class_attribute :subclasses
-      self.subclasses = Set.new
-
-      def self.fabricate(formatter, application_name, filters, colorizer)
-        fabricated_formatter = _formatter_instance(formatter)
-
-        fabricated_formatter.application_name = application_name
-        fabricated_formatter.filter           = Filter.new(filters)
-        fabricated_formatter.colorizer        = colorizer
-
-        fabricated_formatter
-      end
-
-      # @api private
-      def self.inherited(subclass)
-        super
-        subclasses << subclass
-      end
-
-      # @api private
-      def self.eligible?(name)
-        name == :default
-      end
-
-      # @api private
-      # @since 1.1.0
-      def self._formatter_instance(formatter)
-        case formatter
-        when Symbol
-          (subclasses.find { |s| s.eligible?(formatter) } || self).new
-        when nil
-          new
-        else
-          formatter
-        end
-      end
-      private_class_method :_formatter_instance
-
-      # @since 0.5.0
-      # @api private
-      attr_writer :application_name
-
-      # @since 1.0.0
-      # @api private
-      attr_reader :application_name
-
-      # @since 1.2.0
-      # @api private
-      attr_writer :filter
-
-      # @since 1.2.0
-      # @api private
-      attr_writer :colorizer
-
-      # @since 0.5.0
-      # @api private
-      #
-      # @see http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc/Logger/Formatter.html#method-i-call
-      def call(severity, time, progname, msg)
-        colorized = @colorizer.call(application_name, severity, time, progname)
-        colorized.merge!(_message_hash(msg))
-
-        _format(colorized)
-      end
-
-      private
-
-      # @since 0.8.0
-      # @api private
-      def _message_hash(message)
-        case message
-        when ::Hash
-          @filter.call(message)
-        when Exception
-          ::Hash[
-            message: message.message,
-            backtrace: message.backtrace || [],
-            error: message.class
-          ]
-        else
-          ::Hash[message: message]
-        end
-      end
-
-      # @since 0.8.0
-      # @api private
-      def _format(hash)
-        "#{_line_front_matter(hash.delete(:app), hash.delete(:severity), hash.delete(:time))}#{SEPARATOR}#{_format_message(hash)}" # rubocop:disable Layout/LineLength
-      end
-
-      # @since 1.2.0
-      # @api private
-      def _line_front_matter(*args)
-        args.map { |string| "[#{string}]" }.join(SEPARATOR)
-      end
-
-      # @since 1.2.0
-      # @api private
-      def _format_message(hash)
-        if hash.key?(:error)
-          _format_error(hash)
-        elsif hash.key?(:params)
-          "#{hash.values.join(SEPARATOR)}#{NEW_LINE}"
-        else
-          "#{Utils::QueryString.call(hash[:message] || hash)}#{NEW_LINE}"
-        end
-      end
-
-      # @since 1.2.0
-      # @api private
-      def _format_error(hash)
-        result = [hash[:error], hash[:message]].compact.join(": ").concat(NEW_LINE)
-        hash[:backtrace].each do |line|
-          result << "from #{line}#{NEW_LINE}"
-        end
-
-        result
-      end
-    end
-
-    # Hanami::Logger JSON formatter.
-    # This formatter returns string in JSON format.
-    #
-    # @since 0.5.0
-    # @api private
-    class JSONFormatter < Formatter
-      # @api private
-      def self.eligible?(name)
-        name == :json
-      end
-
-      # @api private
-      def colorizer=(*)
-        @colorizer = NullColorizer.new
-      end
-
-      private
-
-      # @since 0.8.0
-      # @api private
-      def _format(hash)
-        hash[:time] = hash[:time].utc.iso8601
-        Hanami::Utils::Json.generate(hash) + NEW_LINE
-      end
-    end
-  end
-end