ruby_jard 0.2.3 → 0.3.0

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

data/lib/ruby_jard/decorators/path_decorator.rb

@@ -1,100 +1,83 @@
 # frozen_string_literal: true
 
 require 'pathname'
+require 'rbconfig'
 
 module RubyJard
   module Decorators
     ##
     # Simplify and generate labels to indicate the location of a path.
-    # If it's from gem, strip Gem paths, or Bundler paths to expose relative
-    # location of the file.
-    # If it's from the current working dir, strip the working dir.
+    # The return value is an array of two elements. The first one is overview,
+    # the second is detailed path location.
     class PathDecorator
-      GEM_PATTERN = /(.*)-(\d+\.\d+[.\d]*[.\d]*[-.\w]*)/i.freeze
-      PATH_TYPES = [
-        TYPE_UNKNOWN = :unknown,
-        TYPE_PWD = :pwd,
-        TYPE_GEM = :gem
-      ].freeze
-
-      attr_reader :path, :lineno, :gem, :gem_version
-
-      def initialize(path, lineno)
-        @gem = nil
-        @gem_version = nil
-        @path = path.to_s
-        @lineno = lineno
-        @type = TYPE_UNKNOWN
-
-        decorate
+      def initialize(path_classifier: nil)
+        @path_classifier = path_classifier || RubyJard::PathClassifier.new
       end
 
-      def decorate
-        try_parse_gem_path
-        return if gem?
-
-        @type = TYPE_PWD
-        if @path.start_with?(Dir.pwd)
-          @path = @path[Dir.pwd.length..-1]
-          @path = @path[1..-1] if @path.start_with?('/')
+      def decorate(path, lineno = nil)
+        return ['at ???', 'at ???'] if path.nil?
+
+        type, *info = @path_classifier.classify(path)
+
+        lineno = ":#{lineno}" unless lineno.nil?
+
+        case type
+        when RubyJard::PathClassifier::TYPE_SOURCE_TREE
+          path = File.expand_path(path)
+          decorate_source_tree(path, lineno)
+        when RubyJard::PathClassifier::TYPE_GEM
+          decorate_gem(path, lineno, info)
+        when RubyJard::PathClassifier::TYPE_STDLIB
+          decorate_stdlib(path, lineno, info)
+        when RubyJard::PathClassifier::TYPE_INTERNAL
+          ["in #{path}", path]
+        when RubyJard::PathClassifier::TYPE_EVALUATION
+          ["at #{path}#{lineno}", "#{path}#{lineno}"]
+        when RubyJard::PathClassifier::TYPE_RUBY_SCRIPT
+          ["at (-e ruby script)#{lineno}", "(-e ruby script)#{lineno}"]
         else
-          try_relative_path
+          path = compact_with_relative_path(path)
+          ["at #{path}#{lineno}", "#{path}#{lineno}"]
         end
       end
 
-      def gem?
-        @type == TYPE_GEM
-      end
-
       private
 
-      def try_parse_gem_path
-        gem_paths.each do |gem_path|
-          next unless path.start_with?(gem_path)
+      def decorate_source_tree(path, lineno)
+        path = path[Dir.pwd.length..-1]
+        path = path[1..-1] if path.start_with?('/')
+        path = "#{path}#{lineno}"
+        ["at #{path}", path]
+      end
 
-          @type = TYPE_GEM
-          splitted_path =
-            @path[gem_path.length..-1]
-            .split('/')
-            .reject(&:empty?)
-          @path = splitted_path[1..-1].join('/')
-          @gem = splitted_path.first
-          match = GEM_PATTERN.match(@gem)
-          if match
-            @gem = match[1]
-            @gem_version = match[2]
+      def decorate_gem(_path, lineno, info)
+        gem_name, gem_version, relative_path = info
+        overview =
+          if gem_version.nil?
+            "<#{gem_name}>"
+          else
+            "<#{gem_name} #{gem_version}>"
           end
+        detail = "<#{gem_name}:#{relative_path}#{lineno}>"
+        ["in #{overview}", detail]
+      end
 
-          break
-        end
+      def decorate_stdlib(_path, lineno, info)
+        lib_name, relative_path = info
+
+        ["in <stdlib:#{lib_name}>", "<stdlib:#{relative_path}#{lineno}>"]
       end
 
-      def try_relative_path
-        relative_path = Pathname.new(@path).relative_path_from(Pathname.pwd).to_s
-        if relative_path.length < @path.length
-          @path = relative_path
+      def compact_with_relative_path(path)
+        relative_path = Pathname.new(path).relative_path_from(Pathname.pwd).to_s
+        if relative_path.length < path.length
+          relative_path
+        else
+          path
         end
       rescue ArgumentError
         # Fail to get relative path, ignore
-      end
-
-      def gem_paths
-        paths = []
-
-        if defined?(Gem)
-          Gem.path.each do |gem_path|
-            paths << File.join(gem_path, 'gems')
-            paths << gem_path
-          end
-        end
-
-        if defined?(Bundler)
-          bundle_path = Bundler.bundle_path.to_s
-          paths << File.join(bundle_path, 'gems')
-          paths << bundle_path
-        end
-
-        paths
+        path
       end
     end
   end

data/lib/ruby_jard/decorators/rails_decorator.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module RubyJard
+  module Decorators
+    ##
+    # A collection of rails-specific decorators.
+    # Why?
+    # Because Rails is magic, and it is like stepping on a minefield. Rails objects
+    # can trigger side-effects (like calling database queries, or even API queries).
+    # And from the end-user perspective, Rails' internal variables are useless. They
+    # care more about database attributes, which requires some extra steps to display
+    # if I don't want to use `#inspect`.
+    class RailsDecorator
+      ##
+      # Individual Active Record object is trivial. The object is a mapping from a DB
+      # entity to Ruby object. It is always in the memory.
+      class ActiveRecordBaseDecorator
+        def initialize(generic_decorator)
+          @generic_decorator = generic_decorator
+          @attributes_decorator = RubyJard::Decorators::AttributesDecorator.new(generic_decorator)
+        end
+
+        def match?(variable)
+          return false unless defined?(ActiveRecord::Base)
+
+          RubyJard::Reflection.call_is_a?(variable, ActiveRecord::Base)
+        end
+
+        def decorate_singleline(variable, line_limit:, depth: 0)
+          label = RubyJard::Span.new(
+            content: RubyJard::Reflection.call_to_s(variable).chomp!('>'),
+            margin_right: 1, styles: :text_primary
+          )
+          spans = [label]
+          spans += @attributes_decorator.inline_pairs(
+            variable.attributes.each_with_index,
+            total: variable.attributes.length, line_limit: line_limit - label.content_length - 2,
+            process_key: false, depth: depth + 1
+          )
+          spans << RubyJard::Span.new(content: '>', styles: :text_primary)
+        end
+
+        def decorate_multiline(variable, first_line_limit:, lines:, line_limit:, depth: 0)
+          singleline = decorate_singleline(variable, line_limit: first_line_limit)
+
+          if singleline.map(&:content_length).sum < line_limit
+            [singleline]
+          else
+            spans = [RubyJard::Span.new(content: RubyJard::Reflection.call_to_s(variable), styles: :text_primary)]
+
+            item_count = 0
+            variable.attributes.each_with_index do |(key, value), index|
+              spans << @attributes_decorator.pair(
+                key, value, line_limit: line_limit, process_key: false, depth: depth + 1
+              )
+              item_count += 1
+              break if index >= lines - 2
+            end
+            if variable.attributes.length > item_count
+              spans << [RubyJard::Span.new(
+                content: "▸ #{variable.attributes.length - item_count} more...",
+                margin_left: 2, styles: :text_dim
+              )]
+            end
+            spans
+          end
+        end
+      end
+
+      ##
+      # When creating an active record relation, Rails won't trigger any SQL query, until
+      # to_ary events. It is required to check for records loaded before recursively display
+      # its children. Hint if the relation is not loaded yet.
+      class ActiveRecordRelationDecorator
+        def initialize(generic_decorator)
+          @generic_decorator = generic_decorator
+          @attributes_decorator = RubyJard::Decorators::AttributesDecorator.new(generic_decorator)
+        end
+
+        def match?(variable)
+          return false unless defined?(ActiveRecord::Relation)
+
+          RubyJard::Reflection.call_class(variable) < ActiveRecord::Relation
+        rescue StandardError
+          false
+        end
+
+        def decorate_singleline(variable, line_limit:, depth: 0)
+          if variable.respond_to?(:loaded?) && variable.loaded?
+            spans = []
+            label = RubyJard::Span.new(
+              content: RubyJard::Reflection.call_to_s(variable).chomp('>'), styles: :text_primary
+            )
+            spans << label
+            spans += @attributes_decorator.inline_values(
+              variable.each_with_index,
+              total: variable.length, line_limit: line_limit - label.content_length - 2,
+              depth: depth + 1
+            )
+            spans << RubyJard::Span.new(content: '>', styles: :text_primary)
+
+            spans
+          else
+            relation_summary(variable, 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)
+          if singleline.map(&:content_length).sum < line_limit
+            [singleline]
+          elsif !variable.respond_to?(:loaded?) || !variable.loaded?
+            [relation_summary(variable, first_line_limit)]
+          else
+            spans = [[RubyJard::Span.new(content: RubyJard::Reflection.call_to_s(variable), styles: :text_primary)]]
+
+            item_count = 0
+            variable.each_with_index do |value, index|
+              spans << @attributes_decorator.value(value, line_limit: line_limit, depth: depth + 1)
+
+              item_count += 1
+              break if index >= lines - 2
+            end
+            if variable.length > item_count
+              spans << [RubyJard::Span.new(
+                content: "▸ #{variable.length - item_count} more...",
+                margin_left: 2, styles: :text_dim
+              )]
+            end
+            spans
+          end
+        end
+
+        private
+
+        def relation_summary(variable, line_limit)
+          overview = RubyJard::Reflection.call_to_s(variable).chomp('>')
+          width = overview.length + 1 + 12
+          spans = [RubyJard::Span.new(content: overview, styles: :text_primary)]
+          if RubyJard::Reflection.call_respond_to?(variable, :to_sql) && width < line_limit
+            detail = variable.to_sql
+            detail = detail[0..line_limit - width - 2] + '…' if width + detail.length < line_limit
+            spans << RubyJard::Span.new(content: detail, styles: :text_dim, margin_left: 1)
+          end
+          spans << RubyJard::Span.new(content: '>', styles: :text_primary)
+          spans << RubyJard::Span.new(content: '(not loaded)', margin_left: 1, styles: :text_dim)
+          spans
+        end
+      end
+
+      def initialize(generic_decorator)
+        @generic_decorator = generic_decorator
+        @sub_decorators = [
+          @active_record_base_decorator = ActiveRecordBaseDecorator.new(generic_decorator),
+          @active_record_relation_decorator = ActiveRecordRelationDecorator.new(generic_decorator)
+        ]
+      end
+
+      def match?(variable)
+        @sub_decorators.any? { |sub_decorator| sub_decorator.match?(variable) }
+      rescue StandardError
+        false
+      end
+
+      def decorate_singleline(variable, line_limit:, depth: 0)
+        @sub_decorators.each do |sub_decorator|
+          next unless sub_decorator.match?(variable)
+
+          return sub_decorator.decorate_singleline(
+            variable, line_limit: line_limit, depth: depth
+          )
+        end
+
+        nil
+      end
+
+      def decorate_multiline(variable, first_line_limit:, lines:, line_limit:, depth: 0)
+        @sub_decorators.each do |sub_decorator|
+          next unless sub_decorator.match?(variable)
+
+          return sub_decorator.decorate_multiline(
+            variable,
+            first_line_limit: first_line_limit,
+            lines: lines,
+            line_limit: line_limit,
+            depth: depth
+          )
+        end
+
+        nil
+      end
+    end
+  end
+end