k_log 0.0.1

data/hooks/pre-commit

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'English'
+
+# NOTE: you may need change file permissions
+#       chmod +x hooks/pre-commit
+
+exit 0 if ARGV.include?('--no-verify')
+
+warning_keywords = %w[console.log]
+keywords = %w[binding.pry console.dir byebug debugger]
+files_changed = `git diff-index --name-only HEAD --`.split
+
+# puts '----------------------------------------------------------------------'
+# puts remove files changed from the pre-commit checking if they are one of the following files
+# puts '----------------------------------------------------------------------'
+# files_changed = files_changed - ['hooks/pre-commit']
+# files_changed = files_changed - ['hooks/update-version']
+
+# byebug may need to be in these files
+files_changed -= ['Gemfile']
+files_changed -= ['Gemfile.lock']
+files_changed -= ['.gitignore']
+files_changed -= ['README.md']
+
+files_changed = files_changed.reject { |f| f.downcase.end_with?('.json') }
+files_changed = files_changed.reject { |f| f.downcase.end_with?('.yml') }
+
+# ignore files from specific folders
+
+file_groups = files_changed.select do |item|
+  item.start_with?('hooks') # ||
+  # item.start_with?('lib/generators')
+end
+
+files_changed -= file_groups
+
+# remove files that are changed because they are deleted
+files_changed = files_changed.select { |filename| File.file?(filename) }
+
+# puts '----------------------------------------------------------------------'
+# puts 'Files Changed'
+# puts '----------------------------------------------------------------------'
+# puts files_changed
+# puts '----------------------------------------------------------------------'
+
+unless files_changed.length.zero?
+  # puts "#{keywords.join('|')}"
+  # puts "#{files_changed.join(' ')}"
+
+  `git grep -q -E "#{warning_keywords.join('|')}" #{files_changed.join(' ')}`
+
+  if $CHILD_STATUS.exitstatus.zero?
+    puts '' # Check following lines:''
+    puts $CHILD_STATUS.exitstatus
+    files_changed.each do |file|
+      warning_keywords.each do |keyword|
+        # puts "#{keyword} ::: #{file}"
+        `git grep -q -E #{keyword} #{file}`
+        if $CHILD_STATUS.exitstatus.zero?
+          line = `git grep -n #{keyword} #{file} | awk -F ":" '{print $2}'`.split.join(', ')
+          puts "WARNING:\t\033[31m#{file}\033[0m contains #{keyword} at line \033[33m#{line}\033[0m."
+        end
+      end
+    end
+  end
+
+  `git grep -q -E "#{keywords.join('|')}" #{files_changed.join(' ')}`
+
+  if $CHILD_STATUS.exitstatus.zero?
+    puts '' # Check following lines:''
+    puts $CHILD_STATUS.exitstatus
+    files_changed.each do |file|
+      keywords.each do |keyword|
+        # puts "#{keyword} ::: #{file}"
+        `git grep -q -E #{keyword} #{file}`
+        if $CHILD_STATUS.exitstatus.zero?
+          line = `git grep -n #{keyword} #{file} | awk -F ":" '{print $2}'`.split.join(', ')
+          puts "ERROR  :\t\033[31m#{file}\033[0m contains #{keyword} at line \033[33m#{line}\033[0m."
+        end
+      end
+    end
+    puts '# Force commit with --no-verify'
+    exit 1
+  end
+end

data/hooks/update-version

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# NOTE: you may need change file permissions
+#       chmod +x hooks/update-version
+
+exit 1 if ARGV.empty?
+
+version = ARGV[0]
+version = version[1..-1] # revoke 'v' character, e.g. v0.1.1 becomes 0.1.1
+
+namespaces = %w[KLog]
+
+indent = 0
+output = ['# frozen_string_literal: true', '']
+
+namespaces.each do |namespace|
+  output.push "#{'  ' * indent}module #{namespace}"
+  indent += 1
+end
+
+output.push "#{'  ' * indent}VERSION = \'#{version}'"
+indent -= 1
+
+namespaces.each do
+  output.push "#{'  ' * indent}end"
+  indent -= 1
+end
+
+output.push('')
+
+printf "%-25<label>s : %<version>s\n", label: 'GEM VERSION', version: version
+File.open('lib/k_log/version.rb', 'w+') { |f| f.write(output.join("\n")) }

data/k_log.gemspec

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'lib/k_log/version'
+
+Gem::Specification.new do |spec|
+  spec.required_ruby_version  = '>= 2.5'
+  spec.name                   = 'k_log'
+  spec.version                = KLog::VERSION
+  spec.authors                = ['David Cruwys']
+  spec.email                  = ['david@ideasmen.com.au']
+
+  spec.summary                = 'KLog provides console logging helpers and formatters'
+  spec.description            = <<-TEXT
+    KLog provides console logging helpers and formatters
+  TEXT
+  spec.homepage               = 'http://appydave.com/gems/k-log'
+  spec.license                = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.' unless spec.respond_to?(:metadata)
+
+  # spec.metadata['allowed_push_host'] = "Set to 'http://mygemserver.com'"
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/klueless-io/k_log'
+  spec.metadata['changelog_uri'] = 'https://github.com/klueless-io/k_log/commits/master'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the RubyGem files that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{^(test|spec|features)/})
+    end
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+  # spec.extensions    = ['ext/k_log/extconf.rb']
+
+  # spec.add_dependency 'tty-box',         '~> 0.5.0'
+end

data/lib/k_log.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'k_log/version'
+
+module KLog
+  # raise KLog::Error, 'Sample message'
+  class Error < StandardError; end
+
+  # Your code goes here...
+end

data/lib/k_log/log_formatter.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module KDsl
+  module Logger
+    # Styled Log formatter
+    class LogFormatter < ::Logger::Formatter
+      attr_accessor :show_caller
+
+      SEVERITY_TO_COLOR_MAP = {
+        'DEBUG' => '34',
+        'INFO' => '32',
+        'WARN' => '33',
+        'ERROR' => '31',
+        'FATAL' => '37'
+      }.freeze
+
+      def call(severity, _timestamp, _progname, msg)
+        severity = severity.upcase
+
+        color = SEVERITY_TO_COLOR_MAP[severity]
+
+        severity_value = format("\033[#{color}m%<severity>-5.5s\033[0m", { severity: severity })
+
+        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
+    end
+  end
+end

data/lib/k_log/log_helper.rb

@@ -0,0 +1,119 @@
+# 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
+
+    unless section.nil?
+      # Pl.info 'here'
+      @progress_section = section
+    end
+
+    # puts '@progress_position'
+    # puts @progress_position
+    # puts '@progress_section'
+    # puts @progress_section
+
+    section_length = 28
+
+    section = if @progress_section.nil?
+                ' ' * section_length
+              else
+                ' ' + @progress_section.ljust(section_length - 1, ' ')
+              end
+
+    # puts 'section'
+    # puts section
+
+    result = '..' + section + ':' + @progress_position.to_s.rjust(4)
+
+    @progress_position += 1
+
+    result
+  end
+
+  def self.line(size = 70, character = '=')
+    green(character * size)
+  end
+
+  def self.heading(heading, size = 70)
+    line = line(size)
+
+    [
+      line,
+      heading,
+      line
+    ]
+  end
+
+  def self.subheading(heading, size = 70)
+    line = line(size, '-')
+    [
+      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, '-')
+
+    # It is important that you set the colour after you have calculated the size
+    "#{green(heading)}#{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)
+
+  #   info(value)
+  # end
+
+  # 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
+
+    result.push messages if messages.is_a?(String) || messages.is_a?(Integer)
+
+    if messages.is_a? Array
+      messages.each do |message|
+        result.push message
+      end
+    end
+
+    result.push line if include_line
+
+    result
+  end
+  # rubocop:enable Metrics/CyclomaticComplexity
+
+  def self.green(value)
+    "\033[32m#{value}\033[0m"
+  end
+end

data/lib/k_log/log_util.rb

@@ -0,0 +1,332 @@
+# 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
+#
+# I usually alias the call to FormatLoggerUtil by doing L = FormatLoggerUtil
+
+# require_relative 'format_logger'
+# require_relative 'format_logger_helper'
+
+class LogUtil
+  def initialize(logger)
+    @logger = logger
+    @fuck = true
+  end
+
+  # include ActiveSupport::LoggerThreadSafeLevel
+  # include LoggerSilence
+
+  #----------------------------------------------------------------------------------------------------
+  # Standard Accessors that are on the standard rails Logger
+  #----------------------------------------------------------------------------------------------------
+  def debug(value)
+    @logger.debug(value)
+  end
+
+  def info(value)
+    @logger.info(value)
+  end
+
+  def warn(value)
+    @logger.warn(value)
+  end
+
+  def error(value)
+    @logger.error(value)
+  end
+
+  def fatal(value)
+    @logger.fatal(value)
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # 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 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
+
+  # prints out a line to the log
+  def line(size = 70, character: '=')
+    message = LogHelper.line(size, character)
+
+    @logger.info(message)
+  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)
+
+    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)
+
+    info(heading)
+  end
+
+  def block(messages, include_line = true, title: nil)
+    lines = LogHelper.block(messages, include_line, title: title)
+
+    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)
+
+  #   info(value)
+  # end
+
+  def yaml(data, is_line = true)
+    line if is_line
+
+    @logger.info(data.to_yaml) if data.is_a?(Hash)
+
+    @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)
+      end
+    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(', ')
+          else
+            tp value, value.first.to_h.keys
+          end
+        end
+      else
+        L.kv "#{indent}#{key}", value
+      end
+    end
+    nil
+  end
+  alias ostruct open_struct
+  alias o open_struct
+
+  def exception(e)
+    line
+
+    @logger.info(e.message)
+    @logger.info(e.backtrace.join("\n"))
+
+    line
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # Pretty Loggers
+  #----------------------------------------------------------------------------------------------------
+
+  # NOTE: using  pretty_inspect is an existing namespace conflict
+  def pretty_class(instance)
+    c = instance.class
+
+    line
+
+    kv('Full Class', c.name)
+    kv('Module', c.name.deconstantize)
+    kv('Class', c.name.demodulize)
+
+    source_location = c.instance_methods(false).map { |m|
+      c.instance_method(m).source_location.first
+    }.uniq
+
+    begin
+      kv('Source Location', source_location)
+    rescue  => e
+      warn e
+    end
+
+    line
+  end
+
+  # 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[k].each do |childK, childV|
+          kv("#{k}[#{childK}]",childV)
+        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
+    end
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # Internal Methods
+  #----------------------------------------------------------------------------------------------------
+
+  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'
+
+    L.kv('First Name', 'David')
+    L.kv('Last Name', 'Cruwys')
+    L.kv('Age', 45)
+    L.kv('Sex', 'male')
+
+    L.progress(0, 'Section 1')
+    L.progress
+    L.progress
+    save_progress = L.progress
+
+    L.progress(10, 'Section 2')
+    L.progress
+    L.progress
+    L.progress
+
+    L.progress(save_progress, 'Section 1')
+    L.progress
+    L.progress
+    L.progress
+
+    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']
+
+    yaml1 = Hash.new
+    yaml1['title'] = 'Software Architect'
+    yaml1['age'] = 45
+    yaml1['name'] = 'David'
+
+    yaml3 = Hash.new
+    yaml3['title'] = 'Develoer'
+    yaml3['age'] = 20
+    yaml3['name'] = 'Jin'
+
+    L.yaml(yaml1)
+
+    yaml2 = OpenStruct.new
+    yaml2.title = 'Software Architect'
+    yaml2.age = 45
+    yaml2.name = 'David'
+
+    L.yaml(yaml2)
+
+    mixed_yaml_array = [yaml1, yaml2]
+
+    # This fails because we don't correctly pre-process the array
+    L.yaml(mixed_yaml_array)
+
+    hash_yaml_array = [yaml1, yaml3]
+
+    L.yaml(hash_yaml_array)
+
+    begin
+      raise 'Here is an error'
+    rescue StandardError => e
+      L.exception(e)
+    end
+  end
+
+  private
+
+  def debug_multi_lines(lines)
+    lines.each do |line|
+      debug(line)
+    end
+  end
+
+  def info_multi_lines(lines)
+    lines.each do |line|
+      info(line)
+    end
+  end
+
+  def warn_multi_lines(lines)
+    lines.each do |line|
+      warn(line)
+    end
+  end
+
+  def error_multi_lines(lines)
+    lines.each do |line|
+      error(line)
+    end
+  end
+
+  def fatal_multi_lines(lines)
+    lines.each do |line|
+      fatal(line)
+    end
+  end
+end