k_log 0.0.20 → 0.0.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5ce4190206d26b326f0295241cf8c087c3c56bfc0bb11b4e8dbb6f8d401447f
-  data.tar.gz: 3ed6be809644377525a00658e5f010b32e3979bb031e4d10037a4393c67c47d1
+  metadata.gz: 2035ee429ccfbb7cd0307d243e9b8bd303f44444d1b356c28ad079bc8219de8f
+  data.tar.gz: c7eeff9ee82d1514859052d264cfcb06216ad939f3c215c34dfee6f64ef0d21f
 SHA512:
-  metadata.gz: 133ea34980568cb38ecf8e3b1d9efdf4aa292005b5a67ad9f8282da82200bf42611bb95dfe25bc2f1ee78b7b845cf9af4e65fbf136e0f73867cb07e092699419
-  data.tar.gz: 3606bca839c257f596f6ca6a0fb1e1b6cda1da58c3735ce0857236523c47e8ca13c0ce656936239ea0ffb2ce1c435e62dbd6b68b9f67a3677f1239c9ff0038ca
+  metadata.gz: f12d2c0fae01798339647d3905fefe8e5e63049d074965c04b878e3ba4df7b8571cba637877395f8fa033d2c780d53bfc4aaa2da605af647908fdb7e29bd1e3a
+  data.tar.gz: 3d780ecca23bac05227ff96629c464f3ecf2ed61f908a6f28145e9b00786fae625e37d751210ccaaf03d613e1683bbfbb15cf009d35e57909ac3110488b34b0f

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_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,24 @@ 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 :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
     #
@@ -26,68 +35,116 @@ module KLog
     # @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
-      @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
+      @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
+
+      data = convert_data(data)
 
-      open_struct_data = KUtil.data.to_open_struct(data)
+      log_data(data)
 
-      log_data(open_struct_data)
+      add_line(KLog::LogHelper.line(line_width))
 
-      KLog.logger.line(line_width)
+      render_output
     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 content
+      @content ||= lines.join("\n")
     end
 
-    private
+    def clean_content
+      # remove color escape codes
+      @clean_content ||= content.gsub(/\x1B\[\d*m/, '')
+    end
 
-    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)
+    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 log_data(data)
-      data.each_pair do |key, value|
-        build_key_format(key)
+      data.each_pair do |k, v|
+        key = k.is_a?(String) ? k.to_sym : k
+
+        graph_path.push(key)
+        @graph_node = GraphNode.for(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
+
+        value = graph_node.transform? ? graph_node.transform(v) : v
+
         case value
         when OpenStruct
-          log_structure(key, value) unless @key_format.ignore?
+          # l.kv 'go', 'open struct ->'
+          log_structure(key, value)
+          # l.kv 'go', 'open struct <-'
         when Array
-          log_array(key, value)     unless @key_format.ignore?
+          # l.kv 'go', 'array ->'
+          log_array(key, value)
+          # l.kv 'go', 'array <-'
         else
-          KLog.logger.kv "#{@indent_label}#{key}", value
+          # l.kv 'go', 'value ->'
+          log_heading(graph_node.heading, graph_node.heading_type) if graph_node.heading
+          add_line KLog::LogHelper.kv "#{@indent_label}#{key}", value
+          # 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 +154,34 @@ 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?
+      # return if items.length.zero? && graph_node.skip_empty?
 
-      log_heading(key_format.heading, key_format.heading_type)
+      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?
 
-      filter_items = key_format.take_all ? array : array.take(key_format.take)
+      return if items.length.zero? && graph_node.skip_empty?
 
-      if primitive?(filter_items)
-        KLog.logger.kv "#{indent}#{key}", filter_items.map(&:to_s).join(', ')
+      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
-        tp filter_items, tp_columns(filter_items)
+        table_print items, tp_columns(items)
       end
+    rescue StandardError
+      #
+    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 +189,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 +203,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 +221,55 @@ 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
     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 +278,7 @@ module KLog
     #   tables: {
     #     heading: 'Database Tables',
     #     take: :all,
-    #     array_columns: [
+    #     columns: [
     #       :name,
     #       :force,
     #       :primary_key,
@@ -178,36 +291,108 @@ 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_accessor :config
 
+      class << self
+        def null
+          @null ||= OpenStruct.new
+        end
+
+        def for(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(node_config)
+        end
+      end
+
       def initialize(config)
-        @config = OpenStruct.new(config)
+        @config = config || OpenStruct.new
       end
 
-      def array_columns
-        config.array_columns
+      # 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
 
-      def ignore?
-        config.ignore == true
+      # Skip empty array node (my be useful for other nodes, but not yet)
+      def skip_empty?
+        config.skip_empty == true
       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)
@@ -198,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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module KLog
-  VERSION = '0.0.20'
+  VERSION = '0.0.27'
 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.27
 platform: ruby
 authors:
 - David Cruwys
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-08-08 00:00:00.000000000 Z
+date: 2021-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: k_util