k_log 0.0.20 → 0.0.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5ce4190206d26b326f0295241cf8c087c3c56bfc0bb11b4e8dbb6f8d401447f
-  data.tar.gz: 3ed6be809644377525a00658e5f010b32e3979bb031e4d10037a4393c67c47d1
+  metadata.gz: f1791ddbcf6769e1e472c511dd52b4f1d4ddda87c9fba038f8abe17e24bff934
+  data.tar.gz: 511ec8d2758769bdc54822f96390f15764e3055f71d96f84db0085b3a8c70a60
 SHA512:
-  metadata.gz: 133ea34980568cb38ecf8e3b1d9efdf4aa292005b5a67ad9f8282da82200bf42611bb95dfe25bc2f1ee78b7b845cf9af4e65fbf136e0f73867cb07e092699419
-  data.tar.gz: 3606bca839c257f596f6ca6a0fb1e1b6cda1da58c3735ce0857236523c47e8ca13c0ce656936239ea0ffb2ce1c435e62dbd6b68b9f67a3677f1239c9ff0038ca
+  metadata.gz: 680b73d54409a72018e0cbf1ea07df828a86713654afd98fa78739e0b83a8e685eefa14ef56a181529404144b4706c902644a5f96dbf31f79af2abaf893e38e2
+  data.tar.gz: 4e855ad037c22b16a3a6ef8bfbbec6b5b3dfee33a35078d4b2f29cc8a2b62ec9d06ae0ea332c8b58f73d19439e5a5e690d18afb62ec4ff3dee4d39d7dc6b27e0

data/.rubocop.yml

@@ -40,6 +40,8 @@ Layout/LineLength:
   # Ignores annotate output
   IgnoredPatterns: ['\A# \*\*']
   IgnoreCopDirectives: true
+  Exclude:
+    - "**/spec/**/*"
 
 Lint/UnusedMethodArgument:
   AllowUnusedKeywordArguments: true
@@ -61,6 +63,16 @@ Metrics/ClassLength:
 Metrics/ModuleLength:
   Exclude:
     - "**/spec/**/*"
+Metrics/CyclomaticComplexity:
+  Exclude:
+    - "lib/k_log/log_structure.rb"
+Metrics/PerceivedComplexity:
+  Exclude:
+    - "lib/k_log/log_structure.rb"
+Metrics/AbcSize:
+  Exclude:
+    - "lib/k_log/log_structure.rb"
+
 Naming/MemoizedInstanceVariableName:
   Enabled: false
 Naming/VariableNumber:

data/Gemfile

@@ -2,23 +2,18 @@
 
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in handlebars_helpers.gemspec
 gemspec
 
-# group :development do
-#   # Currently conflicts with GitHub actions and so I remove it on push
-#   # pry on steroids
-#   gem 'jazz_fingers'
-#   gem 'pry-coolline', github: 'owst/pry-coolline', branch: 'support_new_pry_config_api'
-# end
-
 group :development, :test do
+  gem 'dry-struct', '~> 1'
+
   gem 'guard-bundler'
   gem 'guard-rspec'
   gem 'guard-rubocop'
   gem 'rake', '~> 12.0'
   gem 'rake-compiler', require: false
   gem 'rspec', '~> 3.0'
+  gem 'rspec-collection_matchers'
   gem 'rubocop'
   gem 'rubocop-rake', require: false
   gem 'rubocop-rspec', require: false

data/lib/k_log/log_formatter.rb

@@ -20,8 +20,10 @@ module KLog
 
       msg = msg.is_a?(String) ? msg : msg.inspect
 
+      # "%<time>s %<severity>s %<message>s\n", {
+
       format(
-        "%<time>s %<severity>s %<message>s\n", {
+        "%<severity>s %<message>s\n", {
           time: Time.now.strftime('%d|%H:%M:%S'),
           severity: severity_value,
           message: msg

data/lib/k_log/log_helper.rb

@@ -43,6 +43,14 @@ module KLog
       green(character * size)
     end
 
+    def self.dynamic_heading(heading, size: 70, type: :heading)
+      return heading(heading, size)           if type == :heading
+      return subheading(heading, size)        if type == :subheading
+      return [section_heading(heading, size)] if %i[section_heading section].include?(type)
+
+      []
+    end
+
     def self.heading(heading, size = 70)
       line = line(size)
 
@@ -69,7 +77,8 @@ module KLog
     def self.section_heading(heading, size = 70)
       brace_open = green('[ ')
       brace_close = green(' ]')
-      line = line(size - heading.length - 4, '-')
+      line_length = size - heading.length - 4
+      line = line_length.positive? ? line(line_length, '-') : ''
 
       # It is important that you set the colour after you have calculated the size
       "#{brace_open}#{heading}#{brace_close}#{green(line)}"
@@ -106,8 +115,60 @@ module KLog
     end
     # rubocop:enable Metrics/CyclomaticComplexity
 
+    def self.red(value)
+      "\033[31m#{value}\033[0m"
+    end
+
     def self.green(value)
       "\033[32m#{value}\033[0m"
     end
+
+    def self.yellow(value)
+      "\033[33m#{value}\033[0m"
+    end
+
+    def self.blue(value)
+      "\033[34m#{value}\033[0m"
+    end
+
+    def self.purple(value)
+      "\033[35m#{value}\033[0m"
+    end
+
+    def self.cyan(value)
+      "\033[36m#{value}\033[0m"
+    end
+
+    def self.grey(value)
+      "\033[37m#{value}\033[0m"
+    end
+
+    def self.bg_red(value)
+      "\033[41m#{value}\033[0m"
+    end
+
+    def self.bg_green(value)
+      "\033[42m#{value}\033[0m"
+    end
+
+    def self.bg_yellow(value)
+      "\033[43m#{value}\033[0m"
+    end
+
+    def self.bg_blue(value)
+      "\033[44m#{value}\033[0m"
+    end
+
+    def self.bg_purple(value)
+      "\033[45m#{value}\033[0m"
+    end
+
+    def self.bg_cyan(value)
+      "\033[46m#{value}\033[0m"
+    end
+
+    def self.bg_grey(value)
+      "\033[47m#{value}\033[0m"
+    end
   end
 end

data/lib/k_log/log_structure.rb

@@ -5,15 +5,26 @@ require 'k_util'
 module KLog
   # Log Structure is flexible logger for working through a complex object graph
   class LogStructure
-    attr_accessor :indent
-    attr_accessor :heading
-    attr_accessor :heading_type
-    attr_accessor :line_width
-    attr_accessor :formatter
-    attr_accessor :skip_array
-
-    attr_accessor :recursion_depth
-    attr_accessor :key_format
+    attr_reader :indent
+    attr_reader :title
+    attr_reader :title_type
+    attr_reader :heading
+    attr_reader :heading_type
+    attr_reader :line_width
+    attr_reader :key_width
+    attr_reader :show_array_count
+    attr_reader :graph
+    attr_reader :formatter
+    attr_reader :convert_data_to
+
+    attr_reader :recursion_depth
+    attr_reader :key_format
+    attr_reader :graph_path
+    attr_reader :graph_node
+
+    attr_reader :lines
+    attr_reader :output_as
+    attr_reader :output_file
 
     # Log a structure
     #
@@ -23,71 +34,135 @@ module KLog
     # @option opts [String] :heading Log heading using logger.dynamic_heading
     # @option opts [String] :heading_type :heading, :subheading, :section_heading
     # @option opts [String] :line_width line width defaults to 80, but can be overridden here
+    # @option opts [String] :key_width key width defaults to 30, but can be overridden here
     # @option opts [String] :formatter is a complex configuration for formatting different data within the structure
+    # @option opts [Symbol] :convert_data_to (:raw, open_struct)
     def initialize(opts)
       @indent           = opts[:indent] || '  '
+      @title            = opts[:title]
+      @title_type       = opts[:title_type] || :heading
+
       @heading          = opts[:heading]
       @heading_type     = opts[:heading_type] || :heading
-      @formatter        = opts[:formatter] || {}
+      puts ':heading should be :title'              if opts[:heading]
+      puts ':heading_type should be :title_type'    if opts[:heading_type]
+
+      @formatter        = opts[:formatter]          || {}
+      @graph            = parse_graph(opts[:graph]  || {})
+      @convert_data_to  = opts[:convert_data_to]    || :raw # by default leave data as is
 
-      @line_width       = opts[:line_width] || 80
-      # @skip_array = opts[:skip_array]
+      @line_width       = opts[:line_width]         || 80
+      @key_width        = opts[:key_width]          || 30
+      @show_array_count = opts[:show_array_count]   || false
+      @output_as        = opts[:output_as]          || [:console]
+      @output_as        = [@output_as]              unless @output_as.is_a?(Array)
+      @output_file      = opts[:output_file]
 
       @recursion_depth  = 0
       @key_format       = nil
+      @graph_path       = []
+      @lines            = []
+
       update_indent_label
     end
 
+    def l
+      @l ||= KLog::LogUtil.new(KLog.logger)
+    end
+
     def log(data)
-      log_heading(heading, heading_type)
+      log_heading(title, title_type) if title
 
-      open_struct_data = KUtil.data.to_open_struct(data)
+      data = convert_data(data)
 
-      log_data(open_struct_data)
+      log_data(data)
+
+      add_line(KLog::LogHelper.line(line_width))
+
+      render_output
+    end
+
+    def content
+      @content ||= lines.join("\n")
+    end
 
-      KLog.logger.line(line_width)
+    def clean_content
+      # remove color escape codes
+      @clean_content ||= content.gsub(/\x1B\[\d*m/, '')
     end
 
-    # Build a sample configuration based on the structure (move to own class)
-    def build_sample_config(_data)
-      # open_struct_data = KUtil.data.to_open_struct(data)
-      {
-        to: :do
-      }
+    def clean_lines
+      # remove color escape codes
+      lines.flat_map { |line| line.gsub(/\x1B\[\d*m/, '').split("\n") }
+    end
+
+    def add_lines(lines)
+      @lines += lines
+    end
+
+    def add_line(line)
+      @lines << line
     end
 
     private
 
-    def build_key_format(key)
-      format_config = @formatter[key]
-      format_config = @formatter[:_root] if format_config.nil? && @recursion_depth.zero?
-      @key_format = KeyFormat.new(format_config)
+    # format_config = @formatter[:_root] if format_config.nil? && @recursion_depth.zero?
+
+    def data_enumerator(data)
+      return data.attributes if data.respond_to?(:attributes)
+
+      data
     end
 
     def log_data(data)
-      data.each_pair do |key, value|
-        build_key_format(key)
-        case value
-        when OpenStruct
-          log_structure(key, value) unless @key_format.ignore?
-        when Array
-          log_array(key, value)     unless @key_format.ignore?
+      data_enumerator(data).each_pair do |k, v|
+        key = k.is_a?(String) ? k.to_sym : k
+
+        graph_path.push(key)
+        @graph_node = GraphNode.for(self, graph, graph_path)
+        # @graph_node.debug
+        # l.kv 'key', "#{key.to_s.ljust(15)}#{graph_node.skip?.to_s.ljust(6)}#{@recursion_depth}"
+
+        if graph_node.skip?
+          # l.kv 'key', 'skipping...'
+          @graph_path.pop
+          next
+        end
+
+        # xxxx.pry if graph_node.pry_at?(:before_value) # 'puts xmen'
+
+        value = graph_node.transform? ? graph_node.transform(v) : v
+
+        # xxxx.pry if graph_node.pry_at?(:after_value) # 'puts xmen'
+        if value.is_a?(OpenStruct) || value.respond_to?(:attributes)
+
+          # l.kv 'go', 'open struct ->'
+          # xxxx.pry if graph_node.pry_at?(:before_structure) # 'puts xmen'
+          log_structure(key, value)
+          # l.kv 'go', 'open struct <-'
+        elsif value.is_a?(Array)
+          # l.kv 'go', 'array ->'
+          log_array(key, value)
+          # l.kv 'go', 'array <-'
         else
-          KLog.logger.kv "#{@indent_label}#{key}", value
+          # l.kv 'go', 'value ->'
+          # xxxx.pry if graph_node.pry_at?(:before_kv) # 'puts xmen'
+          log_heading(graph_node.heading, graph_node.heading_type) if graph_node.heading
+          add_line KLog::LogHelper.kv("#{@indent_label}#{key}", value, key_width)
+          # l.kv 'go', 'value <-'
         end
+
+        # l.line
+        # @graph_node = graph.for_path(graph_path)
+        # l.line
+        @graph_path.pop
       end
       nil
     end
 
     def log_structure(key, value)
-      # This is specifically for k_doc, I should use a configuration instead of this technique
-      if value['rows'].is_a?(Array)
-        # KLog.logger.subheading(key)
-        # opts[:subheading] = key
-        # opts.delete(:subheading)
-      else
-        KLog.logger.kv "#{@indent_label}#{key}", ''
-      end
+      log_heading(graph_node.heading, graph_node.heading_type) if graph_node.heading
+      add_line(KLog::LogHelper.green("#{@indent_label}#{key}"))
       log_child_data(value)
     end
 
@@ -97,22 +172,39 @@ module KLog
       depth_up
     end
 
-    # rubocop:disable Metrics/AbcSize
     def log_array(key, array)
-      # next unless opts[:skip_array].nil?
-      return unless array.length.positive?
+      # xxxx.pry if graph_node.pry_at?(:before_array) # 'puts xmen'
+
+      items = array.clone
+      items.select! { |item| graph_node.filter(item) }  if graph_node.filter?
+      items = items.take(graph_node.take)               if graph_node.limited?
+      items.sort!(&graph_node.sort)                     if graph_node.sort?
+
+      # xxxx.pry if graph_node.pry_at?(:before_array_print) # 'puts xmen'
 
-      log_heading(key_format.heading, key_format.heading_type)
+      return if items.length.zero? && graph_node.skip_empty?
 
-      filter_items = key_format.take_all ? array : array.take(key_format.take)
+      log_heading(graph_node.heading, graph_node.heading_type) if graph_node.heading
 
-      if primitive?(filter_items)
-        KLog.logger.kv "#{indent}#{key}", filter_items.map(&:to_s).join(', ')
+      if primitive?(items)
+        add_line KLog::LogHelper.kv "#{@indent_label}#{key}", items.map(&:to_s).join(', ')
       else
-        tp filter_items, tp_columns(filter_items)
+        table_print items, tp_columns(items)
+
+        # NEED SUPPORT FOR A configured ARRAY COUNT with width and label
+        add_line KLog::LogHelper.kv key.to_s, items.count if show_array_count
       end
+    rescue StandardError => e
+      KLog.logger.exception(e)
+    end
+
+    def table_print(items, columns)
+      io = TablePrintIo.new(self)
+
+      tp.set :io, io
+      tp items, columns
+      tp.clear :io
     end
-    # rubocop:enable Metrics/AbcSize
 
     def primitive?(items)
       item = items.first
@@ -120,14 +212,12 @@ module KLog
     end
 
     def log_heading(heading, heading_type)
-      return unless heading
-
-      KLog.logger.dynamic_heading(heading, size: line_width, type: heading_type)
+      add_lines(KLog::LogHelper.dynamic_heading(heading, size: line_width, type: heading_type))
     end
 
     def tp_columns(items)
       # Use configured array columns
-      return key_format.array_columns if key_format.array_columns
+      return graph_node.columns if graph_node.columns
 
       # Slow but complete list of keys
       # items.flat_map { |v| v.to_h.keys }.uniq
@@ -136,6 +226,7 @@ module KLog
     end
 
     def update_indent_label
+      # puts "indent_label: #{indent} - #{@recursion_depth} - #{(indent * @recursion_depth)}"
       @indent_label = (indent * @recursion_depth)
     end
 
@@ -153,10 +244,56 @@ module KLog
     end
 
     def depth_up
-      update_indent_label
       @recursion_depth = recursion_depth - 1
+      update_indent_label
+    end
+
+    def render_output
+      puts content                            if output_as.include?(:console)
+      File.write(output_file, clean_content)  if output_as.include?(:file) && output_file
+      # content
+    end
+
+    # convert_data_to: :open_struct
+    def convert_data(data)
+      return KUtil.data.to_open_struct(data)  if convert_data_to == :open_struct
+
+      data
     end
 
+    def parse_graph(data)
+      if data.is_a?(Hash)
+        transform_hash = data.each_with_object({}) do |(key, value), new_hash|
+          new_hash[key] = if key == :columns && value.is_a?(Array)
+                            # Don't transform the table_print GEM columns definition as it must stay as a hash
+                            value
+                          else
+                            parse_graph(value)
+                          end
+        end
+
+        return OpenStruct.new(transform_hash.to_h)
+      end
+
+      return data.map { |o| parse_graph(o) }                               if data.is_a?(Array)
+      return parse_graph(data.to_h)                                        if data.respond_to?(:to_h) # hash_convertible?(data)
+
+      # Some primitave type: String, True/False or an ObjectStruct
+      data
+    end
+
+    # def hash_convertible?(value)
+    #   # Nil is a special case, it responds to :to_h but generally
+    #   # you only want to convert nil to {} in specific scenarios
+    #   return false if value.nil?
+
+    #   value.is_a?(Array) ||
+    #     value.is_a?(Hash) ||
+    #     value.is_a?(Struct) ||
+    #     value.is_a?(OpenStruct) ||
+    #     value.respond_to?(:to_h)
+    # end
+
     # Format configuration for a specific key
     #
     # @example Example configuration for key: tables
@@ -165,7 +302,7 @@ module KLog
     #   tables: {
     #     heading: 'Database Tables',
     #     take: :all,
-    #     array_columns: [
+    #     columns: [
     #       :name,
     #       :force,
     #       :primary_key,
@@ -178,36 +315,139 @@ module KLog
     #   }
     # }
     #
-    # format = KeyFormat.new(configuration[:tables])
-    class KeyFormat
+
+    # Override table_print IO stream so that it writes into the structure
+    class TablePrintIo
+      def initialize(log_structure)
+        @log_structure = log_structure
+      end
+
+      def puts(line)
+        @log_structure.add_line(line)
+      end
+    end
+
+    class GraphNode
+      attr_reader   :log_structure
       attr_accessor :config
 
-      def initialize(config)
-        @config = OpenStruct.new(config)
+      class << self
+        def null
+          @null ||= OpenStruct.new
+        end
+
+        def for(log_structure, graph, graph_path)
+          # node_config = graph_path.inject(graph, :send) # (uses deep nesting, but fails when nil is returned) https://stackoverflow.com/questions/15862455/ruby-nested-send
+          # node.nil? ? null : node.send(name) || null
+          node_config = graph_path.reduce(graph) do |node, name|
+            result = node.send(name)
+
+            break null if result.nil?
+
+            result
+          end
+          # puts node_config
+
+          new(log_structure, node_config)
+        end
       end
 
-      def array_columns
-        config.array_columns
+      def initialize(log_structure, config)
+        @log_structure = log_structure
+        @config = config || OpenStruct.new
       end
 
+      # table_print compatible configuration for displaying columns for an array
+      def columns
+        config.columns
+      end
+
+      # Optional heading for the node
       def heading
         config.heading
       end
 
+      # Type of heading [:heading, :subheading, :section]
       def heading_type
-        config.heading_type || :section_heading
+        config.heading_type || :section
       end
 
+      # Node data is to be transformed
+      def transform?
+        config&.transform.respond_to?(:call)
+      end
+
+      # Transform node value
+      def transform(value)
+        config.transform.call(value)
+      end
+
+      # Array rows are filtered
+      def filter?
+        config&.filter.respond_to?(:call)
+      end
+
+      # Array rows are filtered via this predicate
+      def filter(value)
+        config.filter.call(value)
+      end
+
+      # How any array rows to take
       def take
         config.take
       end
 
-      def take_all
-        config.take.nil? || config.take == :all
+      # Array rows are limited, see take
+      def limited?
+        config.take&.is_a?(Integer)
+      end
+
+      # Array rows are sorted using .sort
+      def sort?
+        config&.sort.respond_to?(:call)
+      end
+
+      # Use array.sort?
+      def sort
+        config.sort
+      end
+
+      # Skip this node
+      def skip?
+        config.skip == true
+      end
+
+      # Useful in complex debug scenarios
+      def pry_at
+        config.pry_at || []
       end
 
-      def ignore?
-        config.ignore == true
+      def pry_at?(section)
+        pry_at.include?(section)
+      end
+
+      # Skip empty array node (my be useful for other nodes, but not yet)
+      def skip_empty?
+        config.skip_empty == true
+      end
+
+      def show_array_count
+        log_structure.show_array_count
+      end
+  
+      def debug
+        l = KLog::LogUtil.new(KLog.logger)
+        l.kv('columns', columns) if columns
+        l.kv('heading', heading) if heading
+        l.kv('heading_type', heading_type) if heading_type
+        l.kv('filter?', filter?)
+        l.kv('take', take)
+        l.kv('limited?', limited?)
+        l.kv('sort?', sort?)
+        l.kv('sort', sort)
+        l.kv('skip?', skip?)
+        l.kv('pry_at', pry_at)
+        l.kv('skip_empty?', skip_empty?)
       end
     end
   end

data/lib/k_log/log_util.rb

@@ -75,7 +75,7 @@ module KLog
     def dynamic_heading(heading, size: 70, type: :heading)
       KLog.logger.heading(heading, size)          if type == :heading
       KLog.logger.subheading(heading, size)       if type == :subheading
-      KLog.logger.section_heading(heading, size)  if type == :section_heading
+      KLog.logger.section_heading(heading, size)  if %i[section_heading section].include?(type)
     end
 
     def heading(heading, size = 70)
@@ -148,7 +148,7 @@ module KLog
     # @option opts [String] :heading_type :heading, :subheading, :section_heading
     # @option opts [Boolean] :skip_array Arrays items can be skipped
     def structure(data, **opts)
-      structure = LogStructure.new(**opts)
+      structure = LogStructure.new(opts)
       structure.log(data)
     end
 
@@ -195,11 +195,17 @@ module KLog
     alias ostruct open_struct
     alias o open_struct
 
-    def exception(exception)
+    def exception(exception, short: false, method_info: nil)
       line
 
-      @logger.info(exception.message)
-      @logger.info(exception.backtrace.join("\n"))
+      @logger.info(KLog::LogHelper.bg_red(exception.message))
+
+      @logger.info([method_info.owner.name, method_info.name].join('#')) if method_info
+
+      trace_items = short ? exception.backtrace.select { |row| row.start_with?(Dir.pwd) } : exception.backtrace
+      trace_items = trace_items.map { |row| row.start_with?(Dir.pwd) ? KLog::LogHelper.yellow(row) : KLog::LogHelper.red(row) }
+
+      @logger.info(KLog::LogHelper.yellow(trace_items.join("\n")))
 
       line
     end

data/lib/k_log/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: k_log
 version: !ruby/object:Gem::Version
-  version: 0.0.20
+  version: 0.0.31
 platform: ruby
 authors:
 - David Cruwys
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-08-08 00:00:00.000000000 Z
+date: 2021-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: k_util