k_log 0.0.19 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 243999c48416e082085f9c72519cd2cc97bb8585389ee6848592f18dc2cfc6bd
-  data.tar.gz: '009abfdd9b635d89f6e31f8197516f0dd612ce14adc9dfb7f005c9a9da458684'
+  metadata.gz: a5ce4190206d26b326f0295241cf8c087c3c56bfc0bb11b4e8dbb6f8d401447f
+  data.tar.gz: 3ed6be809644377525a00658e5f010b32e3979bb031e4d10037a4393c67c47d1
 SHA512:
-  metadata.gz: f19cf492a22aaf8dbc89dcd9246aacc5732e3db7844d17030d63091e672c4fb201d11c221bbe24450cb1d8745b16d8b70bb21994cc821387ee703aaea4bbc69f
-  data.tar.gz: f0355d0438831db47d1ec390ba7d336b763d76f8d1d23f9520c98a1641901f0114c9961e9ac5d158daa8cddf5658782c6311721aeea5f01cd6dbe7ba24a80c80
+  metadata.gz: 133ea34980568cb38ecf8e3b1d9efdf4aa292005b5a67ad9f8282da82200bf42611bb95dfe25bc2f1ee78b7b845cf9af4e65fbf136e0f73867cb07e092699419
+  data.tar.gz: 3606bca839c257f596f6ca6a0fb1e1b6cda1da58c3735ce0857236523c47e8ca13c0ce656936239ea0ffb2ce1c435e62dbd6b68b9f67a3677f1239c9ff0038ca

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.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'
 

data/lib/k_log/log_structure.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+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
+
+    # 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] :formatter is a complex configuration for formatting different data within the structure
+    def initialize(opts)
+      @indent           = opts[:indent] || '  '
+      @heading          = opts[:heading]
+      @heading_type     = opts[:heading_type] || :heading
+      @formatter        = opts[:formatter] || {}
+
+      @line_width       = opts[:line_width] || 80
+      # @skip_array = opts[:skip_array]
+
+      @recursion_depth  = 0
+      @key_format       = nil
+      update_indent_label
+    end
+
+    def log(data)
+      log_heading(heading, heading_type)
+
+      open_struct_data = KUtil.data.to_open_struct(data)
+
+      log_data(open_struct_data)
+
+      KLog.logger.line(line_width)
+    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
+      }
+    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)
+    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?
+        else
+          KLog.logger.kv "#{@indent_label}#{key}", value
+        end
+      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_child_data(value)
+    end
+
+    def log_child_data(value)
+      depth_down
+      log_data(value)
+      depth_up
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def log_array(key, array)
+      # next unless opts[:skip_array].nil?
+      return unless array.length.positive?
+
+      log_heading(key_format.heading, key_format.heading_type)
+
+      filter_items = key_format.take_all ? array : array.take(key_format.take)
+
+      if primitive?(filter_items)
+        KLog.logger.kv "#{indent}#{key}", filter_items.map(&:to_s).join(', ')
+      else
+        tp filter_items, tp_columns(filter_items)
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def primitive?(items)
+      item = items.first
+      KUtil.data.basic_type?(item)
+    end
+
+    def log_heading(heading, heading_type)
+      return unless heading
+
+      KLog.logger.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
+
+      # 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
+      @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
+      update_indent_label
+      @recursion_depth = recursion_depth - 1
+    end
+
+    # Format configuration for a specific key
+    #
+    # @example Example configuration for key: tables
+    #
+    # configuration = {
+    #   tables: {
+    #     heading: 'Database Tables',
+    #     take: :all,
+    #     array_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
+    #   }
+    # }
+    #
+    # format = KeyFormat.new(configuration[:tables])
+    class KeyFormat
+      attr_accessor :config
+
+      def initialize(config)
+        @config = OpenStruct.new(config)
+      end
+
+      def array_columns
+        config.array_columns
+      end
+
+      def heading
+        config.heading
+      end
+
+      def heading_type
+        config.heading_type || :section_heading
+      end
+
+      def take
+        config.take
+      end
+
+      def take_all
+        config.take.nil? || config.take == :all
+      end
+
+      def ignore?
+        config.ignore == true
+      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 type == :section_heading
+    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?

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.20'
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: k_log
 version: !ruby/object:Gem::Version
-  version: 0.0.19
+  version: 0.0.20
 platform: ruby
 authors:
 - David Cruwys
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-07-11 00:00:00.000000000 Z
+date: 2021-08-08 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