k_log 0.0.3 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f1e325c47a61e20b484d81ed0a5cec935196f9a58da8a858195538a4c17d1a7
-  data.tar.gz: 936c2725ada3d7c9c74c0d49870f42d822077a528004df89a53ab6e334a94a42
+  metadata.gz: 3ed051548c417927d8f7250f275081ef4782bf285ee88fdc6e99709e6173733d
+  data.tar.gz: 263a07335a08a14068b18161328255e0487cb23497875400140ba818ba6c61da
 SHA512:
-  metadata.gz: cc37b200dbe1ea308738085403d317dbba8d826205b42641c350c2d747c33b00697409eb0b80370b5654ad6d5c130f2ad2206bb6304288ab1d76c9a02ccb9486
-  data.tar.gz: a06dc130e55068e25e57e71af44a6a902d10a950a2a1afe3bbffde67e2e746a9113489a0e84a6356a3f94a33b1bd48efff03faed75c65b0050bacd0c13e213be
+  metadata.gz: ff1c14cec827d4e46afe82b1ab37a526ed089c5ed58631b5be3455cd12feeaf4829b55b64dd85afe7511f387a4c3281b139ce9d3cbddcc5867dde483cabdfc97
+  data.tar.gz: 9c92c027d93527b7c62c935f6017eb6e7db9893fa85a579b13032fbc36e70f39a49090685b77f3a483e2247245b00e9021fcdf5d4496f9779cef4dbeed6f7ab3

data/README.md

@@ -2,6 +2,8 @@
 
 > K Log provides console logging helpers and formatters
 
+This code is old and probably needs to be written differently, but it solves my problem of having formatted console logging within different Apps and Gems that I write.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -62,14 +64,18 @@ L.kv('Last Name', 'Cruwys')
 L.kv('Age', 45)
 L.kv('Sex', 'male')
 
-L.line
-L.line(20)
-L.line(20, character: '-')
-
 L.heading('Heading')
 L.subheading('Sub Heading')
+
+L.block ['Line 1', 12, 'Line 3', true, 'Line 5']
+
+L.progress(0, 'Section 1')
+L.progress
+L.progress
 ```
 
+![Usage](usage.png)
+
 ## Development
 
 Checkout the repo
@@ -80,24 +86,13 @@ git clone klueless-io/k_log
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests.
 
-You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-```bash
-bin/console
-
-Aaa::Bbb::Program.execute()
-# => ""
-```
-
 `k_log` is setup with Guard, run `guard`, this will watch development file changes and run tests automatically, if successful, it will then run rubocop for style quality.
 
 To release a new version, update the version number in `version.rb`, build the gem and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ```bash
-gem build
-gem push rspec-usecases-?.?.??.gem
-# or push the latest gem
-ls *.gem | sort -r | head -1 | xargs gem push
+rake publish
+rake clean
 ```
 
 ## Contributing

data/STORIES.md

@@ -12,22 +12,15 @@ As a Developer, I need formatted console logs, so that information presents clea
 
 - A range of helper methods that write formatted log entries to the console
 
-### Tasks next on list
+## Stories and tasks
+
+### Tasks - completed
 
 Setup RubyGems and RubyDoc
 
 - Build and deploy gem to [rubygems.org](https://rubygems.org/gems/k_log)
 - Attach documentation to [rubydoc.info](https://rubydoc.info/github/to-do-/k_log/master)
 
-Setup GitHub Action (test and lint)
-
-- Setup Rspec action
-- Setup RuboCop action
-
-## Stories and tasks
-
-### Tasks - completed
-
 Setup project management, requirement and SCRUM documents
 
 - Setup readme file
@@ -35,6 +28,11 @@ Setup project management, requirement and SCRUM documents
 - Setup a project backlog
 - Setup an examples/usage document
 
+Setup GitHub Action (test and lint)
+
+- Setup Rspec action
+- Setup RuboCop action
+
 Setup new Ruby GEM
 
 - Build out a standard GEM structure

data/hooks/pre-commit

@@ -8,7 +8,7 @@ require 'English'
 
 exit 0 if ARGV.include?('--no-verify')
 
-warning_keywords = %w[console.log]
+warning_keywords = %w[]
 keywords = %w[binding.pry console.dir byebug debugger]
 files_changed = `git diff-index --name-only HEAD --`.split
 
@@ -23,7 +23,7 @@ files_changed -= ['Gemfile']
 files_changed -= ['Gemfile.lock']
 files_changed -= ['.gitignore']
 
-files_changed = files_changed.reject { |f| f.downcase.end_with?('.MD') }
+files_changed = files_changed.reject { |f| f.downcase.end_with?('.mds') }
 files_changed = files_changed.reject { |f| f.downcase.end_with?('.json') }
 files_changed = files_changed.reject { |f| f.downcase.end_with?('.yml') }
 

data/lib/k_log.rb

@@ -1,10 +1,23 @@
 # frozen_string_literal: true
 
+require 'logger'
 require 'k_log/version'
+require 'k_log/log_formatter'
+require 'k_log/log_helper'
+require 'k_log/log_util'
 
+# Simple console log helpers
 module KLog
   # raise KLog::Error, 'Sample message'
   class Error < StandardError; end
 
-  # Your code goes here...
+  class << self
+    attr_accessor :logger
+  end
 end
+
+# KLog.logger = Logger.new($stdout)
+# KLog.logger.level = Logger::DEBUG
+# KLog.logger.formatter = KLog::LogFormatter.new
+
+# L = KLog::LogUtil.new(KLog.logger)

data/lib/k_log/log_formatter.rb

@@ -1,36 +1,32 @@
 # frozen_string_literal: true
 
-module KDsl
-  module Logger
-    # Styled Log formatter
-    class LogFormatter < ::Logger::Formatter
-      attr_accessor :show_caller
+module KLog
+  # Styled Log formatter
+  class LogFormatter < ::Logger::Formatter
+    SEVERITY_TO_COLOR_MAP = {
+      'DEBUG' => '34',
+      'INFO' => '32',
+      'WARN' => '33',
+      'ERROR' => '31',
+      'FATAL' => '37'
+    }.freeze
 
-      SEVERITY_TO_COLOR_MAP = {
-        'DEBUG' => '34',
-        'INFO' => '32',
-        'WARN' => '33',
-        'ERROR' => '31',
-        'FATAL' => '37'
-      }.freeze
+    def call(severity, _timestamp, _prog_name, msg)
+      severity = severity.upcase
 
-      def call(severity, _timestamp, _progname, msg)
-        severity = severity.upcase
+      color = SEVERITY_TO_COLOR_MAP[severity]
 
-        color = SEVERITY_TO_COLOR_MAP[severity]
+      severity_value = format("\033[#{color}m%<severity>-5.5s\033[0m", { severity: severity })
 
-        severity_value = format("\033[#{color}m%<severity>-5.5s\033[0m", { severity: severity })
+      msg = msg.is_a?(String) ? msg : msg.inspect
 
-        msg = msg.is_a?(String) ? msg : msg.inspect
-
-        format(
-          "%<time>s %<severity>s %<message>s\n", {
-            time: Time.now.strftime('%d|%H:%M:%S'),
-            severity: severity_value,
-            message: msg
-          }
-        )
-      end
+      format(
+        "%<time>s %<severity>s %<message>s\n", {
+          time: Time.now.strftime('%d|%H:%M:%S'),
+          severity: severity_value,
+          message: msg
+        }
+      )
     end
   end
 end

data/lib/k_log/log_helper.rb

@@ -1,119 +1,113 @@
 # frozen_string_literal: true
 
-# Log Helper is an internal class that takes care of a lot of the formating of different content types
-# e.g key/values, lines, progress counters and headings
-# it is different to the formatter becuase the formatter is used by Rails Logger to change the output stream style and format
-class LogHelper
-  @progress_section = ''
-  @progress_position = 0
-
-  class << self
-    attr_accessor :progress_position
-    attr_accessor :progress_section
-  end
-
-  def self.kv(key, value, key_width = 30)
-    "#{green(key.to_s.ljust(key_width))}: #{value}"
-  end
-
-  def self.progress(pos = nil, section = nil)
-    @progress_position = pos.nil? ? @progress_position : pos
+# Log Helper is an internal class that takes care of a lot of the formatting
+# of different content types e.g key/values, lines, progress counters and headings
+# it is different to the formatter because the formatter is used by Rails Logger
+# to change the output stream style and format
+module KLog
+  # Simple console log helpers
+  class LogHelper
+    @progress_section = ''
+    @progress_position = 0
+
+    class << self
+      attr_accessor :progress_position
+      attr_accessor :progress_section
+    end
 
-    unless section.nil?
-      # Pl.info 'here'
-      @progress_section = section
+    def self.kv(key, value, key_width = 30)
+      "#{green(key.to_s.ljust(key_width))}: #{value}"
     end
 
-    # puts '@progress_position'
-    # puts @progress_position
-    # puts '@progress_section'
-    # puts @progress_section
+    def self.progress(pos = nil, section = nil)
+      @progress_position = pos.nil? ? @progress_position : pos
 
-    section_length = 28
+      @progress_section = section unless section.nil?
 
-    section = if @progress_section.nil?
-                ' ' * section_length
-              else
-                ' ' + @progress_section.ljust(section_length - 1, ' ')
-              end
+      section_length = 28
 
-    # puts 'section'
-    # puts section
+      section = if @progress_section.nil?
+                  ' ' * section_length
+                else
+                  " #{@progress_section.ljust(section_length - 1, ' ')}"
+                end
 
-    result = '..' + section + ':' + @progress_position.to_s.rjust(4)
+      result = "..#{section}:#{@progress_position.to_s.rjust(4)}"
 
-    @progress_position += 1
+      @progress_position += 1
 
-    result
-  end
-
-  def self.line(size = 70, character = '=')
-    green(character * size)
-  end
+      result
+    end
 
-  def self.heading(heading, size = 70)
-    line = line(size)
+    def self.line(size = 70, character = '=')
+      green(character * size)
+    end
 
-    [
-      line,
-      heading,
-      line
-    ]
-  end
+    def self.heading(heading, size = 70)
+      line = line(size)
 
-  def self.subheading(heading, size = 70)
-    line = line(size, '-')
-    [
-      line,
-      heading,
-      line
-    ]
-  end
+      [
+        line,
+        heading,
+        line
+      ]
+    end
 
-  # A section heading
-  #
-  # example:
-  # [ I am a heading ]----------------------------------------------------
-  def self.section_heading(heading, size = 70)
-    heading = "[ #{heading} ]"
-    line = line(size - heading.length, '-')
+    def self.subheading(heading, size = 70)
+      line = line(size, '-')
+      [
+        line,
+        heading,
+        line
+      ]
+    end
 
-    # It is important that you set the colour after you have calculated the size
-    "#{green(heading)}#{line}"
-  end
+    # A section heading
+    #
+    # example:
+    # [ I am a heading ]----------------------------------------------------
+    def self.section_heading(heading, size = 70)
+      brace_open = green('[ ')
+      brace_close = green(' ]')
+      line = line(size - heading.length - 4, '-')
+
+      # It is important that you set the colour after you have calculated the size
+      "#{brace_open}#{heading}#{brace_close}#{green(line)}"
+    end
 
-  # :sql_array should be an array with SQL and values
-  # example: L.sql(["name = :name and group_id = :value OR parent_id = :value", name: "foo'bar", value: 4])
-  # def sql(sql_array)
-  #   value = ActiveRecord::Base.send(:sanitize_sql_array, sql_array)
+    # :sql_array should be an array with SQL and values
+    # example: L.sql(["name = :name and group_id = :value OR parent_id = :value", name: "foo'bar", value: 4])
+    # def sql(sql_array)
+    #   value = ActiveRecord::Base.send(:sanitize_sql_array, sql_array)
 
-  #   info(value)
-  # end
+    #   info(value)
+    # end
 
-  # rubocop:disable Metrics/CyclomaticComplexity
-  def self.block(messages, include_line = true, title: nil)
-    result = include_line ? [line] : []
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def self.block(messages, include_line: true, title: nil)
+      result = include_line ? [line] : []
 
-    unless title.nil?
-      result.push(title)
-      result.push(line(70, ','))
-    end
+      unless title.nil?
+        result.push(title)
+        result.push(line(70, ','))
+      end
 
-    result.push messages if messages.is_a?(String) || messages.is_a?(Integer)
+      result.push messages if messages.is_a?(String) || messages.is_a?(Integer)
 
-    if messages.is_a? Array
-      messages.each do |message|
-        result.push message
+      if messages.is_a? Array
+        messages.each do |message|
+          result.push message
+        end
       end
-    end
 
-    result.push line if include_line
+      result.push line if include_line
 
-    result
-  end
-  # rubocop:enable Metrics/CyclomaticComplexity
+      result
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
 
-  def self.green(value)
-    "\033[32m#{value}\033[0m"
+    def self.green(value)
+      "\033[32m#{value}\033[0m"
+    end
   end
 end

data/lib/k_log/log_util.rb

@@ -1,332 +1,354 @@
 # frozen_string_literal: true
 
-# Format Logger Util provides static helper methods that delegate responsibility to the underlying
-# Format Logger, you can use the Util instead Rails.logger so that you have access to IDE intellisense around
-# available methods and so that you can use the same logger calls from controllers/models which normally have
-# access to to a logger variable and services which do not have access to a logger varialbe
+# Format Logger Util provides static helper methods that delegate responsibility
+# to the underlying Format Logger, you can use the Util instead Rails.logger so
+# that you have access to IDE intellisense around available methods and so you
+# can use the same logger calls from controllers/models which normally have
+# access to to a logger variable and services which do not have access to a
+# logger variable
 #
-# I usually alias the call to FormatLoggerUtil by doing L = FormatLoggerUtil
+# I usually alias the call to LogUtil by doing L = LogUtil
 
 # require_relative 'format_logger'
 # require_relative 'format_logger_helper'
 
-class LogUtil
-  def initialize(logger)
-    @logger = logger
-    @fuck = true
-  end
+module KLog
+  # Simple console log helpers
+  class LogUtil
+    def initialize(logger)
+      @logger = logger
+    end
 
-  # include ActiveSupport::LoggerThreadSafeLevel
-  # include LoggerSilence
+    # include ActiveSupport::LoggerThreadSafeLevel
+    # include LoggerSilence
 
-  #----------------------------------------------------------------------------------------------------
-  # Standard Accessors that are on the standard rails Logger
-  #----------------------------------------------------------------------------------------------------
-  def debug(value)
-    @logger.debug(value)
-  end
+    #----------------------------------------------------------------------------------------------------
+    # Standard Accessors that are on the standard rails Logger
+    #----------------------------------------------------------------------------------------------------
+    def debug(value)
+      @logger.debug(value)
+    end
 
-  def info(value)
-    @logger.info(value)
-  end
+    def info(value)
+      @logger.info(value)
+    end
 
-  def warn(value)
-    @logger.warn(value)
-  end
+    def warn(value)
+      @logger.warn(value)
+    end
 
-  def error(value)
-    @logger.error(value)
-  end
+    def error(value)
+      @logger.error(value)
+    end
 
-  def fatal(value)
-    @logger.fatal(value)
-  end
+    def fatal(value)
+      @logger.fatal(value)
+    end
 
-  #----------------------------------------------------------------------------------------------------
-  # Helper Log output Methods
-  #----------------------------------------------------------------------------------------------------
+    #----------------------------------------------------------------------------------------------------
+    # Helper Log output Methods
+    #----------------------------------------------------------------------------------------------------
 
-  # Write a Key/Value Pair
-  def kv(key, value, key_width = 30)
-    message = LogHelper.kv(key, value, key_width)
-    @logger.info(message)
-  end
+    # Write a Key/Value Pair
+    def kv(key, value, key_width = 30)
+      message = LogHelper.kv(key, value, key_width)
+      @logger.info(message)
+    end
 
-  # Write a progress point, progress will update on it's own
-  def progress(pos = nil, section = nil)
-    message = LogHelper.progress(pos, section)
-    # @logger.debug(message)
-    @logger.info(message)
+    # Write a progress point, progress will update on it's own
+    def progress(pos = nil, section = nil)
+      message = LogHelper.progress(pos, section)
+      # @logger.debug(message)
+      @logger.info(message)
 
-    LogHelper.progress_position
-  end
+      LogHelper.progress_position
+    end
 
-  # prints out a line to the log
-  def line(size = 70, character: '=')
-    message = LogHelper.line(size, character)
+    # prints out a line to the log
+    def line(size = 70, character: '=')
+      message = LogHelper.line(size, character)
 
-    @logger.info(message)
-  end
+      @logger.info(message)
+    end
 
-  def heading(heading, size = 70)
-    lines = LogHelper.heading(heading, size)
-    info_multi_lines(lines)
-  end
+    def heading(heading, size = 70)
+      lines = LogHelper.heading(heading, size)
+      info_multi_lines(lines)
+    end
 
-  def subheading(heading, size = 70)
-    lines = LogHelper.subheading(heading, size)
+    def subheading(heading, size = 70)
+      lines = LogHelper.subheading(heading, size)
 
-    info_multi_lines(lines)
-  end
+      info_multi_lines(lines)
+    end
 
-  # A section heading
-  #
-  # example:
-  # [ I am a heading ]----------------------------------------------------
-  def section_heading(heading, size = 70)
-    heading = LogHelper.section_heading(heading, size)
+    # A section heading
+    #
+    # example:
+    # [ I am a heading ]----------------------------------------------------
+    def section_heading(heading, size = 70)
+      heading = LogHelper.section_heading(heading, size)
 
-    info(heading)
-  end
+      info(heading)
+    end
 
-  def block(messages, include_line = true, title: nil)
-    lines = LogHelper.block(messages, include_line, title: title)
+    def block(messages, include_line: true, title: nil)
+      lines = LogHelper.block(messages, include_line: include_line, title: title)
 
-    info_multi_lines(lines)
-  end
+      info_multi_lines(lines)
+    end
 
-  # # :sql_array should be an array with SQL and values or with SQL and Hash
-  # # example:
-  # #   L.sql(["name = :name and group_id = :value OR parent_id = :value", name: "foo'bar", value: 4])
-  # #   L.sql([sql_exact_match_skills_in_use, {names: self.segments_container.segment_values}])
-  # def sql(sql_array)
-  #   value = ActiveRecord::Base.send(:sanitize_sql_array, sql_array)
+    # # :sql_array should be an array with SQL and values or with SQL and Hash
+    # # example:
+    # #   L.sql(["name = :name and group_id = :value OR parent_id = :value", name: "foo'bar", value: 4])
+    # #   L.sql([sql_exact_match_skills_in_use, {names: self.segments_container.segment_values}])
+    # def sql(sql_array)
+    #   value = ActiveRecord::Base.send(:sanitize_sql_array, sql_array)
 
-  #   info(value)
-  # end
+    #   info(value)
+    # end
 
-  def yaml(data, is_line = true)
-    line if is_line
+    def yaml(data, is_line: true)
+      require 'yaml'
+      line if is_line
 
-    @logger.info(data.to_yaml) if data.is_a?(Hash)
+      @logger.info(data.to_yaml) if data.is_a?(Hash)
 
-    @logger.info(data.marshal_dump.to_yaml) if data.is_a?(OpenStruct)
+      @logger.info(data.marshal_dump.to_yaml) if data.is_a?(OpenStruct)
 
-    if data.is_a? Array
-      data.each do |d|
-        @logger.info(d.to_yaml)
+      if data.is_a? Array
+        data.each do |d|
+          @logger.info(d.to_yaml)
+        end
       end
-    end
 
-    line if is_line
-  end
+      line if is_line
+    end
 
-  def json(data)
-    @logger.info(JSON.pretty_generate(data))
-  end
-  alias j json
-
-  def open_struct(data, indent = '', **opts)
-    data.each_pair do |key, value|
-      if value.is_a?(OpenStruct)
-        if value['rows'].is_a?(Array)
-          # L.subheading(key)
-          opts[:subheading] = key
-          open_struct(value, indent, **opts)
-          opts.delete(:subheading)
-        else
-          L.kv "#{indent}#{key}", ''
-          indent = "#{indent}  "
-          open_struct(value, indent, **opts)
-          indent = indent.chomp('  ')
-        end
-      elsif value.is_a?(Array)
-        next if opts[:skip_array].present?
-        # puts LogHelper.subheading(key, 88)# if opts[:subheading].present?
-        puts LogHelper.subheading(opts[:subheading], 88) if opts[:subheading].present?
-        if value.length > 0
-          if value.first.is_a?(String)
-            L.kv "#{indent}#{key}", value.join(', ')
+    def json(data)
+      @logger.info(JSON.pretty_generate(data))
+    end
+    alias j json
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/AbcSize
+    def open_struct(data, indent = '', **opts)
+      data.each_pair do |key, value|
+        case value
+        when OpenStruct
+          if value['rows'].is_a?(Array)
+            # L.subheading(key)
+            opts[:subheading] = key
+            open_struct(value, indent, **opts)
+            opts.delete(:subheading)
           else
-            tp value, value.first.to_h.keys
+            L.kv "#{indent}#{key}", ''
+            indent = "#{indent}  "
+            open_struct(value, indent, **opts)
+            indent = indent.chomp('  ')
           end
+        when Array
+          next unless opts[:skip_array].nil?
+
+          # puts LogHelper.subheading(key, 88)# unless opts[:subheading].nil?
+          puts LogHelper.subheading(opts[:subheading], 88) unless opts[:subheading].nil?
+
+          if value.length.positive?
+            if value.first.is_a?(String)
+              L.kv "#{indent}#{key}", value.join(', ')
+            else
+              tp value, value.first.to_h.keys
+            end
+          end
+        else
+          L.kv "#{indent}#{key}", value
         end
-      else
-        L.kv "#{indent}#{key}", value
       end
+      nil
     end
-    nil
-  end
-  alias ostruct open_struct
-  alias o open_struct
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/AbcSize
+    alias ostruct open_struct
+    alias o open_struct
 
-  def exception(e)
-    line
+    def exception(exception)
+      line
 
-    @logger.info(e.message)
-    @logger.info(e.backtrace.join("\n"))
+      @logger.info(exception.message)
+      @logger.info(exception.backtrace.join("\n"))
 
-    line
-  end
+      line
+    end
+
+    #----------------------------------------------------------------------------------------------------
+    # Pretty Loggers
+    #----------------------------------------------------------------------------------------------------
 
-  #----------------------------------------------------------------------------------------------------
-  # Pretty Loggers
-  #----------------------------------------------------------------------------------------------------
+    # NOTE: using  pretty_inspect is an existing namespace conflict
+    # rubocop:disable Metrics/AbcSize
+    def pretty_class(instance)
+      c = instance.class
 
-  # NOTE: using  pretty_inspect is an existing namespace conflict
-  def pretty_class(instance)
-    c = instance.class
+      line
 
-    line
+      kv('Full Class', c.name)
+      kv('Module', c.name.deconstantize)
+      kv('Class', c.name.demodulize)
 
-    kv('Full Class', c.name)
-    kv('Module', c.name.deconstantize)
-    kv('Class', c.name.demodulize)
+      source_location = c.instance_methods(false).map do |m|
+        c.instance_method(m).source_location.first
+      end.uniq
 
-    source_location = c.instance_methods(false).map { |m|
-      c.instance_method(m).source_location.first
-    }.uniq
+      begin
+        kv('Source Location', source_location)
+      rescue StandardError => e
+        warn e
+      end
 
-    begin
-      kv('Source Location', source_location)
-    rescue  => e
-      warn e
+      line
     end
+    # rubocop:enable Metrics/AbcSize
 
-    line
-  end
+    # NOTE: using  pretty_inspect is an existing namespace conflict
+    def pretty_params(params)
+      line
 
-  # NOTE: using  pretty_inspect is an existing namespace conflict
-  def pretty_params(params)
-    line
+      params.each do |k, v|
+        if params[k].is_a?(Hash)
 
-    params.each do |k,v|
-      if (params[k].is_a?(Hash))
+          params[k].each do |child_k, child_v|
+            kv("#{k}[#{child_k}]", child_v)
+          end
 
-        params[k].each do |childK, childV|
-          kv("#{k}[#{childK}]",childV)
+        else
+          kv(k, v)
         end
-
-      else
-        kv(k, v)
       end
-    end
-
-    line
-  end
 
-  def help_all_symbols
-    # Produces a lot of data, need some sort of filter I think before this is useful
-    Symbol.all_symbols.each do |s|
-      info s
-      # debug s
+      line
     end
-  end
 
-  #----------------------------------------------------------------------------------------------------
-  # Internal Methods
-  #----------------------------------------------------------------------------------------------------
+    def help_all_symbols
+      # Produces a lot of data, need some sort of filter I think before this is useful
+      Symbol.all_symbols.each do |s|
+        info s
+        # debug s
+      end
+    end
 
-  def self.samples
-    L.debug 'some debug message'
-    L.info 'some info message'
-    L.warn 'some warning message'
-    L.error 'some error message'
-    L.fatal 'some fatal message'
+    #----------------------------------------------------------------------------------------------------
+    # Internal Methods
+    #----------------------------------------------------------------------------------------------------
 
-    L.kv('First Name', 'David')
-    L.kv('Last Name', 'Cruwys')
-    L.kv('Age', 45)
-    L.kv('Sex', 'male')
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def self.examples
+      examples_simple
+      # examples_complex
+    end
 
-    L.progress(0, 'Section 1')
-    L.progress
-    L.progress
-    save_progress = L.progress
+    def self.examples_simple
+      L.debug 'some debug message'
+      L.info 'some info message'
+      L.warn 'some warning message'
+      L.error 'some error message'
+      L.fatal 'some fatal message'
+
+      L.kv('First Name', 'David')
+      L.kv('Last Name', 'Cruwys')
+      L.kv('Age', 45)
+      L.kv('Sex', 'male')
+
+      L.heading('Heading')
+      L.subheading('Sub Heading')
+      L.section_heading('Section Heading')
+    end
 
-    L.progress(10, 'Section 2')
-    L.progress
-    L.progress
-    L.progress
+    def self.examples_complex
+      L.block ['Line 1', 12, 'Line 3', true, 'Line 5']
 
-    L.progress(save_progress, 'Section 1')
-    L.progress
-    L.progress
-    L.progress
+      L.progress(0, 'Section 1')
+      L.progress
+      L.progress
+      save_progress = L.progress
 
-    L.line
-    L.line(20)
-    L.line(20, character: '-')
+      L.progress(10, 'Section 2')
+      L.progress
+      L.progress
+      L.progress
 
-    L.heading('Heading')
-    L.subheading('Sub Heading')
+      L.progress(save_progress, 'Section 1')
+      L.progress
+      L.progress
+      L.progress
 
-    L.block ['Line 1', 12, 'Line 3', true,'Line 5']
+      L.line
+      L.line(20)
+      L.line(20, character: '-')
 
-    yaml1 = Hash.new
-    yaml1['title'] = 'Software Architect'
-    yaml1['age'] = 45
-    yaml1['name'] = 'David'
+      yaml1 = {}
+      yaml1['title'] = 'Software Architect'
+      yaml1['age'] = 45
+      yaml1['name'] = 'David'
 
-    yaml3 = Hash.new
-    yaml3['title'] = 'Develoer'
-    yaml3['age'] = 20
-    yaml3['name'] = 'Jin'
+      yaml3 = {}
+      yaml3['title'] = 'Developer'
+      yaml3['age'] = 20
+      yaml3['name'] = 'Jin'
 
-    L.yaml(yaml1)
+      L.yaml(yaml1)
 
-    yaml2 = OpenStruct.new
-    yaml2.title = 'Software Architect'
-    yaml2.age = 45
-    yaml2.name = 'David'
+      yaml2 = OpenStruct.new
+      yaml2.title = 'Software Architect'
+      yaml2.age = 45
+      yaml2.name = 'David'
 
-    L.yaml(yaml2)
+      L.yaml(yaml2)
 
-    mixed_yaml_array = [yaml1, yaml2]
+      mixed_yaml_array = [yaml1, yaml2]
 
-    # This fails because we don't correctly pre-process the array
-    L.yaml(mixed_yaml_array)
+      # This fails because we don't correctly pre-process the array
+      L.yaml(mixed_yaml_array)
 
-    hash_yaml_array = [yaml1, yaml3]
+      hash_yaml_array = [yaml1, yaml3]
 
-    L.yaml(hash_yaml_array)
+      L.yaml(hash_yaml_array)
 
-    begin
-      raise 'Here is an error'
-    rescue StandardError => e
-      L.exception(e)
+      begin
+        raise 'Here is an error'
+      rescue StandardError => e
+        L.exception(e)
+      end
     end
-  end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
-  private
+    private
 
-  def debug_multi_lines(lines)
-    lines.each do |line|
-      debug(line)
+    def debug_multi_lines(lines)
+      lines.each do |line|
+        debug(line)
+      end
     end
-  end
 
-  def info_multi_lines(lines)
-    lines.each do |line|
-      info(line)
+    def info_multi_lines(lines)
+      lines.each do |line|
+        info(line)
+      end
     end
-  end
 
-  def warn_multi_lines(lines)
-    lines.each do |line|
-      warn(line)
+    def warn_multi_lines(lines)
+      lines.each do |line|
+        warn(line)
+      end
     end
-  end
 
-  def error_multi_lines(lines)
-    lines.each do |line|
-      error(line)
+    def error_multi_lines(lines)
+      lines.each do |line|
+        error(line)
+      end
     end
-  end
 
-  def fatal_multi_lines(lines)
-    lines.each do |line|
-      fatal(line)
+    def fatal_multi_lines(lines)
+      lines.each do |line|
+        fatal(line)
+      end
     end
   end
 end

data/lib/k_log/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module KLog
-  VERSION = '0.0.3'
+  VERSION = '0.0.9'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: k_log
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.9
 platform: ruby
 authors:
 - David Cruwys
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-03-30 00:00:00.000000000 Z
+date: 2021-04-01 00:00:00.000000000 Z
 dependencies: []
 description: "    KLog provides console logging helpers and formatters\n"
 email:
@@ -42,6 +42,7 @@ files:
 - lib/k_log/log_helper.rb
 - lib/k_log/log_util.rb
 - lib/k_log/version.rb
+- usage.png
 homepage: http://appydave.com/gems/k-log
 licenses:
 - MIT