helium-console 0.1.10 → 0.1.11
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/Gemfile.lock +1 -1
- data/lib/helium/console/printer.rb +5 -2
- data/lib/helium/console/registry/array.rb +5 -5
- data/lib/helium/console/registry/hash.rb +10 -7
- data/lib/helium/console/registry/object.rb +4 -22
- data/lib/helium/console/registry/table.rb +13 -14
- data/lib/helium/console/registry.rb +24 -2
- data/lib/helium/console/version.rb +1 -1
- metadata +2 -2
    
        checksums.yaml
    CHANGED
    
    | @@ -1,7 +1,7 @@ | |
| 1 1 | 
             
            ---
         | 
| 2 2 | 
             
            SHA256:
         | 
| 3 | 
            -
              metadata.gz:  | 
| 4 | 
            -
              data.tar.gz:  | 
| 3 | 
            +
              metadata.gz: 8d935efaa6d5d2a98d58c2d0cea17911486522ce45bfd00432b089735994ce20
         | 
| 4 | 
            +
              data.tar.gz: c86a17fc7b04379249cf491da55086537f7f8983c47758d9b20438495f12039e
         | 
| 5 5 | 
             
            SHA512:
         | 
| 6 | 
            -
              metadata.gz:  | 
| 7 | 
            -
              data.tar.gz:  | 
| 6 | 
            +
              metadata.gz: 2ab8ca592e31437b6e70cd269cd961b8fc38c3e544b24aa2eecfbddce474ed22ebda4c704849271b847656e22d15b25feb169aedad5593f6267378e211b068bf
         | 
| 7 | 
            +
              data.tar.gz: 2915fa426caea028e549e9d55e5a4cb7799ef593cdd706529c9eac5bc582a841bdaaa67fb1480917df0543286a0d7743f5eb13b813b92ad4193eab207d49a378
         | 
    
        data/Gemfile.lock
    CHANGED
    
    
| @@ -12,8 +12,11 @@ module Helium | |
| 12 12 |  | 
| 13 13 | 
             
                  def pp(object)
         | 
| 14 14 | 
             
                    formatted = Helium::Console.format(object)
         | 
| 15 | 
            -
                     | 
| 16 | 
            -
                     | 
| 15 | 
            +
                    output << "\n" if object.is_a? Registry::Element::LazyStringEvaluator
         | 
| 16 | 
            +
                    formatted.lines.each do |line|
         | 
| 17 | 
            +
                      output << "#{line.chomp}\n"
         | 
| 18 | 
            +
                    end
         | 
| 19 | 
            +
                    output << "\n"
         | 
| 17 20 | 
             
                  end
         | 
| 18 21 |  | 
| 19 22 | 
             
                  ::Pry.config.print = method(:default)
         | 
| @@ -22,11 +22,11 @@ module Helium | |
| 22 22 | 
             
                      table.row(light_black("[#{index}]:"), element)
         | 
| 23 23 | 
             
                    end
         | 
| 24 24 |  | 
| 25 | 
            -
                     | 
| 26 | 
            -
                      '[' | 
| 27 | 
            -
                      format(table) | 
| 28 | 
            -
                      ']'
         | 
| 29 | 
            -
                     | 
| 25 | 
            +
                    yield_lines do |y|
         | 
| 26 | 
            +
                      y << '['
         | 
| 27 | 
            +
                      format(table).lines.each { |line| y << line }
         | 
| 28 | 
            +
                      y << ']'
         | 
| 29 | 
            +
                    end
         | 
| 30 30 | 
             
                  end
         | 
| 31 31 |  | 
| 32 32 | 
             
                  def inline_with_truncation
         | 
| @@ -13,17 +13,17 @@ module Helium | |
| 13 13 | 
             
                  private
         | 
| 14 14 |  | 
| 15 15 | 
             
                  def format_as_table
         | 
| 16 | 
            -
                    table = Table.new(runner: '  ', after_key: after_key, format_keys:  | 
| 16 | 
            +
                    table = Table.new(runner: '  ', after_key: after_key, format_keys: true)
         | 
| 17 17 | 
             
                    object.each do |key, value|
         | 
| 18 18 | 
             
                      key = light_blue(key.to_s) if all_symbol?
         | 
| 19 19 | 
             
                      table.row(key, value)
         | 
| 20 20 | 
             
                    end
         | 
| 21 21 |  | 
| 22 | 
            -
                     | 
| 23 | 
            -
                      '{' | 
| 24 | 
            -
                      format(table | 
| 25 | 
            -
                      '}'
         | 
| 26 | 
            -
                     | 
| 22 | 
            +
                    yield_lines do |y|
         | 
| 23 | 
            +
                      y << '{'
         | 
| 24 | 
            +
                      format(table).lines.each { |line| y << line }
         | 
| 25 | 
            +
                      y << '}'
         | 
| 26 | 
            +
                    end
         | 
| 27 27 | 
             
                  end
         | 
| 28 28 |  | 
| 29 29 | 
             
                  def inline_with_truncation
         | 
| @@ -63,7 +63,10 @@ module Helium | |
| 63 63 | 
             
                  end
         | 
| 64 64 |  | 
| 65 65 | 
             
                  def all_symbol?
         | 
| 66 | 
            -
                     | 
| 66 | 
            +
                    return false
         | 
| 67 | 
            +
                    return @all_symbol if defined?(@all_symbol)
         | 
| 68 | 
            +
             | 
| 69 | 
            +
                    @all_symbol = object.keys.all? { |key| key.is_a? Symbol }
         | 
| 67 70 | 
             
                  end
         | 
| 68 71 |  | 
| 69 72 | 
             
                  def format_key(key, **options)
         | 
| @@ -18,10 +18,10 @@ module Helium | |
| 18 18 | 
             
                      table.row(magenta(inst.to_s), object.instance_variable_get(inst))
         | 
| 19 19 | 
             
                    end
         | 
| 20 20 |  | 
| 21 | 
            -
                     | 
| 22 | 
            -
                      "#{light_black '#'} #{class_name}" | 
| 23 | 
            -
                      format(table)
         | 
| 24 | 
            -
                     | 
| 21 | 
            +
                    yield_lines do |y|
         | 
| 22 | 
            +
                      y << "#{light_black '#'} #{class_name}"
         | 
| 23 | 
            +
                      format(table).lines.each {|line| y << line }
         | 
| 24 | 
            +
                    end
         | 
| 25 25 | 
             
                  end
         | 
| 26 26 |  | 
| 27 27 | 
             
                  def inline_with_truncation
         | 
| @@ -38,24 +38,6 @@ module Helium | |
| 38 38 | 
             
                    [class_name, formatted_vars].compact.join
         | 
| 39 39 | 
             
                  end
         | 
| 40 40 |  | 
| 41 | 
            -
                  # def inline_without_truncation
         | 
| 42 | 
            -
                  #   joined = nil
         | 
| 43 | 
            -
                  #
         | 
| 44 | 
            -
                  #   object.each do |key, value|
         | 
| 45 | 
            -
                  #     return unless simple?(value)
         | 
| 46 | 
            -
                  #
         | 
| 47 | 
            -
                  #     formatted_key = format(key, level: 3, max_with: 15)
         | 
| 48 | 
            -
                  #     formatted_value = format(value, level: 3, max_width: 15)
         | 
| 49 | 
            -
                  #     formatted = "#{formatted_key} => #{formatted_value}"
         | 
| 50 | 
            -
                  #
         | 
| 51 | 
            -
                  #     joined = [joined, formatted].compact.join(', ')
         | 
| 52 | 
            -
                  #
         | 
| 53 | 
            -
                  #     return if joined.length > max_width - 4
         | 
| 54 | 
            -
                  #   end
         | 
| 55 | 
            -
                  #   joined = " #{joined} " if joined
         | 
| 56 | 
            -
                  #   ['{', joined, '}'].compact.join
         | 
| 57 | 
            -
                  # end
         | 
| 58 | 
            -
             | 
| 59 41 | 
             
                  def force_inline?
         | 
| 60 42 | 
             
                    level > 2
         | 
| 61 43 | 
             
                  end
         | 
| @@ -4,25 +4,23 @@ module Helium | |
| 4 4 | 
             
              class Console
         | 
| 5 5 | 
             
                define_formatter_for Table do
         | 
| 6 6 | 
             
                  def call
         | 
| 7 | 
            -
                     | 
| 8 | 
            -
                       | 
| 9 | 
            -
             | 
| 10 | 
            -
             | 
| 7 | 
            +
                    yield_lines do |y|
         | 
| 8 | 
            +
                      rows.each do |key, value, options = {}|
         | 
| 9 | 
            +
                        format_pair(key, value, **options) do |line|
         | 
| 10 | 
            +
                          y << line
         | 
| 11 | 
            +
                        end
         | 
| 12 | 
            +
                      end
         | 
| 13 | 
            +
                      y << truncation if truncation
         | 
| 14 | 
            +
                    end
         | 
| 11 15 | 
             
                  end
         | 
| 12 16 |  | 
| 13 17 | 
             
                  private
         | 
| 14 18 |  | 
| 15 | 
            -
                  def formatted_values
         | 
| 16 | 
            -
                    rows.flat_map do |key, value, options = {}|
         | 
| 17 | 
            -
                      format_pair(key, value, **options)
         | 
| 18 | 
            -
                    end
         | 
| 19 | 
            -
                  end
         | 
| 20 | 
            -
             | 
| 21 19 | 
             
                  def format_pair(key, value, **options)
         | 
| 22 20 | 
             
                    formatted_value = format_nested(value, max_width: max_value_width, **options)
         | 
| 23 21 |  | 
| 24 | 
            -
                    formatted_value.lines. | 
| 25 | 
            -
                      [
         | 
| 22 | 
            +
                    formatted_value.lines.each.with_index.map do |line, index|
         | 
| 23 | 
            +
                      yield [
         | 
| 26 24 | 
             
                        object.runner,
         | 
| 27 25 | 
             
                        text_or_blank(rjust(format_key(key), key_width), blank: index > 0),
         | 
| 28 26 | 
             
                        text_or_blank(object.after_key, blank: index > 0),
         | 
| @@ -59,7 +57,7 @@ module Helium | |
| 59 57 |  | 
| 60 58 | 
             
                  def rows
         | 
| 61 59 | 
             
                    @rows ||= case level
         | 
| 62 | 
            -
                      when 1 then  | 
| 60 | 
            +
                      when 1 then object.rows
         | 
| 63 61 | 
             
                      when 2 then rows_limited_by(10)
         | 
| 64 62 | 
             
                      else rows_limited_by(3)
         | 
| 65 63 | 
             
                    end
         | 
| @@ -74,7 +72,8 @@ module Helium | |
| 74 72 |  | 
| 75 73 | 
             
                    [
         | 
| 76 74 | 
             
                      object.runner,
         | 
| 77 | 
            -
                      light_black("(#{object.rows.length - rows.length} more)")
         | 
| 75 | 
            +
                      light_black("(#{object.rows.length - rows.length} more)"),
         | 
| 76 | 
            +
                      "\n"
         | 
| 78 77 | 
             
                    ].join
         | 
| 79 78 | 
             
                  end
         | 
| 80 79 | 
             
                end
         | 
| @@ -6,6 +6,18 @@ module Helium | |
| 6 6 | 
             
              class Console
         | 
| 7 7 | 
             
                class Registry
         | 
| 8 8 | 
             
                  class Element
         | 
| 9 | 
            +
                    class LazyStringEvaluator
         | 
| 10 | 
            +
                      def initialize(&block)
         | 
| 11 | 
            +
                        @lines = Enumerator.new { |y| block.(y) }
         | 
| 12 | 
            +
                      end
         | 
| 13 | 
            +
             | 
| 14 | 
            +
                      attr_reader :lines
         | 
| 15 | 
            +
             | 
| 16 | 
            +
                      def to_s
         | 
| 17 | 
            +
                        lines.to_a.join
         | 
| 18 | 
            +
                      end
         | 
| 19 | 
            +
                    end
         | 
| 20 | 
            +
             | 
| 9 21 | 
             
                    def initialize(object, **options)
         | 
| 10 22 | 
             
                      @object = object
         | 
| 11 23 | 
             
                      @options = options
         | 
| @@ -43,16 +55,26 @@ module Helium | |
| 43 55 | 
             
                      @options.key?(name) || ColorizedString.colors.include?(name) || super
         | 
| 44 56 | 
             
                    end
         | 
| 45 57 |  | 
| 58 | 
            +
                    private
         | 
| 59 | 
            +
             | 
| 60 | 
            +
                    def nested_objects
         | 
| 61 | 
            +
                      []
         | 
| 62 | 
            +
                    end
         | 
| 63 | 
            +
             | 
| 46 64 | 
             
                    def nested_opts(new_options, increase_level: true)
         | 
| 47 65 | 
             
                      new_options = options.merge(new_options)
         | 
| 48 66 | 
             
                      new_options[:level] += 1 if increase_level
         | 
| 49 | 
            -
                      new_options[:ignore_objects]  | 
| 67 | 
            +
                      new_options[:ignore_objects] = nested_objects
         | 
| 50 68 | 
             
                      new_options
         | 
| 51 69 | 
             
                    end
         | 
| 52 70 |  | 
| 53 71 | 
             
                    def length_of(string)
         | 
| 54 72 | 
             
                      ColorizedString.new(string).uncolorize.length
         | 
| 55 73 | 
             
                    end
         | 
| 74 | 
            +
             | 
| 75 | 
            +
                    def yield_lines(&block)
         | 
| 76 | 
            +
                      LazyStringEvaluator.new(&block)
         | 
| 77 | 
            +
                    end
         | 
| 56 78 | 
             
                  end
         | 
| 57 79 |  | 
| 58 80 | 
             
                  def add(klass, &handler)
         | 
| @@ -82,4 +104,4 @@ module Helium | |
| 82 104 | 
             
                  end
         | 
| 83 105 | 
             
                end
         | 
| 84 106 | 
             
              end
         | 
| 85 | 
            -
            end
         | 
| 107 | 
            +
            end
         | 
    
        metadata
    CHANGED
    
    | @@ -1,14 +1,14 @@ | |
| 1 1 | 
             
            --- !ruby/object:Gem::Specification
         | 
| 2 2 | 
             
            name: helium-console
         | 
| 3 3 | 
             
            version: !ruby/object:Gem::Version
         | 
| 4 | 
            -
              version: 0.1. | 
| 4 | 
            +
              version: 0.1.11
         | 
| 5 5 | 
             
            platform: ruby
         | 
| 6 6 | 
             
            authors:
         | 
| 7 7 | 
             
            - Stanislaw Klajn
         | 
| 8 8 | 
             
            autorequire: 
         | 
| 9 9 | 
             
            bindir: exe
         | 
| 10 10 | 
             
            cert_chain: []
         | 
| 11 | 
            -
            date: 2021- | 
| 11 | 
            +
            date: 2021-09-03 00:00:00.000000000 Z
         | 
| 12 12 | 
             
            dependencies:
         | 
| 13 13 | 
             
            - !ruby/object:Gem::Dependency
         | 
| 14 14 | 
             
              name: colorize
         |