ruby_jard 0.1.0 → 0.3.0

data/lib/ruby_jard/decorators/path_decorator.rb

@@ -1,87 +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
+      def initialize(path_classifier: nil)
+        @path_classifier = path_classifier || RubyJard::PathClassifier.new
+      end
 
-      attr_reader :path, :lineno, :gem, :gem_version
+      def decorate(path, lineno = nil)
+        return ['at ???', 'at ???'] if path.nil?
 
-      def initialize(path, lineno)
-        @gem = nil
-        @gem_version = nil
-        @path = path
-        @lineno = lineno
-        @type = TYPE_UNKNOWN
+        type, *info = @path_classifier.classify(path)
 
-        decorate
-      end
+        lineno = ":#{lineno}" unless lineno.nil?
 
-      def decorate
-        if path.start_with?(Dir.pwd)
-          @type = TYPE_PWD
-          @path = @path[Dir.pwd.length..-1]
+        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
-          decorate_gem_path
+          path = compact_with_relative_path(path)
+          ["at #{path}#{lineno}", "#{path}#{lineno}"]
         end
-
-        @path = @path[1..-1] if @path.start_with?('/')
-      end
-
-      def gem?
-        @type == TYPE_GEM
       end
 
       private
 
-      def decorate_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
-
-          break
-        end
+        detail = "<#{gem_name}:#{relative_path}#{lineno}>"
+        ["in #{overview}", detail]
       end
 
-      def gem_paths
-        paths = []
+      def decorate_stdlib(_path, lineno, info)
+        lib_name, relative_path = info
 
-        if defined?(Gem)
-          Gem.path.each do |gem_path|
-            paths << File.join(gem_path, 'gems')
-            paths << gem_path
-          end
-        end
+        ["in <stdlib:#{lib_name}>", "<stdlib:#{relative_path}#{lineno}>"]
+      end
 
-        if defined?(Bundler)
-          bundle_path = Bundler.bundle_path.to_s
-          paths << File.join(bundle_path, 'gems')
-          paths << bundle_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
-
-        paths
+      rescue ArgumentError
+        # Fail to get relative path, ignore
+        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

data/lib/ruby_jard/decorators/source_decorator.rb

@@ -12,6 +12,8 @@ module RubyJard
         @file = file
         @lineno = lineno
         @window = window
+        @window_start = 0
+        @window_end = 0
         @codes = []
 
         decorate
@@ -25,7 +27,7 @@ module RubyJard
         end
 
         @window_start = @lineno - @window / 2
-        @window_start = 0 if @window_start.negative?
+        @window_start = 1 if @window_start <= 0
         @window_end = @window_start + @window
 
         until file.eof?

data/lib/ruby_jard/decorators/string_decorator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubyJard
+  module Decorators
+    ##
+    # A light decorator for a string. String should be escaped, and cut off.
+    class StringDecorator
+      def initialize(generic_decorator)
+        @generic_decorator = generic_decorator
+      end
+
+      def match?(variable)
+        RubyJard::Reflection.call_is_a?(variable, String)
+      end
+
+      # rubocop:disable Lint/UnusedMethodArgument
+      def decorate_multiline(variable, first_line_limit:, line_limit:, lines:, depth: 0)
+        [
+          decorate_singleline(variable, line_limit: first_line_limit)
+        ]
+      end
+
+      def decorate_singleline(variable, line_limit:, depth: 0)
+        inspection = variable.inspect[1..-1].chomp!('"')
+        str =
+          if inspection.length < line_limit - 2
+            inspection
+          else
+            inspection[0..line_limit - 4] + '…'
+          end
+        [
+
+          RubyJard::Span.new(content: '"', styles: :string),
+          RubyJard::Span.new(content: str, styles: :string),
+          RubyJard::Span.new(content: '"', styles: :string)
+        ]
+      end
+      # rubocop:enable Lint/UnusedMethodArgument
+    end
+  end
+end

data/lib/ruby_jard/decorators/struct_decorator.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RubyJard
+  module Decorators
+    ##
+    # Decorator for Struct.
+    # TODO: This one should handle Open Struct too
+    class StructDecorator
+      def initialize(generic_decorator)
+        @generic_decorator = generic_decorator
+        @attributes_decorator = RubyJard::Decorators::AttributesDecorator.new(generic_decorator)
+      end
+
+      def match?(variable)
+        RubyJard::Reflection.call_is_a?(variable, Struct)
+      end
+
+      def decorate_singleline(variable, line_limit:, depth: 0)
+        spans = [RubyJard::Span.new(content: '#<struct', margin_right: 1, styles: :text_dim)]
+        unless variable.class.name.nil?
+          spans << RubyJard::Span.new(content: variable.class.name.to_s, margin_right: 1, styles: :text_primary)
+        end
+        spans += @attributes_decorator.inline_pairs(
+          variable.members.each_with_index,
+          total: variable.length, line_limit: line_limit - spans.map(&:content_length).sum - 1,
+          process_key: false, depth: depth + 1,
+          value_proc: ->(key) { variable[key] }
+        )
+        spans << RubyJard::Span.new(content: '>', styles: :text_dim)
+      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
+
+      private
+
+      def do_decorate_multiline(variable, lines:, line_limit:, depth: 0)
+        spans = []
+        start = [RubyJard::Span.new(content: '#<struct', styles: :text_dim)]
+        unless variable.class.name.nil?
+          start << RubyJard::Span.new(content: variable.class.name.to_s, margin_left: 1, styles: :text_primary)
+        end
+        start << RubyJard::Span.new(content: '>', styles: :text_dim)
+        spans << start
+
+        item_count = 0
+        variable.members.each_with_index do |member, index|
+          spans << @attributes_decorator.pair(
+            member, variable[member], line_limit: line_limit, process_key: false, depth: depth + 1
+          )
+          item_count += 1
+          break if index >= lines - 2
+        end
+        spans << last_line(variable.length, item_count) if variable.length > item_count
+        spans
+      end
+
+      def last_line(total, item_count)
+        [
+          RubyJard::Span.new(
+            content: "▸ #{total - item_count} more...",
+            margin_left: 2, styles: :text_dim
+          )
+        ]
+      end
+    end
+  end
+end