helium-console 0.1.9 → 0.1.13

data/lib/helium/console/registry/date.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Helium
+  class Console
+    define_formatter_for 'Date' do
+      def render_inline
+        blue object.strftime('%A, %d %b %Y')
+      end
+
+      def render_compact
+        blue object.strftime('%d/%m/%Y')
+      end
+    end
+  end
+end

data/lib/helium/console/registry/hash.rb

@@ -3,7 +3,13 @@
 module Helium
   class Console
     define_formatter_for Hash do
-      def call
+      def render_compact
+        return '{}' unless object.any?
+
+        "##{format object.class, :compact}#{light_black "[#{object.size}]"}"
+      end
+
+      def render_partial
         return '{}' if object.none?
         return inline_with_truncation if force_inline?
 
@@ -13,23 +19,27 @@ module Helium
       private
 
       def format_as_table
-        table = Table.new(runner: '  ', after_key: after_key, format_keys: !all_symbol?)
-        object.each do |key, value|
-          key = light_blue(key.to_s) if all_symbol?
-          table.row(key, value)
+        key_value = build_key_value do |kv|
+          object.each do |key, value|
+            key = light_blue(key.to_s) if all_symbol?
+            kv.row(key, value)
+          end
         end
 
-        [
-          '{',
-          format(table, **options),
-          '}'
-        ].join("\n")
+        yield_lines do |y|
+          y << '{'
+          format_key_value(key_value, left: '  ', between: after_key,
+                                      format_keys: all_symbol? ? false : {}).lines.each do |line|
+            y << line
+          end
+          y << '}'
+        end
       end
 
       def inline_with_truncation
         truncated = formatted_inline_elements.with_index.inject([]) do |collected, (formatted, index)|
           new_collected = [*collected[0..-2], formatted, trunc_text(index + 1)].compact
-          break collected if new_collected.join(', ').length > max_width - 4
+          break collected if length_of(new_collected.join(', ')) > max_width - 4
 
           new_collected
         end
@@ -55,15 +65,18 @@ module Helium
       end
 
       def formatted_inline_elements
+        max_width = 15 unless level == 1
         object.each.lazy.map do |key, value|
-          formatted_key = format_key(key, max_lines: 1, nesting: 1, max_with: 15)
-          formatted_value = format_nested(value, max_lines: 1, nesting: 1, max_width: 15)
+          formatted_key = format_key(key, max_lines: 1, nesting: 1, max_with: max_width)
+          formatted_value = format_nested(value, max_lines: 1, nesting: 1, max_width: max_width)
           [formatted_key, after_key, formatted_value].join
         end
       end
 
       def all_symbol?
-        object.keys.all? { |key| key.is_a? Symbol }
+        return @all_symbol if defined?(@all_symbol)
+
+        @all_symbol = object.keys.all? { |key| key.is_a? Symbol }
       end
 
       def format_key(key, **options)
@@ -78,6 +91,8 @@ module Helium
 
       def trunc_text(count)
         truncated_elements = total_elements - count
+        return if truncated_elements.zero?
+
         light_black("(#{truncated_elements} #{count.zero? ? 'elements' : 'more'})")
       end
 

data/lib/helium/console/registry/method.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Helium
+  class Console
+    define_formatter_for Method do
+      def render_full
+        as_table(source: true)
+      end
+
+      def render_partial
+        as_table(source: false)
+      end
+
+      def render_compact
+        "#{yellow 'method'} #{title}"
+      end
+
+      private
+
+      # TODO: he method below breaks ABCSize, most likely due to an amount of colouring method calls.
+      # This should be simplified by altering table handling: https://github.com/helium-rb/console/issues/10
+      def as_table(source:) # rubocop:disable Metrics/AbcSize
+        key_value = build_key_value do |kv|
+          kv.row(magenta('receiver'), object.receiver)
+          kv.row(magenta('location'), object.source_location&.join(':'))
+          kv.row(magenta('source'), trimmed_source, format_value: false) if source && object.source_location
+        end
+
+        yield_lines do |y|
+          y << "#{light_black '#'} #{render_compact}"
+          format_key_value(key_value, left: light_black('| '), format_keys: false, between: light_black(': '))
+            .lines.each { |line| y << line }
+        end
+      end
+
+      def title
+        formatted_owner = format(owner, :compact)
+        formatted_owner = "(#{formatted_owner})" unless owner.is_a? Module
+
+        "#{formatted_owner}#{yellow(singleton_owner? ? '.' : '#')}#{yellow object.name.to_s}"
+      end
+
+      def owner
+        return @owner if defined?(@owner)
+
+        @owner = object.owner
+        if singleton_owner?
+          @owner = object.receiver
+          @owner = owner.ancestors.find { |ancestor| ancestor.singleton_class == object.owner } if owner.is_a? Class
+        end
+        @owner
+      end
+
+      def singleton_owner?
+        object.owner.singleton_class?
+      end
+
+      def trimmed_source
+        indent = object.source.lines.map { |line| line =~ /[^ ]/ }.min
+        object.source.lines.map { |line| line[indent..-1] }.join.chomp
+      end
+    end
+  end
+end

data/lib/helium/console/registry/module.rb

@@ -2,22 +2,34 @@
 
 module Helium
   class Console
-    define_formatter_for Module do
-      def call
-        light_yellow(object.name || anonymous_text)
+    define_class_formatter_for BasicObject do
+      def render_compact
+        class_name || singleton_name || anonymous_text
       end
 
       private
 
+      def class_name
+        light_yellow(object.name) if object.name
+      end
+
+      def singleton_name
+        return unless object.is_a?(Class) && object.singleton_class?
+
+        owner = ObjectSpace.each_object(object).first
+        "#{light_yellow 'singleton class of'} #{format owner, :compact}"
+      end
+
       def anonymous_text
         closest = (object.ancestors.grep(Class) - [Object, BasicObject]).find(&:name)&.name
 
         signature = if closest
-          "subclass of #{closest}"
+          "#{light_yellow 'subclass of'} #{format closest, :compact}"
         else
-          object.class.name.downcase
+          light_yellow(object.class.name.downcase)
         end
-        "(anonymous #{signature})"
+
+        "#{light_yellow '('}#{signature})#{light_yellow ')'}"
       end
     end
   end

data/lib/helium/console/registry/nil.rb

@@ -3,7 +3,7 @@
 module Helium
   class Console
     define_formatter_for NilClass do
-      def call
+      def render_compact
         light_black('nil')
       end
     end

data/lib/helium/console/registry/numeric.rb

@@ -3,9 +3,15 @@
 module Helium
   class Console
     define_formatter_for Numeric do
-      def call
+      def render_compact
         light_cyan(object.to_s)
       end
     end
+
+    define_formatter_for 'BigDecimal' do
+      def render_compact
+        light_cyan(object.to_s('F'))
+      end
+    end
   end
 end

data/lib/helium/console/registry/object.rb

@@ -3,28 +3,17 @@
 module Helium
   class Console
     define_formatter_for Object do
-      def call
-        return inline_with_truncation if force_inline?
+      def optimal_format
+        return [:compact, {}] if object.instance_variables.none?
 
-        format_as_table
+        super
       end
 
-      private
-
-      def format_as_table
-        table = Table.new(runner: light_black('| '), after_key: light_black(': '), format_keys: false)
-
-        object.instance_variables.each do |inst|
-          table.row(magenta(inst.to_s), object.instance_variable_get(inst))
-        end
-
-        [
-          "#{light_black '#'} #{class_name}",
-          format(table)
-        ].reject(&:empty?).join("\n")
+      def render_compact
+        "#{format object.class, :compact}#{light_black "##{object.object_id}"}"
       end
 
-      def inline_with_truncation
+      def render_inline
         class_name = class_name(short: true)
 
         vars = formatted_instance_variables(max_width: 15, max_lines: 1).inject([]) do |collected, element|
@@ -38,30 +27,22 @@ module Helium
         [class_name, formatted_vars].compact.join
       end
 
-      # def inline_without_truncation
-      #   joined = nil
-      #
-      #   object.each do |key, value|
-      #     return unless simple?(value)
-      #
-      #     formatted_key = format(key, level: 3, max_with: 15)
-      #     formatted_value = format(value, level: 3, max_width: 15)
-      #     formatted = "#{formatted_key} => #{formatted_value}"
-      #
-      #     joined = [joined, formatted].compact.join(', ')
-      #
-      #     return if joined.length > max_width - 4
-      #   end
-      #   joined = " #{joined} " if joined
-      #   ['{', joined, '}'].compact.join
-      # end
-
-      def force_inline?
-        level > 2
+      def render_partial
+        yield_lines do |y|
+          y << "#{light_black '#'} #{class_name}"
+          as_table.lines.each { |line| y << line }
+        end
       end
 
-      def all_symbol?
-        object.keys.all? { |key| key.is_a? Symbol }
+      private
+
+      def as_table
+        key_value = build_key_value do |kv|
+          object.instance_variables.each do |inst|
+            kv.row(magenta(inst.to_s), object.instance_variable_get(inst))
+          end
+        end
+        format_key_value(key_value, left: light_black('| '), between: light_black(': '), format_keys: false)
       end
 
       def formatted_instance_variables(**options)
@@ -72,7 +53,7 @@ module Helium
       end
 
       def class_name(short: false)
-        formatted = format(object.class, short: short)
+        formatted = format(object.class, :compact)
         short ? "##{formatted}" : "#{formatted} instance"
       end
     end

data/lib/helium/console/registry/pathname.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Helium
+  class Console
+    define_formatter_for 'Pathname' do
+      def render_compact
+        "#{format(Pathname, :compact)}: #{yellow(object.to_s)}"
+      end
+    end
+  end
+end

data/lib/helium/console/registry/set.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Helium
+  class Console
+    define_formatter_for 'Set' do
+      def render_compact
+        return render_empty if object.none?
+
+        "#{light_magenta('Set:')} #{trunc_message(object.count, all_truncated: true)}"
+      end
+
+      def render_partial
+        return render_empty if object.none?
+        return inline_with_truncation if options[:max_lines] == 1
+
+        inline_without_truncation || format_as_table
+      end
+
+      def simple?
+        object.none?
+      end
+
+      private
+
+      def render_empty
+        "#{light_magenta('Set:')} #{red 'empty'}"
+      end
+
+      def format_as_table
+        table = Table.new(runner: '', format_keys: false)
+        object.each do |element|
+          table.row(light_black('-'), element)
+        end
+
+        yield_lines do |y|
+          y << light_magenta('Set: {')
+          format(table).lines.each { |line| y << line }
+          y << light_magenta('}')
+        end
+      end
+
+      def inline_with_truncation
+        formatted = formatted_elements.with_index.inject([]) do |joined, (element, index)|
+          new_joined = [*joined[0..-2], element, trunc_message(object_size - index - 1, all_truncated: index.zero?)]
+          break joined if too_long?(new_joined, max_width: max_width - 9)
+
+          new_joined
+        end
+
+        "#{light_magenta('Set: {')} #{formatted.join(light_magenta(' | '))} #{light_magenta('}')}"
+      end
+
+      def inline_without_truncation
+        return unless object.all? { |element| Helium::Console.simple? element }
+
+        formatted = formatted_elements.inject([]) do |joined, element|
+          joined = [*joined, element]
+          break if too_long?(joined, max_width: max_width - 4)
+
+          joined
+        end
+
+        "#{light_magenta('Set: {')} #{formatted.join(light_magenta(' | '))} #{light_magenta('}')}" unless formatted.nil?
+      end
+
+      def too_long?(object, max_width:)
+        string = object.respond_to?(:join) ? object.join(' | ') : object
+        length_of(string) > max_width - 4
+      end
+
+      def formatted_elements(**options)
+        sorted = begin
+          object.sort
+        rescue StandardError
+          object
+        end
+        sorted.each.lazy.map { |element| format_nested(element, **options) }
+      end
+
+      def trunc_message(count, all_truncated: false)
+        return if count < 1
+
+        light_black "(#{count} #{all_truncated ? 'elements' : 'more'})"
+      end
+
+      def object_size
+        @object_size ||= object.size
+      end
+    end
+  end
+end

data/lib/helium/console/registry/string.rb

@@ -3,26 +3,46 @@
 module Helium
   class Console
     define_formatter_for String do
-      def call
-        formatted = Helium::Console.format_string(
-          object.dump.gsub('\n', "\n"),
+      def render_compact
+        render_string(object, max_width: 15, max_lines: 1)
+      end
+
+      def render_inline
+        render_string(object.gsub("\n", '\n'), max_lines: 1)
+      end
+
+      def render_partial
+        render_string(object, max_lines: max_lines || 3)
+      end
+
+      def render_full
+        render_string(object)
+      end
+
+      def simple?
+        object.lines.count == 1 && length_of(object) < 15
+      end
+
+      def render_string(string, max_lines: self.max_lines, max_width: self.max_width)
+        formatted = format_string(
+          "\"#{string.gsub('"', '\"')}\"",
           max_width: max_width,
           max_lines: max_lines,
           overflow: overflow,
-          ellipses: '..."'
+          ellipses: '..."',
+          indent: indent
         )
 
-        formatted.lines
-          .map { |line| light_green(line) }
-          .join
+        result = formatted.lines
+          .map { |line| light_green(line.chomp) }
+          .join("\n")
+
+        result = "#{result}\n" if formatted.end_with?("\n")
+        result
       end
 
       def max_lines
-        case level
-          when 1 then nil
-          when 2 then 3
-          else 1
-        end
+        @options[:max_lines]
       end
     end
   end

data/lib/helium/console/registry/symbol.rb

@@ -3,7 +3,7 @@
 module Helium
   class Console
     define_formatter_for Symbol do
-      def call
+      def render_compact
         light_blue(":#{object}")
       end
     end

data/lib/helium/console/registry/time.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Helium
+  class Console
+    define_formatter_for Time do
+      def render_inline
+        blue object.strftime('%A, %d %b %Y, %H:%M:%S')
+      end
+
+      def render_compact
+        blue object.strftime('%d/%m/%Y, %H:%M')
+      end
+    end
+  end
+end

data/lib/helium/console/registry.rb

@@ -1,77 +1,33 @@
 # frozen_string_literal: true
 
-require 'colorized_string'
+require 'helium/console/colorized_string'
+require 'helium/console/formatter'
 
 module Helium
   class Console
     class Registry
-      class Element
-        def initialize(object, **options)
-          @object = object
-          @options = options
-        end
-
-        def call
-        end
-
-        attr_reader :object, :options
-
-        def format_nested(other_object, **options)
-          Helium::Console.format(other_object, **nested_opts(options))
-        end
-
-        def format(other_object, **options)
-          Helium::Console.format(other_object, **nested_opts(options, increase_level: false))
-        end
-
-        def format_string(string, **options)
-          Helium::Console.format_string(string, **options)
-        end
-
-        def simple?
-          false
-        end
-
-        def method_missing(name, *args)
-          return @options[name] if @options.key?(name)
-          return ColorizedString.new(*args).colorize(name) if ColorizedString.colors.include?(name)
-
-          super
-        end
-
-        def respond_to_missing?(name, private = false)
-          @options.key?(name) || ColorizedString.colors.include?(name) || super
-        end
-
-        def nested_opts(new_options, increase_level: true)
-          new_options = options.merge(new_options)
-          new_options[:level] += 1 if increase_level
-          new_options[:ignore_objects] << object.object_id
-          new_options
-        end
+      def self.instance_formatters
+        @instance_formatters ||= new
+      end
 
-        def length_of(string)
-          ColorizedString.new(string).uncolorize.length
-        end
+      def self.class_formatters
+        @class_formatters ||= new
       end
 
-      def add(klass, &handler)
-        define(klass) do
-          define_method(:call, &handler)
-        end
+      def add(mod, formatter)
+        handlers[mod] = formatter
       end
 
-      def define(klass, &block)
-        handlers[klass] = Class.new(Element, &block)
+      def define(mod, &block)
+        add(mod, Class.new(Formatter, &block))
       end
 
-      def handler_for(object, **options)
-        element_class = object.class.ancestors.find do |ancestor|
-          break handlers[ancestor] if handlers.key?(ancestor)
+      def handler_for(klass)
+        klass.ancestors.each do |ancestor|
+          result = handlers[ancestor] || handlers[ancestor.name]
+          return result if result
         end
-        return unless element_class
-
-        element_class.new(object, **options)
+        handlers[BasicObject]
       end
 
       private

data/lib/helium/console/version.rb

@@ -2,6 +2,6 @@
 
 module Helium
   class Console
-    VERSION = '0.1.9'
+    VERSION = '0.1.13'
   end
 end