helium-console 0.1.9 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bae4abb107ba24a4d9e30434e48cbfb8ff57b75b1bc5f636c2208a4af066b20
-  data.tar.gz: 910786c0c312352c2a202bc82646c38135fa8e1890318ba4f91e4fc4f9955467
+  metadata.gz: a7a2bce9c0f3fe1f94baf382a4f23d10b9fab87164dddbce7736a00a10357cf4
+  data.tar.gz: 420ff6d68c766405c2f29a7ee37cd7fa4d78341ac52769341c4ed54f995ccd24
 SHA512:
-  metadata.gz: 7d0cf4390043396e2dcf8f550b5ac4ef827dca0445abe9c740290a97d9c09c2986c1ab8b283870e2e9bf2821590c828033d86a6bd3247611a633f26f8d333009
-  data.tar.gz: 26a26250b08bdf800e852887047f8c8848886bee69afa105bdd456688af6ee570a22fd17889624c5113d34b081f98bb1f5790ebb8be0733f62d841a089ff0730
+  metadata.gz: 83528cf238a38ca7de2a49534233a1e8c2bce5c761291b1115114e7ac814096e669008445f063fe2eb1f3cdd4ef12de02258547344098cf776bed721ed95d666
+  data.tar.gz: 19f87c531bf302a9d66d8eced560fe81303d728ea778937396d4d439fc987d5fd9a97a88c39976df3431a65ca469c702f0aacca232e57587bbade9fd4ba99de0

data/.github/workflows/pull_request.yml

@@ -0,0 +1,37 @@
+name: Pull request
+
+on:
+  pull_request:
+
+jobs:
+  test:
+    name: Spec
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.6', '2.7', '3.0']
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+      - name: Run tests
+        run: bundle exec rspec
+
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 2.7
+          bundler-cache: true
+      - name: Run tests
+        run: bundle exec rubocop

data/.rspec

@@ -1,3 +1,2 @@
---format documentation
 --color
 --require spec_helper

data/.rubocop.yml

@@ -67,4 +67,22 @@ Style/NumericPredicate:
 Style/EachWithObject:
   Enabled: false
 
+RSpec/MultipleMemoizedHelpers:
+  Enabled: false
+
+RSpec/FilePath:
+  Enabled: false
+
+RSpec/DescribeMethod:
+  Enabled: false
+
+RSpec/DescribeClass:
+  Enabled: false
+
+Metrics/ParameterLists:
+  CountKeywordArgs: false
+
+Metrics/AbcSize:
+  Max: 20
+
 

data/Gemfile

@@ -12,3 +12,4 @@ gem 'byebug'
 gem 'rubocop', require: false
 gem 'rubocop-rspec', require: false
 gem 'rubocop-rake', require: false
+gem 'simplecov'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    helium-console (0.1.9)
+    helium-console (0.1.13)
       colorize
       pry
 
@@ -13,6 +13,7 @@ GEM
     coderay (1.1.3)
     colorize (0.8.1)
     diff-lcs (1.4.4)
+    docile (1.4.0)
     ffaker (2.18.0)
     method_source (1.0.0)
     parallel (1.20.1)
@@ -55,6 +56,12 @@ GEM
       rubocop (~> 1.0)
       rubocop-ast (>= 1.1.0)
     ruby-progressbar (1.11.0)
+    simplecov (0.21.2)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.3)
     unicode-display_width (2.0.0)
 
 PLATFORMS
@@ -69,6 +76,7 @@ DEPENDENCIES
   rubocop
   rubocop-rake
   rubocop-rspec
+  simplecov
 
 BUNDLED WITH
    2.1.4

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,31 @@
+# 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
+
+      module Helpers
+        ColorizedString.colors.each do |color|
+          define_method(color) do |string|
+            ColorizedString.new(string).colorize(color)
+          end
+        end
+
+        def length_of(string)
+          ColorizedString.new(string).length
+        end
+      end
+    end
+  end
+end

data/lib/helium/console/formatter.rb

@@ -0,0 +1,127 @@
+# 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
+        style, options = optimal_format
+        format(object, style, **options)
+      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
+
+      def build_key_value(&block)
+        key_value = KeyValue.new
+        block.(key_value)
+        key_value
+      end
+
+      def format_key_value(key_value, **options)
+        key_value.as_table(level: level, console: @console, max_width: max_width, **options)
+      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/formatters/overflow/wrap.rb

@@ -10,6 +10,8 @@ module Helium
           end
 
           def call(string)
+            return string unless @max_width
+
             result = string.lines.flat_map do |line|
               line.chomp.chars.each_slice(@max_width).map(&:join)
             end

data/lib/helium/console/key_value.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Helium
+  class Console
+    class KeyValue
+      def row(key, value, format_key: {}, format_value: {})
+        rows << [key, value, { format_key: format_key, format_value: format_value }]
+      end
+
+      def rows
+        @rows ||= []
+      end
+
+      def as_table(console:, max_width:, level:, left: '|', between: ' ', right: '', format_keys: {}, format_values: {})
+        TableFormatter.(
+          self,
+          console: console,
+          left: left,
+          between: between,
+          right: right,
+          key_options: format_keys,
+          value_options: format_values,
+          max_width: max_width,
+          level: level
+        )
+      end
+
+      class TableFormatter
+        include ColorizedString::Helpers
+
+        def self.call(*args, **options)
+          new(*args, **options).()
+        end
+
+        def initialize(
+          key_value,
+          console:,
+          level:,
+          left:,
+          between:,
+          right:,
+          max_width:,
+          key_options: {},
+          value_options: {}
+        )
+          @key_value = key_value
+          @console = console
+          @left = left
+          @between = between
+          @right = right
+          @max_width = max_width
+          @key_options = key_options
+          @level = level
+          @value_options = value_options
+
+          set_width_limits
+        end
+
+        def call
+          Formatter::LazyStringEvaluator.new do |y|
+            key_value.rows.each do |key, value, options|
+              format_entry(y, key, value, **options)
+            end
+          end
+        end
+
+        private
+
+        attr_reader :key_value, :console, :left, :between, :right, :key_options, :value_options, :max_width
+
+        def format_entry(yielder, key, value, format_key:, format_value:)
+          key = format(key, merge_options(key_options, format_key))
+          value = format(value, merge_options(value_options, format_value))
+          zip_lines(key, value) do |key_line, value_line, index|
+            yielder << [
+              left,
+              rjust(key_line, key_width),
+              index.zero? ? between : ' ' * length_of(between),
+              value_line,
+              right
+            ].join
+          end
+        end
+
+        def key_width
+          @key_width ||= key_value.rows.first(100).map do |key, _, format_key:, **|
+            length_of(format(key, merge_options(key_options, format_key)))
+          end.max
+        end
+
+        def format(object, options = {})
+          return object unless options
+
+          console.format(object, options.delete(:style), level: @level + 1, **options)
+        end
+
+        def merge_options(opt1, opt2)
+          return false unless opt1 && opt2
+
+          opt1.merge(opt2)
+        end
+
+        def set_default(hash, key, &block)
+          hash[key] = block.() if hash && !hash[key]
+        end
+
+        def zip_lines(str1, str2)
+          str1 = (str1.lines.each + [nil].cycle).lazy
+          str2 = (str2.lines.each + [nil].cycle).lazy
+          str1.zip(str2).with_index.each do |(line1, line2), index|
+            break unless line1 || line2
+
+            yield [line1 || '', line2 || '', index]
+          end
+        end
+
+        def set_width_limits
+          set_default(key_options, :max_width) { max_width / 3 }
+          set_default(value_options, :max_width) do
+            max_width - key_width - length_of(left) - length_of(between) - length_of(right)
+          end
+        end
+
+        def rjust(string, length)
+          ' ' * (length - length_of(string)) + string
+        end
+      end
+    end
+  end
+end

data/lib/helium/console/printer.rb

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

data/lib/helium/console/prompt.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+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
@@ -17,22 +27,23 @@ module Helium
       private
 
       def format_as_table
-        table = Table.new(runner: '  ', format_keys: false)
-        object.each.with_index do |element, index|
-          table.row(light_black("[#{index}]:"), element)
+        key_value = build_key_value do |kv|
+          object.each.with_index do |element, index|
+            kv.row(light_black("[#{index}]:"), element)
+          end
         end
 
-        [
-          '[',
-          format(table),
-          ']'
-        ].join("\n")
+        yield_lines do |y|
+          y << '['
+          format_key_value(key_value, left: '  ', format_keys: false).lines.each { |line| y << line }
+          y << ']'
+        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 - 4)
+          break joined if max_width && too_long?(new_joined, max_width: max_width - 4)
 
           new_joined
         end
@@ -65,7 +76,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