helium-console 0.1.11 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d935efaa6d5d2a98d58c2d0cea17911486522ce45bfd00432b089735994ce20
-  data.tar.gz: c86a17fc7b04379249cf491da55086537f7f8983c47758d9b20438495f12039e
+  metadata.gz: eaa7f60f45f5dfc8e2debd5115c10760755ea71ae485328300af7d4a36cff972
+  data.tar.gz: ce41d603bfcee8df481f4132cf2b82a03842de53452474d4b71fd65d6a676d5e
 SHA512:
-  metadata.gz: 2ab8ca592e31437b6e70cd269cd961b8fc38c3e544b24aa2eecfbddce474ed22ebda4c704849271b847656e22d15b25feb169aedad5593f6267378e211b068bf
-  data.tar.gz: 2915fa426caea028e549e9d55e5a4cb7799ef593cdd706529c9eac5bc582a841bdaaa67fb1480917df0543286a0d7743f5eb13b813b92ad4193eab207d49a378
+  metadata.gz: fbd742302810644a5c0e18d9ea1bb2bb1fef2d1995a2670dea2996478cc8eaf3232b07ba42785a84e9f9bb8fbc1d57a462cf3583747d0b3366f3a8072aab1fc2
+  data.tar.gz: 52cfe0ed72fddd80f8c61f4063d01ff8305a0a00ca88944fc73a0d3e1e466abdc262ab55b0fd050b27891af35dad0e349fd7e5d4b08904b0da30bec90d2e43e7

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    helium-console (0.1.11)
+    helium-console (0.1.12)
       colorize
       pry
 

data/README.md

@@ -1,7 +1,13 @@
 # Helium::Console
 
+Readable console output for your ruby project!
+
 It is really tricky to display data in the console in the readable and consistent way. Many objects needs to display other objects, which might break their own formatting.
-Helium:Console is to make it easier by formatting strings in accordance to current console size.
+Helium:Console is an attempt to make your development console more readable by:
+* limiting displayed nesting levels to 3
+* limiting data displayed for nested objects
+* using nested table layout
+* automatically dividing and wrapping long strings
 
 ## Installation
 
@@ -21,24 +27,74 @@ Or install it yourself as:
 
 ## Usage
 
-Helium::Console helps you to format any string in such a way that it displays nicely in the console:
+You can start helium console same way as you would start Pry:
+
+``` ruby
+require 'helium/console'
+Helium::Console.start
+```
+
+### Custom formatters
+
+Helium::Console hooks into pry and brings a number of default formatters. Unlike IRB and Pry, it does not use object's methods for display
+(so no `inspect` nor `pretty_print`) and replaces them by the collection of inheritable formatters objects stored in its registry.
+
+Formatter can be any object that conforms to the following interface:
+* `initialize(object_to_format, format, console_instance, **options)`
+* `call` method returning any object responding to `lines` (e.g. `String` )
+
+Formatter bellow will simply return a result of `inspect` call on the object:
+
+```ruby
+class InspectFormatter
+  def initialize(object, _console, **)
+    @object = object
+  end
+  
+  def call
+    @object.inspect
+  end
+end
+```
+
+You can register your formatter in console registry with:
 
+```ruby
+Helium::Console.register(Kernel, InspectFormatter)
 ```
-string = "- Hello there!\nGeneral Kenobi"
-Helium::Console.format(string, indent: 2)
-=> "  - Hello there!\n  General Kenobi"
+
+The call above makes `InspectFormatter` available for all the objects that derives from Kernel module.
+
+To make formatting easier, you can subclass your formatter from `Helium::Console::Registry::Element`. By doing so, the following methods will be available to you inside your formatter class:
+* `object`, `console` and `options` readers
+* default `call` implementation, delegating formatting to one
+* `format(other_object, **options)` - formats some other object **using the exact same options, including nesting level**.
+* `format_nested(other_object, **options)` - as above, but increases nesting level.
+* `format_string(string, **options)` - formats string by splitting it into lines of appropriate length and truncating (depending on nesting level).
+This is different to `format` and `format_nested` as it will not trigger `String` formatter (which by default adds quotes, escapes inner quotes and colors the result light green)
+* `red(string)`, `light_red(string)`, `yellow(string)`, etc - returns colorized string when `Pry.color` is set to true.
+* `length_of(string)` - utility option returning the length of displayed string, handling both colorized and non-colorized strings.
+
+### Displaying as a table
+
+To display object in a form of a table, format instance of `Helium::Console::Table`:
+
+```ruby
+class MyFormatter < Helium::Console::Registry::Element
+  def call
+    table = Helium::Console::Table.new(runner: '--@', after_key: '--@--', format_keys: false)
+    table.row magenta("property 1"), object.prop1
+    table.row magenta("property 2"), object.instance_variable_get(:@prop2)
+    
+    format table
+  end
+end
 ```
 
-When executed in a non-console environment `format` simply returns the string.
+Table will automatically format all the right-hand values with an increased nesting level. By default, it will also format the left-hand keys, however this is controlled with `format_keys` option.
 
-Supported formattign options:
+Other options: `runner` is a string to be displayed at the beginning of each line, and `after_key` is a string to be injected between left and right values.
 
-* `indent` - specifies the amount of spaces added to each new line. Also accepts hash `{first:, other:}`. Defaults to 0.
-* `overflow` - specifies how to handle lines longer than console line width.
-  * `:wrap` - splits the long line into few lines and applies the required indent.
-  * `:wrap_words` - similar to wrap, but will try to avoid breaking the words.
-  * `:none` - does not modify long strings.
-* `max-lines` - specifies how many lines to display. Last line will be truncated with `...`. Defaults to `nil`
 
 ## Development
 

data/bin/console

@@ -7,4 +7,4 @@ require 'helium/console'
 require 'byebug'
 require 'ffaker'
 
-Pry.start
+Helium::Console.start

data/lib/helium/console/colorized_string.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'colorized_string'
+
+module Helium
+  class Console
+    class ColorizedString < ColorizedString
+      def length
+        uncolorize.to_s.length
+      end
+
+      def colorize(*)
+        return self unless Pry.color
+
+        super
+      end
+    end
+  end
+end

data/lib/helium/console/formatter.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Helium
+  class Console
+    class Formatter
+      DEFAULT_STYLES = {
+        1 => [:full, {}],
+        2 => [:partial, {}],
+        3 => [:partial, { max_lines: 1 }]
+      }.freeze
+
+      class LazyStringEvaluator
+        def initialize(&block)
+          @lines = Enumerator.new { |y| block.(y) }
+        end
+
+        attr_reader :lines
+
+        def to_s
+          lines.to_a.join
+        end
+      end
+
+      def initialize(object, style, console, **options)
+        @object = object
+        @options = options
+        @style = style
+        @console = console
+      end
+
+      def call
+        method_name = [:render, @style].compact.join('_')
+        public_send(method_name)
+      end
+
+      def optimal_format
+        DEFAULT_STYLES.fetch(level) { [:compact, {}] }
+      end
+
+      def render
+        format(object, *optimal_format)
+      end
+
+      def render_full
+        render_partial
+      end
+
+      def render_partial
+        format_string(render_inline, max_width: max_width, indent: indent)
+      end
+
+      def render_inline
+        render_compact
+      end
+
+      def render_compact
+        raise NotImplementedError
+      end
+
+      attr_reader :object, :options
+
+      def format_nested(other_object, style = nil, **options)
+        @console.format(other_object, style, **nested_opts(options))
+      end
+
+      def format(other_object, style = nil, **options)
+        @console.format(other_object, style, **nested_opts(options, increase_level: false))
+      end
+
+      def format_string(string, **options)
+        @console.format_string(string, **options)
+      end
+
+      def simple?
+        false
+      end
+
+      ColorizedString.colors.each do |color|
+        define_method color do |string|
+          ColorizedString.new(string).colorize(color)
+        end
+      end
+
+      def method_missing(name, *args)
+        return @options[name] if @options.key?(name)
+
+        super
+      end
+
+      def respond_to_missing?(name, private = false)
+        @options.key?(name) || super
+      end
+
+      private
+
+      def nested_objects
+        []
+      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] = nested_objects
+        new_options
+      end
+
+      def length_of(string)
+        ColorizedString.new(string).length
+      end
+
+      def yield_lines(&block)
+        LazyStringEvaluator.new(&block)
+      end
+    end
+  end
+end

data/lib/helium/console/printer.rb

@@ -11,15 +11,22 @@ module Helium
       end
 
       def pp(object)
-        formatted = Helium::Console.format(object)
-        output << "\n" if object.is_a? Registry::Element::LazyStringEvaluator
-        formatted.lines.each do |line|
-          output << "#{line.chomp}\n"
+        formatted = Helium::Console.format(object, max_width: maxwidth)
+        start_new_line = formatted.is_a?(Formatter::LazyStringEvaluator)
+        byebug if !formatted
+        start_new_line ||= formatted.lines.count > 1
+        start_new_line ||= length_of(formatted.chomp) >= maxwidth - 2
+        output << "\n" if start_new_line
+
+        formatted.lines.each.with_index do |line, index|
+          output << "\n" unless index.zero?
+          output << line.chomp
         end
-        output << "\n"
       end
 
-      ::Pry.config.print = method(:default)
+      def length_of(str)
+        ColorizedString.new(str).uncolorize.length
+      end
     end
   end
-end
+end

data/lib/helium/console/prompt.rb

@@ -0,0 +1,42 @@
+module Helium
+  class Console
+    class Prompt
+      def initialize
+        @line = 0
+      end
+
+      def pry_prompt
+        Pry::Prompt.new(
+          'helium',
+          'Default prompt for helium',
+          [
+            method(:active_prompt),
+            method(:wait_prompt)
+          ]
+        )
+      end
+
+      private
+
+      def active_prompt(context, _nesting, _pry)
+        @line += 1
+        str = [
+          ColorizedString.new("[#{@line}]").light_black,
+          ColorizedString.new("He\u269B").light_blue,
+          ColorizedString.new("(#{context.inspect})").magenta
+        ].join(' ')
+        "#{str}> "
+      end
+
+      def wait_prompt(context, nesting, pry)
+        @line += 1
+        str = [
+          ColorizedString.new("[#{@line}]").light_black,
+          '   ',
+          ColorizedString.new("(#{context.inspect})").magenta
+        ].join(' ')
+        "#{str}> "
+      end
+    end
+  end
+end

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

@@ -3,13 +3,23 @@
 module Helium
   class Console
     define_formatter_for Array 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?
 
         inline_without_truncation || format_as_table
       end
 
+      def render_inline
+        inline_with_truncation
+      end
+
       def simple?
         object.none?
       end
@@ -32,7 +42,7 @@ module Helium
       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 - 4)
+          break joined if max_width && too_long?(new_joined, max_width: max_width - 4)
 
           new_joined
         end
@@ -65,7 +75,7 @@ module Helium
       def trunc_message(count, all_truncated: false)
         return if count < 1
 
-        "(#{count} #{all_truncated ? 'elements' : 'more'})"
+        light_black "(#{count} #{all_truncated ? 'elements' : 'more'})"
       end
 
       def object_size

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

@@ -3,13 +3,13 @@
 module Helium
   class Console
     define_formatter_for TrueClass do
-      def call
+      def render_compact
         green('true')
       end
     end
 
     define_formatter_for FalseClass do
-      def call
+      def render_compact
         red('false')
       end
     end

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

@@ -3,9 +3,13 @@
 module Helium
   class Console
     define_formatter_for 'Date' do
-      def call
+      def render_inline
         blue object.strftime('%A, %d %b %Y')
       end
+
+      def render_comapact
+        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?
 
@@ -29,7 +35,7 @@ module Helium
       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,9 +61,10 @@ 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
@@ -81,6 +88,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,53 @@
+# 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
+
+      def as_table(source:)
+        table = Table.new(runner: light_black('| '), format_keys: false, after_key: light_black(': '))
+        table.row(magenta('receiver'), object.receiver)
+        table.row(magenta('location'), object.source_location&.join(':'))
+        table.row(magenta('source'), trimmed_source, :full) if source && object.source_location
+
+        yield_lines do |y|
+          y << "#{light_black '#'} #{render_compact}"
+          format(table).lines.each { |line| y << line }
+        end
+      end
+
+      def title
+        owner = object.owner
+        singleton = owner.singleton_class?
+
+        if singleton
+          owner = object.receiver
+          owner = owner.ancestors.find { |ancestor| ancestor.singleton_class == object.owner } if owner.is_a? Class
+        end
+
+        formatted_owner = format(owner, short: true, max_length: 20)
+        formatted_owner = "(#{formatted_owner})" unless owner.is_a? Module
+
+        "#{formatted_owner}#{yellow(singleton ? '.' : '#')}#{yellow object.name.to_s}"
+      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,7 +3,7 @@
 module Helium
   class Console
     define_formatter_for Numeric do
-      def call
+      def render_compact
         light_cyan(object.to_s)
       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
-
-        yield_lines do |y|
-          y << "#{light_black '#'} #{class_name}"
-          format(table).lines.each {|line| y << line }
-        end
+      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,14 +27,22 @@ module Helium
         [class_name, formatted_vars].compact.join
       end
 
-      def force_inline?
-        level > 2
-      end
 
-      def all_symbol?
-        object.keys.all? { |key| key.is_a? Symbol }
+      def render_partial
+        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
+
+        yield_lines do |y|
+          y << "#{light_black '#'} #{class_name}"
+          format(table).lines.each { |line| y << line }
+        end
       end
 
+      private
+
       def formatted_instance_variables(**options)
         object.instance_variables.sort.each.lazy.map do |var_name|
           value = object.instance_variable_get(var_name)
@@ -54,7 +51,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

@@ -3,8 +3,8 @@
 module Helium
   class Console
     define_formatter_for 'Pathname' do
-      def call
-        "#{format(Pathname, short: true)}: #{yellow(object.to_s)}"
+      def render_compact
+        "#{format(Pathname, :compact)}: #{yellow(object.to_s)}"
       end
     end
   end

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

@@ -3,9 +3,15 @@
 module Helium
   class Console
     define_formatter_for Set do
-      def call
+      def render_compact
+        return rendr_empty if object.none?
+
+        "#{light_magenta('Set:')} #{trunc_message(object.count, all_truncated: true)}"
+      end
+
+      def render_partial
         return "#{light_magenta('Set:')} #{red 'empty'}" if object.none?
-        return inline_with_truncation if force_inline?
+        return inline_with_truncation if options[:max_lines] == 1
 
         inline_without_truncation || format_as_table
       end
@@ -16,17 +22,21 @@ module Helium
 
       private
 
+      def render_empty
+        "#{light_magenta('Set:')} #{red 'empty'}" if object.none?
+      end
+
       def format_as_table
         table = Table.new(runner: '', format_keys: false)
         object.each do |element|
-          table.row(light_magenta('-'), element)
+          table.row(light_black('-'), element)
         end
 
-        [
-          light_magenta('Set: {'),
-          format(table),
-          light_magenta('}')
-        ].join("\n")
+        yield_lines do |y|
+          y << light_magenta('Set: {')
+          format(table).lines.each { |line| y << line }
+          y << light_magenta('}')
+        end
       end
 
       def inline_with_truncation
@@ -59,7 +69,8 @@ module Helium
       end
 
       def formatted_elements(**options)
-        object.sort.each.lazy.map { |element| format_nested(element, **options) }
+        sorted = object.sort rescue object
+        sorted.each.lazy.map { |element| format_nested(element, **options) }
       end
 
       def trunc_message(count, all_truncated: false)
@@ -71,10 +82,6 @@ module Helium
       def object_size
         @object_size ||= object.size
       end
-
-      def force_inline?
-        level > 2
-      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/table.rb

@@ -5,8 +5,8 @@ module Helium
     define_formatter_for Table do
       def call
         yield_lines do |y|
-          rows.each do |key, value, options = {}|
-            format_pair(key, value, **options) do |line|
+          rows.each do |key, value, style, options = {}|
+            format_pair(key, value, style, **options) do |line|
               y << line
             end
           end
@@ -16,8 +16,8 @@ module Helium
 
       private
 
-      def format_pair(key, value, **options)
-        formatted_value = format_nested(value, max_width: max_value_width, **options)
+      def format_pair(key, value, style, **options)
+        formatted_value = format_nested(value, style, max_width: max_value_width, **options)
 
         formatted_value.lines.each.with_index.map do |line, index|
           yield [

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

@@ -3,9 +3,13 @@
 module Helium
   class Console
     define_formatter_for Time do
-      def call
+      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,100 +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
-        class LazyStringEvaluator
-          def initialize(&block)
-            @lines = Enumerator.new { |y| block.(y) }
-          end
-
-          attr_reader :lines
-
-          def to_s
-            lines.to_a.join
-          end
-        end
-
-        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
-
-        private
-
-        def nested_objects
-          []
-        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] = nested_objects
-          new_options
-        end
-
-        def length_of(string)
-          ColorizedString.new(string).uncolorize.length
-        end
+      def self.instance_formatters
+        @instance_formatters ||= new
+      end
 
-        def yield_lines(&block)
-          LazyStringEvaluator.new(&block)
-        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)
-          break handlers[ancestor.name] if handlers.key?(ancestor.name)
+      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/table.rb

@@ -11,8 +11,8 @@ module Helium
 
       attr_reader :runner, :after_key, :format_keys
 
-      def row(key, value, **options)
-        rows << [key, value, options]
+      def row(key, value, style = nil, **options)
+        rows << [key, value, style, options]
       end
 
       def rows

data/lib/helium/console/version.rb

@@ -2,6 +2,6 @@
 
 module Helium
   class Console
-    VERSION = '0.1.11'
+    VERSION = '0.1.12'
   end
 end

data/lib/helium/console.rb

@@ -10,6 +10,7 @@ require 'helium/console/table'
 require 'helium/console/registry'
 
 require 'helium/console/printer'
+require 'helium/console/prompt'
 
 module Helium
   class Console
@@ -23,9 +24,30 @@ module Helium
       Symbol
     ].freeze
 
+    def self.start(target = nil, options = {})
+      prompt = ColorizedString.new("He\u269B").light_blue
+      line = 0
+
+      options = {
+        print: ColorPrinter.method(:default),
+        prompt: Prompt.new.pry_prompt
+      }.merge(options)
+
+      Pry.start(target, options)
+    end
+
+    def self.define_formatter_for(klass, &handler)
+      Registry.instance_formatters.define(klass, &handler)
+    end
+
+    def self.define_class_formatter_for(klass, &handler)
+      Registry.class_formatters.define(klass, &handler)
+    end
+
+
     class << self
       def instance
-        @instance ||= new(registry: Registry.new)
+        @instance ||= new
       end
 
       def method_missing(name, *args, &block)
@@ -39,51 +61,31 @@ module Helium
       end
     end
 
-    def initialize(registry:)
-      @registry = registry
-    end
-
-    def format(object, **options)
+    def format(object, style = nil, **options)
       options = default_options.merge(options)
       return '(...)' if options[:ignore_objects].include?(object.object_id)
 
-      handler = registry.handler_for(object, **options)
-
-      if handler
-        handler.()
-      else
-        format(object.inspect, **options)
-      end
-    end
-
-    def register(klass, &handler)
-      registry.add(klass, &handler)
-    end
-
-    def define_formatter_for(klass, &handler)
-      registry.define(klass, &handler)
+      handler_for(object, style, **options).()
     end
 
-    def simple?(object)
+    def simple?(object, style = nil, **options)
       SIMPLE_OBJECTS.any? { |simple_obj_class| object.is_a? simple_obj_class } ||
-        registry.handler_for(object).simple?
+        handler_for(object, style, **options).simple?
     end
 
     def default_options
       {
         overflow: :wrap,
         indent: 0,
-        max_width: `tput cols`.chomp.to_i,
         level: 1,
-        ignore_objects: []
+        ignore_objects: [],
+        short: false
       }
     end
 
     def format_string(string, ellipses: '...', **options)
       options = default_options.merge(options)
-
       formatters = [
-        Formatters::Overflow.get(options[:overflow]).new(max_width: options[:max_width] - options[:indent]),
         Formatters::Indent.new(options[:indent]),
         Formatters::MaxLines.new(
           max_lines: options[:max_lines],
@@ -91,6 +93,11 @@ module Helium
           ellipses: ellipses
         )
       ]
+      if options[:max_width]
+        formatters.unshift(
+          Formatters::Overflow.get(options[:overflow]).new(max_width: options[:max_width] - options[:indent]),
+        )
+      end
 
       formatters.inject(string) do |str, formatter|
         formatter.(str)
@@ -99,7 +106,15 @@ module Helium
 
     private
 
-    attr_reader :registry
+    # TODO: Injection instead of hard dependency!
+    def handler_for(object, style, **options)
+      formatter_class = if object.is_a? Module
+        Registry.class_formatters.handler_for(object)
+      else
+        Registry.instance_formatters.handler_for(object.class)
+      end
+      formatter_class&.new(object, style, self, **options)
+    end
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: helium-console
 version: !ruby/object:Gem::Version
-  version: 0.1.11
+  version: 0.1.12
 platform: ruby
 authors:
 - Stanislaw Klajn
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-09-03 00:00:00.000000000 Z
+date: 2021-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -59,16 +59,20 @@ files:
 - bin/setup
 - helium-console.gemspec
 - lib/helium/console.rb
+- lib/helium/console/colorized_string.rb
+- lib/helium/console/formatter.rb
 - lib/helium/console/formatters/indent.rb
 - lib/helium/console/formatters/max_lines.rb
 - lib/helium/console/formatters/overflow.rb
 - lib/helium/console/formatters/overflow/wrap.rb
 - lib/helium/console/printer.rb
+- lib/helium/console/prompt.rb
 - lib/helium/console/registry.rb
 - lib/helium/console/registry/array.rb
 - lib/helium/console/registry/booleans.rb
 - lib/helium/console/registry/date.rb
 - lib/helium/console/registry/hash.rb
+- lib/helium/console/registry/method.rb
 - lib/helium/console/registry/module.rb
 - lib/helium/console/registry/nil.rb
 - lib/helium/console/registry/numeric.rb
@@ -102,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Collection of tools for smooth integration with console