hanami-utils 1.2.0.beta2 → 1.2.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b955a7e152875e4cc34e5ddec80dafe8899583ab1acd02d76b8159d6b0fae97d
-  data.tar.gz: a457c7b92519e895fd2ce3551fec98533f46719284bd252592e0306122742cb2
+  metadata.gz: 86da2fce7ef69bfbd91366caa3abcc403dcacbf581fca38eb3b242f4dcbca5e7
+  data.tar.gz: 34213163f0aff44ee06516a4ceb7fdcbe96802a4b101a1bb5c45b6220c8e8736
 SHA512:
-  metadata.gz: ba3e080d6256a17b2fc942f5f3614ffda59041c454b3bccf7ace5dd84949a2fa8e074d1e257d279b317c138e8e7e34bff3358d4ea6f4329bb96935928eb46e5f
-  data.tar.gz: 9b33223b53a7df21a33304fc368b95db9b218ab72da601967fa83bc650291485155afd2c9c054646e123da11fc6bd32150211c792b7af044d98658ad60bb6ade
+  metadata.gz: 607969cb2bc3673ef48a15102342409b5e383433c55dc39543f51dd4436e384f56050e8d48be9defddba15d2933644d001c59ce6863bffd203f020a58b34753d
+  data.tar.gz: c9374f9627a418002d7753536025f9b3724cfea6fb18a77344ccdfcc0a8d94375cf26c687fd8d91edda8fb036b75d7dda16674785260f37a8507672d62935a9c

data/CHANGELOG.md

@@ -1,6 +1,13 @@
 # Hanami::Utils
 Ruby core extentions and class utilities for Hanami
 
+## v1.2.0.rc1 - 2018-03-30
+### Added
+- [Oana Sipos & Sean Collins & Luca Guidi] Colored logging
+
+### Fixed
+- [Luca Guidi] Make `Hanami::Logger` to properly log hash messages
+
 ## v1.2.0.beta2 - 2018-03-23
 
 ## v1.2.0.beta1 - 2018-02-28

data/README.md

@@ -124,6 +124,14 @@ Manage directories where to find Ruby source code or web static assets. [[API do
 
 Safe logic to manage relative URLs. [[API doc](http://www.rubydoc.info/gems/hanami-utils/Hanami/Utils/PathPrefix)]
 
+### Hanami::Utils::QueryString
+
+URI query string transformation [[API doc](http://www.rubydoc.info/gems/hanami-utils/Hanami/Utils/QueryString)]
+
+### Hanami::Utils::ShellColor
+
+Shell colorizer [[API doc](http://www.rubydoc.info/gems/hanami-utils/Hanami/Utils/ShellColor)]
+
 ### Hanami::Utils::String
 
 Enhanced version of Ruby's `String`. [[API doc](http://www.rubydoc.info/gems/hanami-utils/Hanami/Utils/String)]

data/lib/hanami/logger/colorizer.rb

@@ -0,0 +1,95 @@
+# 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 four parts of the log message
+      #
+      # These can be overridden, keeping the name keys, with acceptable values
+      # being any from Hanami::Utils::ShellColor::COLORS
+      #
+      # @since 1.2.0
+      COLORS = ::Hash[
+        app:      :blue,
+        severity: :magenta,
+        datetime: :cyan,
+      ].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)
+        colorize(input, color: colors.fetch(:severity, nil))
+      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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Hanami
+  class Logger < ::Logger
+    # Filtering logic
+    #
+    # @since 1.1.0
+    # @api private
+    class Filter
+      # @since 1.1.0
+      # @api private
+      def initialize(filters = [])
+        @filters = filters
+      end
+
+      # @since 1.1.0
+      # @api private
+      def call(hash)
+        _filtered_keys(hash).each do |key|
+          *keys, last = _actual_keys(hash, key.split("."))
+          keys.inject(hash, :fetch)[last] = "[FILTERED]"
+        end
+
+        hash
+      end
+
+      private
+
+      # @since 1.1.0
+      # @api private
+      attr_reader :filters
+
+      # @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 + (v.respond_to?(:each) ? _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
+    end
+  end
+end

data/lib/hanami/logger/formatter.rb

@@ -0,0 +1,183 @@
+# 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) # rubocop:disable Metrics/MethodLength
+        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)}"
+      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

data/lib/hanami/logger.rb

@@ -1,11 +1,8 @@
-require 'set'
-require 'json'
-require 'logger'
-require 'hanami/utils/string'
-require 'hanami/utils/json'
-require 'hanami/utils/hash'
-require 'hanami/utils/class_attribute'
-require 'hanami/utils/files'
+# frozen_string_literal: true
+
+require "logger"
+require "hanami/utils/string"
+require "hanami/utils/files"
 
 module Hanami
   # Hanami logger
@@ -82,248 +79,65 @@ module Hanami
   #   # => app=FOO severity=INFO time=2016-05-27 10:14:42 UTC message=Hello
   #
   # @example Write to file
-  #   require 'hanami'
+  #   require 'hanami/logger'
   #
   #   Hanami::Logger.new(stream: 'logfile.log').info('Hello')
   #   # in logfile.log
   #   # => app=FOO severity=INFO time=2016-05-27 10:14:42 UTC message=Hello
   #
   # @example Use JSON formatter
-  #   require 'hanami'
+  #   require 'hanami/logger'
   #
   #   Hanami::Logger.new(formatter: Hanami::Logger::JSONFormatter).info('Hello')
   #   # => "{\"app\":\"Hanami\",\"severity\":\"INFO\",\"time\":\"1988-09-01 00:00:00 UTC\",\"message\":\"Hello\"}"
+  #
+  # @example Disable colorization
+  #   require 'hanami/logger'
+  #
+  #   Hanami::Logger.new(colorizer: false)
+  #
+  # @example Use custom colors
+  #   require 'hanami/logger'
+  #
+  #   Hanami::Logger.new(colorizer: Hanami::Logger::Colorizer.new(colors: { app: :red }))
+  #
+  # @example Use custom colorizer
+  #   require "hanami/logger"
+  #   require "paint" # gem install paint
+  #
+  #   class LogColorizer < Hanami::Logger::Colorizer
+  #     def initialize(colors: { app: [:red, :bright], severity: [:red, :blue], datetime: [:italic, :yellow] })
+  #       super
+  #     end
+  #
+  #     private
+  #
+  #     def colorize(message, color:)
+  #       Paint[message, *color]
+  #     end
+  #   end
+  #
+  #   Hanami::Logger.new(colorizer: LogColorizer.new)
   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
-      # @since 0.8.0
-      # @api private
-      SEPARATOR = ' '.freeze
-
-      # @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)
-        fabricated_formatter = _formatter_instance(formatter)
-
-        fabricated_formatter.application_name = application_name
-        fabricated_formatter.hash_filter      = HashFilter.new(filters)
-
-        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.1.0
-      # @api private
-      attr_writer :hash_filter
-
-      # @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)
-        _format({
-          app:      application_name,
-          severity: severity,
-          time:     time
-        }.merge(
-          _message_hash(msg)
-        ))
-      end
-
-      private
-
-      # @since 0.8.0
-      # @api private
-      def _message_hash(message) # rubocop:disable Metrics/MethodLength
-        case message
-        when Hash
-          @hash_filter.filter(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)
-        result = RESERVED_KEYS.map { |k| "[#{hash[k]}]" }.join(SEPARATOR)
-        return _format_error(result, hash) if hash.key?(:error)
-
-        values = hash.each_with_object([]) do |(k, v), memo|
-          memo << v unless RESERVED_KEYS.include?(k)
-        end
-
-        result << " #{values.join(SEPARATOR)}#{NEW_LINE}"
-        result
-      end
-
-      # @api private
-      def _format_error(result, hash)
-        result << " #{hash[:error]}:" if hash.key?(:error)
-        result << " #{hash[:message]}#{NEW_LINE}"
-        if hash.key?(:backtrace)
-          hash[:backtrace].each do |line|
-            result << "from #{line}#{NEW_LINE}"
-          end
-        end
-
-        result
-      end
-
-      # Filtering logic
-      #
-      # @since 1.1.0
-      # @api private
-      class HashFilter
-        # @since 1.1.0
-        # @api private
-        attr_reader :filters
-
-        # @since 1.1.0
-        # @api private
-        def initialize(filters = [])
-          @filters = filters
-        end
-
-        # @since 1.1.0
-        # @api private
-        def filter(hash)
-          _filtered_keys(hash).each do |key|
-            *keys, last = _actual_keys(hash, key.split('.'))
-            keys.inject(hash, :fetch)[last] = '[FILTERED]'
-          end
-
-          hash
-        end
-
-        private
-
-        # @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 + (v.respond_to?(:each) ? _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
-      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
-
-      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
+    require "hanami/logger/formatter"
+    require "hanami/logger/colorizer"
 
     # Default application name.
     # This is used as a fallback for tagging purposes.
     #
     # @since 0.5.0
     # @api private
-    DEFAULT_APPLICATION_NAME = 'hanami'.freeze
+    DEFAULT_APPLICATION_NAME = "hanami"
 
     # @since 0.8.0
     # @api private
-    LEVELS = Hash[
-      'debug'   => DEBUG,
-      'info'    => INFO,
-      'warn'    => WARN,
-      'error'   => ERROR,
-      'fatal'   => FATAL,
-      'unknown' => UNKNOWN
+    LEVELS = ::Hash[
+      "debug"   => DEBUG,
+      "info"    => INFO,
+      "warn"    => WARN,
+      "error"   => ERROR,
+      "fatal"   => FATAL,
+      "unknown" => UNKNOWN
     ].freeze
 
     # @since 0.5.0
@@ -456,7 +270,7 @@ module Hanami
     #   # => {"app":"Hanami","severity":"DEBUG","time":"2017-03-30T13:57:59Z","message":"Hello World"}
     # rubocop:disable Lint/HandleExceptions
     # rubocop:disable Metrics/ParameterLists
-    def initialize(application_name = nil, *args, stream: $stdout, level: DEBUG, formatter: nil, filter: [])
+    def initialize(application_name = nil, *args, stream: $stdout, level: DEBUG, formatter: nil, filter: [], colorizer: nil)
       begin
         Utils::Files.mkdir_p(stream)
       rescue TypeError
@@ -467,8 +281,9 @@ module Hanami
       @level            = _level(level)
       @stream           = stream
       @application_name = application_name
-      @formatter        = Formatter.fabricate(formatter, self.application_name, filter)
+      @formatter        = Formatter.fabricate(formatter, self.application_name, filter, lookup_colorizer(colorizer))
     end
+
     # rubocop:enable Metrics/ParameterLists
     # rubocop:enable Lint/HandleExceptions
 
@@ -500,7 +315,7 @@ module Hanami
     # @api private
     def _application_name_from_namespace
       class_name = self.class.name
-      namespace  = Utils::String.new(class_name).namespace
+      namespace  = Utils::String.namespace(class_name)
 
       class_name != namespace and return namespace
     end
@@ -521,5 +336,18 @@ module Hanami
         LEVELS.fetch(level.to_s.downcase, DEBUG)
       end
     end
+
+    # @since 1.2.0
+    # @api private
+    def lookup_colorizer(colorizer)
+      return NullColorizer.new if colorizer == false
+      colorizer || (tty? ? Colorizer : NullColorizer).new
+    end
+
+    # @since 1.2.0
+    # @api private
+    def tty?
+      @logdev.dev.tty?
+    end
   end
 end

data/lib/hanami/utils/query_string.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module Hanami
+  module Utils
+    # URI query string transformations
+    #
+    # @since 1.2.0
+    module QueryString
+      # Serialize input into a query string
+      #
+      # @param input [Object] the input
+      #
+      # @return [::String] the query string
+      #
+      # @since 1.2.0
+      #
+      # TODO: this is a very basic implementation that needs to be expanded
+      def self.call(input)
+        case input
+        when ::Hash
+          input.to_a.join("=")
+        else
+          input.to_s
+        end
+      end
+    end
+  end
+end

data/lib/hanami/utils/shell_color.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Utils
+    # Shell helper for colorizing STDOUT
+    #
+    # It doesn't check if you're writing to a file or anything, so you have to
+    # check that yourself before using this module.
+    #
+    # @since 1.2.0
+    module ShellColor
+      # Unknown color code error
+      #
+      # @since 1.2.0
+      class UnknownColorCodeError < ::StandardError
+        def initialize(code)
+          super("unknown color code: `#{code.inspect}'")
+        end
+      end
+
+      # Escape codes for terminals to output strings in colors
+      #
+      # @since 1.2.0
+      # @api private
+      COLORS = ::Hash[
+        black:   30,
+        red:     31,
+        green:   32,
+        yellow:  33,
+        blue:    34,
+        magenta: 35,
+        cyan:    36,
+        gray:    37,
+      ].freeze
+
+      # Colorize output
+      # 8 colors available: black, red, green, yellow, blue, magenta, cyan, and gray
+      #
+      # @param input [#to_s] the string to colorize
+      # @param color [Symbol] the color
+      #
+      # @raise [Hanami::Utils::ShellColor::UnknownColorError] if the color code is
+      #   unknown
+      #
+      # @return [String] the colorized string
+      #
+      # @since 1.2.0
+      def self.call(input, color:)
+        "\e[#{color_code(color)}m#{input}\e[0m"
+      end
+
+      # Helper method to translate between color names and terminal escape codes
+      #
+      # @api private
+      # @since 1.2.0
+      #
+      # @raise [Hanami::Utils::ShellColor::UnknownColorError] if the color code is
+      #   unknown
+      def self.color_code(code)
+        COLORS.fetch(code) { raise UnknownColorCodeError.new(code) }
+      end
+    end
+  end
+end

data/lib/hanami/utils/version.rb

@@ -3,6 +3,6 @@ module Hanami
     # Defines the version
     #
     # @since 0.1.0
-    VERSION = '1.2.0.beta2'.freeze
+    VERSION = '1.2.0.rc1'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hanami-utils
 version: !ruby/object:Gem::Version
-  version: 1.2.0.beta2
+  version: 1.2.0.rc1
 platform: ruby
 authors:
 - Luca Guidi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-23 00:00:00.000000000 Z
+date: 2018-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: transproc
@@ -94,6 +94,9 @@ files:
 - lib/hanami-utils.rb
 - lib/hanami/interactor.rb
 - lib/hanami/logger.rb
+- lib/hanami/logger/colorizer.rb
+- lib/hanami/logger/filter.rb
+- lib/hanami/logger/formatter.rb
 - lib/hanami/utils.rb
 - lib/hanami/utils/basic_object.rb
 - lib/hanami/utils/blank.rb
@@ -112,6 +115,8 @@ files:
 - lib/hanami/utils/kernel.rb
 - lib/hanami/utils/load_paths.rb
 - lib/hanami/utils/path_prefix.rb
+- lib/hanami/utils/query_string.rb
+- lib/hanami/utils/shell_color.rb
 - lib/hanami/utils/string.rb
 - lib/hanami/utils/version.rb
 homepage: http://hanamirb.org