k_log 0.0.19 → 0.0.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 243999c48416e082085f9c72519cd2cc97bb8585389ee6848592f18dc2cfc6bd
-  data.tar.gz: '009abfdd9b635d89f6e31f8197516f0dd612ce14adc9dfb7f005c9a9da458684'
+  metadata.gz: 328dd6fd19c8872158c3de15cbcb0bc2cf222ca2124b8d03ce81a81040cd1411
+  data.tar.gz: f44defe61b5895b2505725c2cbad5c27c45c93e155e25460a85d1a083f1cb775
 SHA512:
-  metadata.gz: f19cf492a22aaf8dbc89dcd9246aacc5732e3db7844d17030d63091e672c4fb201d11c221bbe24450cb1d8745b16d8b70bb21994cc821387ee703aaea4bbc69f
-  data.tar.gz: f0355d0438831db47d1ec390ba7d336b763d76f8d1d23f9520c98a1641901f0114c9961e9ac5d158daa8cddf5658782c6311721aeea5f01cd6dbe7ba24a80c80
+  metadata.gz: 0753d0d203b0673a2526368fa92a6cd6fc0c7ba42f6d425dbaba54b489b9db8e8865bbba2a1b6c22804c6e47b74e1f885b1cb11c85cb9c922fb99d34c30ea21d
+  data.tar.gz: 436f881ffb78b39ded0f7d2649712286c74c39e104991b8fd28cfc7b7dc7417c91f64030d82ab9a54bb3d17ce6d6ae7c64bfe2ccc955b2ccff6f71b43d5dd72e

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/k_log.gemspec

@@ -38,6 +38,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
   # spec.extensions    = ['ext/k_log/extconf.rb']
 
+  spec.add_dependency 'k_util', '~> 0'
   spec.add_dependency 'table_print', '~> 1.5.7'
   # spec.add_dependency 'tty-box',         '~> 0.5.0'
 end

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

@@ -0,0 +1,436 @@
+# frozen_string_literal: true
+
+require 'k_util'
+
+module KLog
+  # Log Structure is flexible logger for working through a complex object graph
+  class LogStructure
+    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
+    #
+    # Can handle Hash, Array, OpenStruct, Struct, DryStruct, Hash convertible custom classes
+    #
+    # @option opts [String] :indent Indent with string, defaults to '  '
+    # @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
+    def initialize(opts)
+      @indent           = opts[:indent] || '  '
+      @title            = opts[:title]
+      @title_type       = opts[:title_type] || :heading
+
+      @heading          = opts[:heading]
+      @heading_type     = opts[:heading_type] || :heading
+      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
+      @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(title, title_type) if title
+
+      data = convert_data(data)
+
+      log_data(data)
+
+      add_line(KLog::LogHelper.line(line_width))
+
+      render_output
+    end
+
+    def content
+      @content ||= lines.join("\n")
+    end
+
+    def clean_content
+      # remove color escape codes
+      @clean_content ||= content.gsub(/\x1B\[\d*m/, '')
+    end
+
+    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
+
+    # 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_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)
+        # 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
+
+        'puts xmen' if graph_node.pry_at?(:before_value)
+
+        value = graph_node.transform? ? graph_node.transform(v) : v
+
+        'puts xmen' if graph_node.pry_at?(:after_value)
+        if value.is_a?(OpenStruct) || value.respond_to?(:attributes)
+
+          # l.kv 'go', 'open struct ->'
+          'puts xmen' if graph_node.pry_at?(:before_structure)
+          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
+          # l.kv 'go', 'value ->'
+          'puts xmen' if graph_node.pry_at?(:before_kv)
+          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)
+      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
+
+    def log_child_data(value)
+      depth_down
+      log_data(value)
+      depth_up
+    end
+
+    def log_array(key, array)
+      'puts xmen' if graph_node.pry_at?(:before_array)
+
+      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?
+
+      'puts xmen' if graph_node.pry_at?(:before_array_print)
+
+      return if items.length.zero? && graph_node.skip_empty?
+
+      log_heading(graph_node.heading, graph_node.heading_type) if graph_node.heading
+
+      if primitive?(items)
+        add_line KLog::LogHelper.kv "#{@indent_label}#{key}", items.map(&:to_s).join(', ')
+      else
+        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
+
+    def primitive?(items)
+      item = items.first
+      KUtil.data.basic_type?(item)
+    end
+
+    def log_heading(heading, 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 graph_node.columns if graph_node.columns
+
+      # Slow but complete list of keys
+      # items.flat_map { |v| v.to_h.keys }.uniq
+
+      items.first.to_h.keys
+    end
+
+    def update_indent_label
+      # puts "indent_label: #{indent} - #{@recursion_depth} - #{(indent * @recursion_depth)}"
+      @indent_label = (indent * @recursion_depth)
+    end
+
+    def indent_in
+      @indent = "#{@indent}  "
+    end
+
+    def indent_out
+      @indent = indent.chomp('  ')
+    end
+
+    def depth_down
+      @recursion_depth = recursion_depth + 1
+      update_indent_label
+    end
+
+    def depth_up
+      @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
+    #
+    # configuration = {
+    #   tables: {
+    #     heading: 'Database Tables',
+    #     take: :all,
+    #     columns: [
+    #       :name,
+    #       :force,
+    #       :primary_key,
+    #       :id,
+    #       columns: { display_method: lambda { |row| row.columns.map { |c| c.name }.join(', ') }, width: 100 }
+    #     ]
+    #   },
+    #   people: {
+    #     ... people configuration goes here
+    #   }
+    # }
+    #
+
+    # 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
+
+      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
+
+          new(log_structure, node_config)
+        end
+      end
+
+      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
+      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
+
+      # 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 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
+    end
+  end
+end

data/lib/k_log/log_util.rb

@@ -72,6 +72,12 @@ module KLog
       @logger.info(message)
     end
 
+    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 %i[section_heading section].include?(type)
+    end
+
     def heading(heading, size = 70)
       lines = LogHelper.heading(heading, size)
       info_multi_lines(lines)
@@ -131,7 +137,23 @@ module KLog
     end
     alias j json
 
+    # Log a structure
+    #
+    # Can handle Hash, Array, OpenStruct, Struct, DryStruct, Hash convertible custom classes
+    #
+    # @param [Hash] **opts Options
+    # @option opts [String] :indent Indent with string, defaults to ''
+    # @option opts [String] :depth is a computered
+    # @option opts [String] :heading Log title using logger.dynamic_heading
+    # @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.log(data)
+    end
+
     # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/AbcSize
+    # DEPRECATE
     def open_struct(data, indent = '', **opts)
       KLog.logger.heading(opts[:heading], 88) unless opts[:heading].nil?
       KLog.logger.subheading(opts[:subheading], 88) unless opts[:subheading].nil?
@@ -176,8 +198,9 @@ module KLog
     def exception(exception)
       line
 
-      @logger.info(exception.message)
-      @logger.info(exception.backtrace.join("\n"))
+      @logger.info(KLog::LogHelper.bg_red(exception.message))
+
+      @logger.info(KLog::LogHelper.yellow(exception.backtrace.map { |row| row.start_with?(Dir.pwd) ? KLog::LogHelper.yellow(row) : KLog::LogHelper.red(row) }.join("\n")))
 
       line
     end

data/lib/k_log/tools/build_formatter_configuration_for_log_structure.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'k_util'
+
+module KLog
+  module Tools
+    # This tool will build a Log Structure Formatter configuration by working
+    # through the object graph you would like to use with Log Structure
+    class BuildFormatterConfigurationForLogStructure
+      # Build a sample configuration based on the structure
+      def build_sample_config(data)
+        open_struct_data = KUtil.data.to_open_struct(data)
+
+        lines = [
+          '# Usage:',
+          '',
+          "formatter = #{infer_config(open_struct_data)}",
+          '',
+          "log.structure(data, heading: 'Insert Heading', line_width: 150, formatter: formatter)"
+        ]
+        KLog.logger.line
+        puts lines
+        KLog.logger.line
+      end
+
+      private
+
+      def infer_config(data)
+        result = {}
+
+        data.each_pair do |key, value|
+          next unless value.is_a?(Array)
+          next if KUtil.data.basic_type?(value.first)
+
+          result[key] = {
+            heading: key.to_s,
+            take: :all,
+            array_columns: value.first.to_h.keys
+          }
+        end
+
+        # This is essentially a pretty hash
+        JSON.pretty_generate(result)
+            .gsub(/(?:"|')(?<key>[^"]*)(?:"|')(?=:)(?::)/) do |_|
+          "#{Regexp.last_match(:key)}:"
+        end
+            .gsub('take: "all"', 'take: :all')
+      end
+    end
+  end
+end

data/lib/k_log/version.rb

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

data/lib/k_log.rb

@@ -5,6 +5,7 @@ require 'table_print'
 require 'k_log/version'
 require 'k_log/log_formatter'
 require 'k_log/log_helper'
+require 'k_log/log_structure'
 require 'k_log/log_util'
 require 'k_log/logging'
 

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: k_log
 version: !ruby/object:Gem::Version
-  version: 0.0.19
+  version: 0.0.30
 platform: ruby
 authors:
 - David Cruwys
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-07-11 00:00:00.000000000 Z
+date: 2021-09-11 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: k_util
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: table_print
   requirement: !ruby/object:Gem::Requirement
@@ -55,8 +69,10 @@ files:
 - lib/k_log/examples.rb
 - lib/k_log/log_formatter.rb
 - lib/k_log/log_helper.rb
+- lib/k_log/log_structure.rb
 - lib/k_log/log_util.rb
 - lib/k_log/logging.rb
+- lib/k_log/tools/build_formatter_configuration_for_log_structure.rb
 - lib/k_log/version.rb
 - usage.png
 homepage: http://appydave.com/gems/k-log