helium-console 0.1.7 → 0.1.11

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Helium
   class Console
     define_formatter_for TrueClass do

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

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

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

@@ -1,80 +1,91 @@
+# frozen_string_literal: true
+
 module Helium
   class Console
     define_formatter_for Hash do
       def call
-        return format_inline_with_truncation if force_inline?
-        format_inline_with_no_truncation || format_as_table
+        return '{}' if object.none?
+        return inline_with_truncation if force_inline?
+
+        inline_without_truncation || format_as_table
       end
 
-    private
+      private
 
       def format_as_table
-        table = Table.new(runner: '  ', after_key: after_key, format_keys: !all_symbol?)
+        table = Table.new(runner: '  ', after_key: after_key, format_keys: true)
         object.each do |key, value|
           key = light_blue(key.to_s) if all_symbol?
           table.row(key, value)
         end
 
-        [
-          "{",
-          format(table, **options),
-          "}"
-        ].join($/)
+        yield_lines do |y|
+          y << '{'
+          format(table).lines.each { |line| y << line }
+          y << '}'
+        end
       end
 
-      def format_inline_with_truncation
-        joined = nil
-        trunc = nil
-        total = object.length
+      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
 
-        object.each.with_index do |(key, value), index|
-          formatted_key = format(key, max_lines: 1, nesting: 1, max_with: 15)
-          formatted_value = format(value, max_lines: 1, nesting: 1, max_width: 15)
-
-          formatted = "#{formatted_key} => #{formatted_value}"
+          new_collected
+        end
 
-          new_joined = [joined, formatted].compact.join(", ")
-          new_trunc = (", (#{total - index - 1} #{index.zero? ? 'elements' : 'more'})" unless index == total - 1)
+        ['{ ', truncated.join(', '), ' }'].compact.join
+      end
 
-          break if new_joined.length > max_width - (new_trunc&.length || 0) - 4
+      def inline_without_truncation
+        formatted = formatted_inline_elements.inject([]) do |collected, element|
+          collected << element
+          break if collected.join(', ').length > max_width - 4
 
-          joined = new_joined
-          trunc = new_trunc
+          collected
         end
 
-        joined = [" ", joined, trunc, " "].compact.join if joined
-        ["{", joined, "}"].compact.join
+        return if formatted.nil?
+
+        ['{ ', formatted.join(', '), ' }'].compact.join
+      end
+
+      def force_inline?
+        level > 2
       end
 
-      def format_inline_with_no_truncation
-        joined = nil
-        one_complex = false
+      def formatted_inline_elements
+        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, after_key, formatted_value].join
+        end
+      end
 
-        object.each do |key, value|
-          return unless simple?(value)
+      def all_symbol?
+        return false
+        return @all_symbol if defined?(@all_symbol)
 
-          formatted_key = format(key, max_lines: 1, nesting: 1, max_with: 15)
-          formatted_value = format(value, max_lines: 1, nesting: 1, max_width: 15)
-          formatted = "#{formatted_key} => #{formatted_value}"
+        @all_symbol = object.keys.all? { |key| key.is_a? Symbol }
+      end
 
-          joined = [joined, formatted].compact.join(", ")
+      def format_key(key, **options)
+        return light_blue(key.to_s) if all_symbol?
 
-          return if joined.length > max_width - 4
-        end
-        joined = " #{joined} " if joined
-        ["{", joined, "}"].compact.join
+        format_nested(key, **options)
       end
 
-      def force_inline?
-        level > 2
+      def total_elements
+        @total_elements ||= object.length
       end
 
-      def all_symbol?
-        object.keys.all? { |key| key.is_a? Symbol }
+      def trunc_text(count)
+        truncated_elements = total_elements - count
+        light_black("(#{truncated_elements} #{count.zero? ? 'elements' : 'more'})")
       end
 
       def after_key
-        all_symbol? ? light_blue(": ") : light_black(" => ")
+        all_symbol? ? light_blue(': ') : light_black(' => ')
       end
     end
   end

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

@@ -1,15 +1,23 @@
+# frozen_string_literal: true
+
 module Helium
   class Console
     define_formatter_for Module do
       def call
-        light_yellow(object.name || anonymus_text)
+        light_yellow(object.name || anonymous_text)
       end
 
       private
 
-      def anonymus_text
-        closest = object.ancestors.find(&:name).name
-        "(anonymous #{closest})"
+      def anonymous_text
+        closest = (object.ancestors.grep(Class) - [Object, BasicObject]).find(&:name)&.name
+
+        signature = if closest
+          "subclass of #{closest}"
+        else
+          object.class.name.downcase
+        end
+        "(anonymous #{signature})"
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Helium
   class Console
     define_formatter_for NilClass do

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Helium
   class Console
     define_formatter_for Numeric do

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

@@ -1,61 +1,41 @@
+# frozen_string_literal: true
+
 module Helium
   class Console
     define_formatter_for Object do
       def call
-        return format_inline_with_truncation if force_inline?
+        return inline_with_truncation if force_inline?
+
         format_as_table
       end
 
-    private
+      private
 
       def format_as_table
-        table = Table.new(runner: light_black('| '), after_key: light_black(": "), format_keys: false)
+        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
 
-        [
-          table_header,
-          format(table),
-        ].reject(&:empty?).join($/)
-      end
-
-      def format_inline_with_truncation
-        "#{object.class.name}##{object.object_id.to_s(16)}"
+        yield_lines do |y|
+          y << "#{light_black '#'} #{class_name}"
+          format(table).lines.each {|line| y << line }
+        end
       end
 
-      def format_inline_with_no_truncation
-        joined = nil
-
-        object.each do |key, value|
-          return unless simple?(value)
+      def inline_with_truncation
+        class_name = class_name(short: true)
 
-          formatted_key = format(key, level: 3, max_with: 15)
-          formatted_value = format(value, level: 3, max_width: 15)
-          formatted = "#{formatted_key} => #{formatted_value}"
+        vars = formatted_instance_variables(max_width: 15, max_lines: 1).inject([]) do |collected, element|
+          new_collected = [*collected, element]
+          break collected if new_collected.join(', ').length > max_width - length_of(class_name) - 2
 
-          joined = [joined, formatted].compact.join(", ")
-
-          return if joined.length > max_width - 4
+          new_collected
         end
-        joined = " #{joined} " if joined
-        ["{", joined, "}"].compact.join
-      end
 
-      def table_header
-        type = case object
-          when Class then :class
-          when Module then :module
-          else :instance
-        end
-        klass = type == :instance ? object.class : object
-        klass_name = klass.name
-        if !klass_name
-          named_ancestor = klass.ancestors.find(&:name)
-          klass_name = ['anonymous', named_ancestor&.name].compact.join(" ")
-        end
-        "#{light_black('#')} #{light_yellow(klass_name)} #{type}"
+        formatted_vars = "( #{vars.join(', ')} )" if vars.any?
+        [class_name, formatted_vars].compact.join
       end
 
       def force_inline?
@@ -65,6 +45,18 @@ module Helium
       def all_symbol?
         object.keys.all? { |key| key.is_a? Symbol }
       end
+
+      def formatted_instance_variables(**options)
+        object.instance_variables.sort.each.lazy.map do |var_name|
+          value = object.instance_variable_get(var_name)
+          "#{magenta(var_name.to_s)} = #{format_nested(value, **options)}"
+        end
+      end
+
+      def class_name(short: false)
+        formatted = format(object.class, short: short)
+        short ? "##{formatted}" : "#{formatted} instance"
+      end
     end
   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 call
+        "#{format(Pathname, short: true)}: #{yellow(object.to_s)}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Helium
+  class Console
+    define_formatter_for Set do
+      def call
+        return "#{light_magenta('Set:')} #{red 'empty'}" if object.none?
+        return inline_with_truncation if force_inline?
+
+        inline_without_truncation || format_as_table
+      end
+
+      def simple?
+        object.none?
+      end
+
+      private
+
+      def format_as_table
+        table = Table.new(runner: '', format_keys: false)
+        object.each do |element|
+          table.row(light_magenta('-'), element)
+        end
+
+        [
+          light_magenta('Set: {'),
+          format(table),
+          light_magenta('}')
+        ].join("\n")
+      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)
+        object.sort.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
+
+      def force_inline?
+        level > 2
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Helium
   class Console
     define_formatter_for String do
@@ -7,7 +9,7 @@ module Helium
           max_width: max_width,
           max_lines: max_lines,
           overflow: overflow,
-          ellipses: "...\""
+          ellipses: '..."'
         )
 
         formatted.lines
@@ -17,9 +19,9 @@ module Helium
 
       def max_lines
         case level
-        when 1 then nil
-        when 2 then 3
-        else 1
+          when 1 then nil
+          when 2 then 3
+          else 1
         end
       end
     end

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

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Helium
   class Console
     define_formatter_for Symbol do
       def call
-        light_blue(':' + object.to_s)
+        light_blue(":#{object}")
       end
     end
   end

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

@@ -1,38 +1,40 @@
+# frozen_string_literal: true
+
 module Helium
   class Console
     define_formatter_for Table do
       def call
-        [
-          *formatted_values,
-          truncation,
-        ].compact.join($/)
+        yield_lines do |y|
+          rows.each do |key, value, options = {}|
+            format_pair(key, value, **options) do |line|
+              y << line
+            end
+          end
+          y << truncation if truncation
+        end
       end
 
-      def formatted_values
-        rows.flat_map do |key, value, options = {}|
-          formatted_value = format_nested(value, max_width: max_value_width, **options)
+      private
 
-          formatted_value.lines.map.with_index do |line, index|
-            [
-              object.runner,
-              index.zero? ? rjust(format_key(key), key_width) : " " * key_width,
-              index.zero? ? object.after_key : " " * length_of(object.after_key),
-              line.chomp,
-            ].join
-          end
+      def format_pair(key, value, **options)
+        formatted_value = format_nested(value, max_width: max_value_width, **options)
+
+        formatted_value.lines.each.with_index.map do |line, index|
+          yield [
+            object.runner,
+            text_or_blank(rjust(format_key(key), key_width), blank: index > 0),
+            text_or_blank(object.after_key, blank: index > 0),
+            line.chomp
+          ].join
         end
       end
 
-      def truncation
-        return unless object.rows.length > rows.length
+      def text_or_blank(text, blank:)
+        return text unless blank
 
-        [
-          object.runner,
-          light_black("(#{object.rows.length - rows.length} more)")
-        ].join
+        ' ' * length_of(text)
       end
 
-
       def key_width
         @key_width ||= rows
           .map(&:first)
@@ -50,26 +52,30 @@ module Helium
       end
 
       def rjust(string, width)
-        " " * (width - length_of(string)) + string
-      end
-
-      def length_of(string)
-        if string.respond_to?(:uncolorize)
-          string.uncolorize.length
-        else
-          string.length
-        end
+        ' ' * (width - length_of(string)) + string
       end
 
       def rows
         @rows ||= case level
-        when 1 then object.rows
-        when 2
-          object.rows.count < 10 ? object.rows : object.rows.first(9)
-        else
-          object.rows.count < 3 ? object.rows : object.rows.first(2)
+          when 1 then object.rows
+          when 2 then rows_limited_by(10)
+          else rows_limited_by(3)
         end
       end
+
+      def rows_limited_by(number)
+        object.rows.count <= number ? object.rows : object.rows.first(number - 1)
+      end
+
+      def truncation
+        return unless object.rows.length > rows.length
+
+        [
+          object.runner,
+          light_black("(#{object.rows.length - rows.length} more)"),
+          "\n"
+        ].join
+      end
     end
   end
 end