ruby_jard 0.2.3 → 0.3.0

data/lib/ruby_jard/decorators/attributes_decorator.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module RubyJard
+  module Decorators
+    TYPICAL_DEPTH = 3
+    MAX_DEPTH = 5
+    DO_NOT_WASTE_LENGTH = 40
+    ##
+    # Decorate collection data structure. Support:
+    # - Collection of values
+    # - Collection of key-value pairs
+    # - Individual value
+    # - Individual pair
+    # This decorator should not be used directly.
+    class AttributesDecorator
+      def initialize(generic_decorator)
+        @generic_decorator = generic_decorator
+      end
+
+      def inline_pairs(enum, total:, line_limit:, process_key:, value_proc: nil, depth: 0)
+        return [ellipsis_span] if too_deep?(depth, line_limit)
+
+        spans = []
+        width = 1
+        item_limit = total == 0 ? 0 : [line_limit / total, pair_limit(depth)].max
+
+        enum.each do |(key, value), index|
+          key_inspection = inspect_key(key, item_limit, process_key: process_key, depth: depth)
+          key_inspection_length = key_inspection.map(&:content_length).sum
+
+          value_inspection = @generic_decorator.decorate_singleline(
+            value_proc.nil? ? value : value_proc.call(key),
+            line_limit: [item_limit - key_inspection_length, pair_limit(depth)].max, depth: depth
+          )
+          value_inspection_length = value_inspection.map(&:content_length).sum
+
+          if index > 0
+            spans << separator_span
+            width += 2
+          end
+
+          if width + key_inspection_length + value_inspection_length + 5 > line_limit
+            spans << ellipsis_span
+            break
+          end
+
+          spans += key_inspection
+          width += key_inspection_length
+
+          spans << arrow_span
+          width += 3
+
+          spans += value_inspection
+          width += value_inspection_length
+        end
+
+        spans
+      end
+
+      def pair(key, value, line_limit:, process_key:, depth: 0)
+        return [ellipsis_span] if too_deep?(depth, line_limit)
+
+        spans = []
+        spans << indent_span
+        width = indent_span.content_length
+
+        key_inspection = inspect_key(key, line_limit - width, process_key: process_key, depth: depth)
+        key_inspection_length = key_inspection.map(&:content_length).sum
+
+        spans += key_inspection
+        width += key_inspection_length
+
+        spans << arrow_span
+        width += 3
+
+        value_inspection = @generic_decorator.decorate_singleline(
+          value, line_limit: [line_limit - width, pair_limit(depth)].max, depth: depth
+        )
+
+        spans + value_inspection
+      end
+
+      def inline_values(enum, total:, line_limit:, depth: 0)
+        return [ellipsis_span] if too_deep?(depth, line_limit)
+
+        spans = []
+        width = 1
+        item_limit = total == 0 ? 0 : [line_limit / total, value_limit(depth)].max
+
+        enum.each do |value, index|
+          value_inspection = @generic_decorator.decorate_singleline(
+            value, line_limit: [item_limit, value_limit(depth)].max, depth: depth
+          )
+          value_inspection_length = value_inspection.map(&:content_length).sum
+
+          if index > 0
+            spans << separator_span
+            width += 2
+          end
+
+          if width + value_inspection_length + 2 > line_limit
+            spans << ellipsis_span
+            break
+          end
+
+          spans += value_inspection
+          width += value_inspection_length
+        end
+
+        spans
+      end
+
+      def value(value, line_limit:, depth: 0)
+        return [ellipsis_span] if too_deep?(depth, line_limit)
+
+        spans = []
+        spans << indent_span
+        width = indent_span.content_length
+
+        value_inspection = @generic_decorator.decorate_singleline(
+          value, line_limit: [line_limit - width, value_limit(depth)].max, depth: depth
+        )
+
+        spans + value_inspection
+      end
+
+      private
+
+      def inspect_key(key, item_limit, process_key:, depth: 0)
+        if process_key
+          @generic_decorator.decorate_singleline(
+            key, line_limit: item_limit, depth: depth
+          )
+        else
+          [RubyJard::Span.new(content: key.to_s, styles: :text_primary)]
+        end
+      end
+
+      def arrow_span
+        RubyJard::Span.new(content: '→', margin_left: 1, margin_right: 1, styles: :text_highlighted)
+      end
+
+      def separator_span
+        RubyJard::Span.new(content: ',', margin_right: 1, styles: :text_primary)
+      end
+
+      def ellipsis_span
+        RubyJard::Span.new(content: '…', styles: :text_dim)
+      end
+
+      def indent_span
+        RubyJard::Span.new(content: '▸', margin_right: 1, margin_left: 2, styles: :text_dim)
+      end
+
+      def too_deep?(depth, line_limit)
+        return true if depth > MAX_DEPTH
+        return false if line_limit > DO_NOT_WASTE_LENGTH
+
+        depth > TYPICAL_DEPTH
+      end
+
+      def pair_limit(depth)
+        # The deeper structure, the less meaningful the actual data is
+        30 - depth * 5
+      end
+
+      def value_limit(_depth)
+        30
+      end
+    end
+  end
+end

data/lib/ruby_jard/decorators/color_decorator.rb

@@ -23,22 +23,29 @@ module RubyJard
 
       CSI_ITALIC = "\e[3m"
       CSI_UNDERLINE = "\e[4m"
+      CSI_BOLD = "\e[1m"
 
       STYLES_CSI_MAP = {
         underline: CSI_UNDERLINE,
-        italic: CSI_ITALIC
+        italic: CSI_ITALIC,
+        bold: CSI_BOLD
       }.freeze
 
       def initialize(color_scheme)
         @color_scheme = color_scheme
       end
 
-      # TODO: rename and replace #decorate by this method
-      def decorate(element, content)
-        styles = @color_scheme.styles_for(element) || []
+      def decorate(style_names, content)
+        attributes = nil
+        if style_names.is_a?(Symbol)
+          styles = @color_scheme.styles_for(style_names)
+        else
+          attributes = translate_styles(style_names)
+          styles = @color_scheme.styles_for(style_names.shift)
+        end
         foreground = translate_color(styles.shift, true)
         background = translate_color(styles.shift, false)
-        "#{foreground}#{background}#{translate_styles(styles)}#{content}#{CSI_RESET}"
+        "#{foreground}#{background}#{attributes}#{content}#{CSI_RESET}"
       end
 
       def translate_color(color, foreground)

data/lib/ruby_jard/decorators/hash_decorator.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RubyJard
+  module Decorators
+    ##
+    # Decorate Hash data structure, supports singleline and multiline form.
+    class HashDecorator
+      def initialize(generic_decorator)
+        @generic_decorator = generic_decorator
+        @attributes_decorator = RubyJard::Decorators::AttributesDecorator.new(generic_decorator)
+      end
+
+      def decorate_singleline(variable, line_limit:, depth: 0)
+        spans = []
+        spans << RubyJard::Span.new(content: '{', styles: :text_primary)
+        spans += @attributes_decorator.inline_pairs(
+          variable.each_with_index,
+          total: variable.length, line_limit: line_limit - 2, process_key: true, depth: depth + 1
+        )
+        spans << RubyJard::Span.new(content: '}', styles: :text_primary)
+      end
+
+      def decorate_multiline(variable, first_line_limit:, lines:, line_limit:, depth: 0)
+        if variable.size > lines * 1.5
+          return do_decorate_multiline(variable, lines: lines, line_limit: line_limit, depth: depth)
+        end
+
+        singleline = decorate_singleline(variable, line_limit: first_line_limit)
+        if singleline.map(&:content_length).sum < line_limit || variable.length <= 1
+          [singleline]
+        else
+          do_decorate_multiline(variable, lines: lines, line_limit: line_limit, depth: depth)
+        end
+      end
+
+      def match?(variable)
+        RubyJard::Reflection.call_is_a?(variable, Hash)
+      end
+
+      private
+
+      def do_decorate_multiline(variable, lines:, line_limit:, depth: 0)
+        spans = [[RubyJard::Span.new(content: '{', styles: :text_primary)]]
+
+        item_count = 0
+        variable.each_with_index do |(key, value), index|
+          spans << @attributes_decorator.pair(
+            key, value, line_limit: line_limit, process_key: true, depth: depth + 1
+          )
+          item_count += 1
+          break if index >= lines - 2
+        end
+        spans << last_line(variable.length, item_count)
+      end
+
+      def last_line(total, item_count)
+        if total > item_count
+          [
+            RubyJard::Span.new(
+              content: "▸ #{total - item_count} more...",
+              margin_left: 2, styles: :text_dim
+            ),
+            RubyJard::Span.new(
+              content: '}',
+              styles: :text_primary
+            )
+          ]
+        else
+          [RubyJard::Span.new(content: '}', styles: :text_primary)]
+        end
+      end
+    end
+  end
+end

data/lib/ruby_jard/decorators/inspection_decorator.rb

@@ -1,76 +1,109 @@
 # frozen_string_literal: true
 
+require 'ruby_jard/decorators/array_decorator'
+require 'ruby_jard/decorators/string_decorator'
+require 'ruby_jard/decorators/hash_decorator'
+require 'ruby_jard/decorators/struct_decorator'
+require 'ruby_jard/decorators/object_decorator'
+require 'ruby_jard/decorators/attributes_decorator'
+require 'ruby_jard/decorators/rails_decorator'
+
 module RubyJard
-  # PP subclass for streaming inspect output in color.
-  class InspectionDecorator < ::PP::SingleLine
-    def self.inspect(obj, output = [], max_width = 79)
-      queue = new(output, max_width)
-      queue.guard_inspect_key { queue.pp obj }
-      queue.flush
+  module Decorators
+    ##
+    # Generate beauty inspection of a particular variable.
+    # The inspection doesn't aim to become a better version of PP. Instead,
+    # it's scope is to generate an overview of a variable within a limited
+    # space. So, it only keeps useful information, and tries to reach the
+    # very shallow layers of a nested data structure.
+    # This class is inspired by Ruby's PP:
+    # https://github.com/ruby/ruby/blob/master/lib/pp.rb
+    class InspectionDecorator
+      PRIMITIVE_TYPES = {
+        # Intertal classes for those values may differ between Ruby versions
+        # For example: Bignum is renamed to Integer
+        # So, it's safer to use discrete value's class as the key for this mapping.
+        true.class.name => :literal,
+        false.class.name => :literal,
+        1.class.name => :literal,
+        1.1.class.name => :literal,
+        1.to_r.class.name => :literal, # Rational: (1/1)
+        1.to_c.class.name => :literal, # Complex: (1+0i)
+        :sym.class.name => :literal,
+        //.class.name => :literal, # TODO: create a new class to handle range
+        (0..0).class.name => :literal,
+        nil.class.name => :text_dim,
+        Class.class.name => :text_primary, # Sorry, I lied, Class will never change
+        Proc.name => :text_primary # TODO: create a new class to handle proc.
+      }.freeze
 
-      queue.output.flatten
-    end
+      def initialize
+        @klass_decorators = [
+          @array_decorator = ArrayDecorator.new(self),
+          @string_decorator = StringDecorator.new(self),
+          @hash_decorator = HashDecorator.new(self),
+          @struct_decorator = StructDecorator.new(self),
+          @rails_decorator = RailsDecorator.new(self)
+        ]
+        @object_decorator = ObjectDecorator.new(self)
+      end
 
-    attr_reader :output
+      def decorate_singleline(variable, line_limit:, depth: 0)
+        if primitive?(variable)
+          return decorate_primitive(variable, line_limit)
+        end
 
-    def initialize(output, max_width = nil, new_line = nil)
-      @output = output
-      @first = [true]
-      @max_width = max_width
-      @width = 0
-      @new_line = new_line
-      @loc_decorator = RubyJard::Decorators::LocDecorator.new
-    end
+        @klass_decorators.each do |klass_decorator|
+          next unless klass_decorator.match?(variable)
 
-    def pp(object)
-      return if @width > @max_width
-      return super unless object.is_a?(String)
+          spans = klass_decorator.decorate_singleline(variable, line_limit: line_limit, depth: depth)
+          return spans unless spans.nil?
+        end
+        @object_decorator.decorate_singleline(variable, line_limit: line_limit, depth: depth)
+      end
 
-      puts @output.length
-      text(object.inspect)
-    end
+      def decorate_multiline(variable, first_line_limit:, lines:, line_limit:, depth: 0)
+        if primitive?(variable)
+          return decorate_primitive(variable, first_line_limit)
+        end
 
-    def text(str, _max_width = str.length)
-      if str.start_with?('#<') || ['>'].include?(str)
-        append_output(str, :object)
-      elsif [' ', '=', '=>'].include?(str)
-        append_output(str, :trivial_inspection)
-      elsif str.start_with?("\e")
-        append_output(str.gsub(/\e/i, '\e'), :trivial_inspection)
-      else
-        spans, _tokens = @loc_decorator.decorate(str)
-        spans.each do |span|
-          break if @width > @max_width
+        @klass_decorators.each do |klass_decorator|
+          next unless klass_decorator.match?(variable)
 
-          @output << span
-          @width += span.content_length
+          spans = klass_decorator.decorate_multiline(
+            variable,
+            first_line_limit: first_line_limit,
+            lines: lines,
+            line_limit: line_limit,
+            depth: depth
+          )
+          return spans unless spans.nil?
         end
+        @object_decorator.decorate_multiline(
+          variable,
+          first_line_limit: first_line_limit,
+          lines: lines,
+          line_limit: line_limit,
+          depth: depth
+        )
       end
-    end
 
-    def breakable(sep = ' ', _width = nil)
-      append_output(sep, :trivial_inspection)
-    end
+      private
 
-    def group(_indent = nil, open_obj = nil, close_obj = nil, _open_width = nil, _close_width = nil)
-      @first.push true
-      append_output(open_obj, :normal_token) unless open_obj.nil?
-      yield
-      append_output(close_obj, :normal_token) unless close_obj.nil?
-      @first.pop
-    end
-
-    def append_output(str, style)
-      return if str.empty?
-      return if @width > @max_width
+      def primitive?(variable)
+        !PRIMITIVE_TYPES[RubyJard::Reflection.call_class(variable).name].nil?
+      end
 
-      @output << Span.new(
-        span_template: nil,
-        content: str,
-        content_length: str.length,
-        styles: style
-      )
-      @width += str.length
+      def decorate_primitive(variable, line_limit)
+        inspection = variable.inspect
+        inspection = inspection[0..line_limit - 2] + '…' if inspection.length >= line_limit
+        [
+          RubyJard::Span.new(
+            content: inspection,
+            styles: PRIMITIVE_TYPES[RubyJard::Reflection.call_class(variable).name]
+          )
+        ]
+      end
     end
   end
 end