ruby_jard 0.1.0 → 0.3.0

data/lib/ruby_jard/decorators/inspection_decorator.rb

@@ -0,0 +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
+  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
+
+      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
+
+      def decorate_singleline(variable, line_limit:, depth: 0)
+        if primitive?(variable)
+          return decorate_primitive(variable, line_limit)
+        end
+
+        @klass_decorators.each do |klass_decorator|
+          next unless klass_decorator.match?(variable)
+
+          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
+
+      def decorate_multiline(variable, first_line_limit:, lines:, line_limit:, depth: 0)
+        if primitive?(variable)
+          return decorate_primitive(variable, first_line_limit)
+        end
+
+        @klass_decorators.each do |klass_decorator|
+          next unless klass_decorator.match?(variable)
+
+          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
+
+      private
+
+      def primitive?(variable)
+        !PRIMITIVE_TYPES[RubyJard::Reflection.call_class(variable).name].nil?
+      end
+
+      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

data/lib/ruby_jard/decorators/loc_decorator.rb

@@ -1,135 +1,126 @@
 # frozen_string_literal: true
 
+require 'coderay'
+
 module RubyJard
   module Decorators
     ##
     # Decorate a line of code fetched from the source file.
     # The line is tokenized, and feed into JardEncoder to append color (with
-    # Pastel).
+    # Span).
     class LocDecorator
-      attr_reader :loc, :tokens
-
-      def initialize(color_decorator, loc, highlighted)
-        @loc = loc
-        @highlighted = highlighted
-        @encoder = JardLocEncoder.new(
-          color_decorator: color_decorator,
-          highlighted: highlighted
-        )
+      def initialize
+        @encoder = JardLocEncoder.new
+      end
 
-        decorate
+      def decorate(loc, file = nil)
+        tokens = CodeRay.scan(loc, extension(file))
+        spans = @encoder.encode_tokens(tokens)
+        [spans, tokens]
       end
 
-      def decorate
-        @tokens = CodeRay.scan(@loc, :ruby)
-        @loc = @encoder.encode_tokens(tokens)
+      private
+
+      def extension(file)
+        # TODO: A map constant is better
+        if file =~ /.*\.erb$/
+          :erb
+        elsif file =~ /.*\.haml$/
+          :haml
+        else
+          :ruby
+        end
       end
 
       # A shameless copy from https://github.com/rubychan/coderay/blob/master/lib/coderay/encoders/terminal.rb
       class JardLocEncoder < CodeRay::Encoders::Encoder
-        TOKEN_COLORS = {
-          debug: [:white, :on_blue],
-          annotation: [:blue],
-          attribute_name: [:blue],
-          attribute_value: [:blue],
+        DEFAULT_STYLE = :normal_token
+        TOKEN_STYLES = {
+          annotation: :keyword,
+          attribute_name: :keyword,
+          attribute_value: :keyword,
           binary: {
-            self: [:blue],
-            char: [:blue],
-            delimiter: [:blue]
+            self: :keyword,
+            char: :keyword,
+            delimiter: :keyword
           },
           char: {
-            self: [:blue],
-            delimiter: [:blue]
+            self: :keyword,
+            delimiter: :keyword
           },
-          class: [:underline, :green],
-          class_variable: [:green],
-          color: [:green],
+          class: :constant,
+          class_variable: :constant,
+          color: :constant,
           comment: {
-            self: [:white],
-            char: [:white],
-            delimiter: [:white]
+            self: :comment,
+            char: :comment,
+            delimiter: :comment
           },
-          constant: [:underline, :green],
-          decorator: [:blue],
-          definition: [:blue],
-          directive: [:blue],
-          docstring: [:blue],
-          doctype: [:blue],
-          done: [:blue],
-          entity: [:blue],
-          error: [:white, :on_red],
-          exception: [:blue],
-          float: [:blue],
-          function: [:green],
-          method: [:green],
-          global_variable: [:green],
-          hex: [:blue],
-          id: [:blue],
-          include: [:blue],
-          integer: [:blue],
-          imaginary: [:blue],
-          important: [:blue],
+          constant: :constant,
+          decorator: :keyword,
+          definition: :keyword,
+          directive: :keyword,
+          docstring: :keyword,
+          doctype: :keyword,
+          done: :keyword,
+          entity: :keyword,
+          error: :constant,
+          exception: :keyword,
+          float: :literal,
+          function: :constant,
+          method: :method,
+          global_variable: :constant,
+          hex: :keyword,
+          id: :keyword,
+          include: :keyword,
+          integer: :literal,
+          imaginary: :keyword,
+          important: :keyword,
           key: {
-            self: [:blue],
-            char: [:blue],
-            delimiter: [:blue]
+            self: :literal,
+            char: :literal,
+            delimiter: :literal
           },
-          label: [:blue],
-          local_variable: [:blue],
-          namespace: [:blue],
-          octal: [:blue],
-          predefined: [:blue],
-          predefined_constant: [:blue],
-          predefined_type: [:green],
-          preprocessor: [:blue],
-          pseudo_class: [:blue],
+          label: :literal,
+          local_variable: :keyword,
+          namespace: :keyword,
+          octal: :keyword,
+          predefined: :keyword,
+          predefined_constant: :keyword,
+          predefined_type: :constant,
+          preprocessor: :keyword,
+          pseudo_class: :keyword,
           regexp: {
-            self: [:blue],
-            delimiter: [:blue],
-            modifier: [:blue],
-            char: [:blue]
+            self: :keyword,
+            delimiter: :keyword,
+            modifier: :keyword,
+            char: :keyword
           },
-          reserved: [:blue],
-          keyword: [:blue],
+          reserved: :keyword,
+          keyword: :keyword,
           shell: {
-            self: [:blue],
-            char: [:blue],
-            delimiter: [:blue],
-            escape: [:blue]
+            self: :keyword,
+            char: :keyword,
+            delimiter: :keyword,
+            escape: :keyword
           },
           string: {
-            self: [:blue],
-            modifier: [:blue],
-            char: [:blue],
-            delimiter: [:blue],
-            escape: [:blue]
+            self: :string,
+            modifier: :string,
+            char: :string,
+            delimiter: :string,
+            escape: :string,
+            content: :string
           },
           symbol: {
-            self: [:blue],
-            delimiter: [:blue]
-          },
-          tag: [:green],
-          type: [:blue],
-          value: [:blue],
-          variable: [:blue],
-          insert: {
-            self: [:on_green],
-            insert: [:green, :on_green],
-            eyecatcher: [:italic]
+            self: :literal,
+            delimiter: :literal
           },
-          delete: {
-            self: [:on_red],
-            delete: [:blue, :on_red],
-            eyecatcher: [:italic]
-          },
-          change: {
-            self: [:on_blue],
-            change: [:white, :on_blue]
-          },
-          head: {
-            self: [:on_red],
-            filename: [:white, :on_red]
-          }
+          tag: :constant,
+          type: :keyword,
+          value: :keyword,
+          variable: :keyword,
+          instance_variable: :instance_variable
         }.freeze
 
         protected
@@ -137,9 +128,8 @@ module RubyJard
         def setup(options)
           super
           @opened = []
-          @color_scopes = [TOKEN_COLORS]
-          @color_decorator = options[:color_decorator]
-          @highlighted = options[:highlighted]
+          @color_scopes = [TOKEN_STYLES]
+          @out = []
         end
 
         public
@@ -147,19 +137,26 @@ module RubyJard
         def text_token(text, kind)
           color = @color_scopes.last[kind]
           text.gsub!("\n", '')
-          if color
-            color = color[:self] if color.is_a? Hash
-            @out << @color_decorator.decorate(text, *compose_color(color))
-          else
-            @out << @color_decorator.decorate(text, *compose_color([]))
-          end
+          style =
+            if !color
+              DEFAULT_STYLE
+            elsif color.is_a? Hash
+              color[:self]
+            else
+              color
+            end
+          @out << Span.new(
+            content: text,
+            content_length: text.length,
+            styles: style.to_sym
+          )
         end
 
         def begin_group(kind)
           @opened << kind
           open_token(kind)
         end
-        alias begin_line begin_group
+        alias_method :begin_line, :begin_group
 
         def end_group(_kind)
           return unless @opened.pop
@@ -186,14 +183,6 @@ module RubyJard
               @color_scopes.last
             end
         end
-
-        def compose_color(color)
-          if @highlighted
-            [:clear] + color
-          else
-            [:dim] + color
-          end
-        end
       end
     end
   end

data/lib/ruby_jard/decorators/object_decorator.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RubyJard
+  module Decorators
+    ##
+    # Default decorator for non-primitive data structure. It is aimed to replace default `inspect`.
+    # If a variable re-implement `#inspect`, it hornors this decision, but still try to
+    # parse the result.
+    # Otherwise, it use `Kernel#to_s`, and try to push instance variables into the result.
+    class ObjectDecorator
+      DEFAULT_INSPECTION_PATTERN = /#<(.*:0x[0-9a-z]+)(.*)>/i.freeze
+
+      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)
+        if native_inspect?(variable)
+          decorate_native_inspection(variable, line_limit: line_limit, depth: depth)
+        else
+          decorate_custom_inspection(variable, line_limit: line_limit)
+        end
+      end
+
+      def decorate_multiline(variable, first_line_limit:, lines:, line_limit:, depth: 0)
+        singleline = decorate_singleline(variable, line_limit: first_line_limit)
+        return [singleline] if singleline.map(&:content_length).sum < line_limit
+
+        spans = [decorate_native_inspection(variable, line_limit: first_line_limit, with_children: false)]
+
+        item_count = 0
+        instance_variables = RubyJard::Reflection.call_instance_variables(variable)
+        instance_variables.each do |key|
+          spans << @attributes_decorator.pair(
+            key, RubyJard::Reflection.call_instance_variable_get(variable, key),
+            line_limit: line_limit, process_key: false, depth: depth + 1
+          )
+
+          item_count += 1
+          break if item_count >= lines - 2
+        end
+
+        if instance_variables.length > item_count
+          spans << [
+            RubyJard::Span.new(
+              content: "▸ #{instance_variables.length - item_count} more...",
+              margin_left: 2, styles: :text_dim
+            )
+          ]
+        end
+
+        spans
+      end
+
+      private
+
+      def native_inspect?(variable)
+        return true unless RubyJard::Reflection.call_respond_to?(variable, :inspect)
+
+        RubyJard::Reflection.bind_call(::Kernel, :method, variable, :inspect).owner == ::Kernel
+      end
+
+      def call_inspect(variable)
+        variable.inspect
+      rescue StandardError
+        RubyJard::Reflection.call_to_s(variable)
+      end
+
+      def decorate_native_inspection(variable, line_limit:, depth: 0, with_children: true)
+        raw_inspection = RubyJard::Reflection.call_to_s(variable)
+        match = raw_inspection.match(DEFAULT_INSPECTION_PATTERN)
+
+        if match
+          instance_variables = RubyJard::Reflection.call_instance_variables(variable)
+          spans = [
+            RubyJard::Span.new(content: '#<', styles: :text_primary),
+            RubyJard::Span.new(content: match[1], styles: :text_primary)
+          ]
+          if with_children && !instance_variables.empty?
+            spans << RubyJard::Span.new(content: ' ', styles: :text_primary)
+            spans += @attributes_decorator.inline_pairs(
+              instance_variables.each_with_index, total: instance_variables.length,
+              line_limit: line_limit - spans.map(&:content_length).sum - 1,
+              depth: depth + 1, process_key: false,
+              value_proc: ->(key) { RubyJard::Reflection.call_instance_variable_get(variable, key) }
+            )
+          end
+          spans << RubyJard::Span.new(content: '>', styles: :text_primary)
+          spans
+        elsif raw_inspection.length <= line_limit
+          [RubyJard::Span.new(content: raw_inspection[0..line_limit], styles: :text_primary)]
+        else
+          [RubyJard::Span.new(content: raw_inspection[0..line_limit - 3] + '…>', styles: :text_primary)]
+        end
+      end
+
+      def decorate_custom_inspection(variable, line_limit:)
+        raw_inspection = call_inspect(variable)
+        match = raw_inspection.match(DEFAULT_INSPECTION_PATTERN)
+        if match
+          detail =
+            if match[2].length < line_limit - match[1].length - 3
+              match[2]
+            else
+              match[2][0..line_limit - match[1].length - 4] + '…'
+            end
+          [
+            RubyJard::Span.new(content: '#<', styles: :text_primary),
+            RubyJard::Span.new(content: match[1], styles: :text_primary),
+            RubyJard::Span.new(content: detail, styles: :text_dim),
+            RubyJard::Span.new(content: '>', styles: :text_primary)
+          ]
+        elsif raw_inspection.length <= line_limit
+          [RubyJard::Span.new(content: raw_inspection[0..line_limit], styles: :text_primary)]
+        else
+          [RubyJard::Span.new(content: raw_inspection[0..line_limit - 3] + '…>', styles: :text_primary)]
+        end
+      end
+    end
+  end
+end