ruby_jard 0.2.3 → 0.3.0

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

data/lib/ruby_jard/frame.rb

@@ -6,42 +6,55 @@ module RubyJard
   # access to Byebug's internal data structure, provides some more helpers
   # and make Jard easier to test.
   class Frame
-    attr_reader :pos
+    attr_reader :real_pos
+    attr_writer :visible
+    attr_accessor :virtual_pos
 
-    def initialize(context, pos)
+    def initialize(context, real_pos, virtual_pos: nil)
       @context = context
-      @pos = pos
+      @real_pos = real_pos
+      @virtual_pos = virtual_pos
+
+      @visible = true
+    end
+
+    def visible?
+      @visible == true
+    end
+
+    def hidden?
+      @visible == false
     end
 
     def frame_file
-      @context.frame_file(@pos)
+      @context.frame_file(@real_pos)
     end
 
     def frame_line
-      @context.frame_line(@pos)
+      @context.frame_line(@real_pos)
     end
 
     def frame_location
-      frame_backtrace = @context.backtrace[@pos]
+      frame_backtrace = @context.backtrace[@real_pos]
       return nil if frame_backtrace.nil?
 
       frame_backtrace.first
     end
 
     def frame_self
-      @context.frame_self(@pos)
+      @context.frame_self(@real_pos)
     end
 
     def frame_class
-      @context.frame_class(@pos)
+      @context.frame_class(@real_pos)
     end
 
     def frame_binding
-      @context.frame_binding(@pos)
+      @context.frame_binding(@real_pos)
     end
 
     def frame_method
-      @context.frame_method(@pos)
+      @context.frame_method(@real_pos)
     end
 
     def c_frame?

data/lib/ruby_jard/keys.rb

@@ -35,6 +35,7 @@ module RubyJard
     SHIFT_F11 = "\e[23;2~"
     SHIFT_F12 = "\e[24;2~"
     DEFAULT_KEY_BINDINGS = {
+      F2       => (ACTION_FILTER   = :switch_filter),
       F5       => (ACTION_LIST     = :list),
       F6       => (ACTION_UP       = :up),
       SHIFT_F6 => (ACTION_DOWN     = :down),

data/lib/ruby_jard/layouts/narrow_horizontal_layout.rb

@@ -20,6 +20,10 @@ module RubyJard
               width_ratio: 40
             )
           ]
+        ),
+        RubyJard::Templates::ScreenTemplate.new(
+          height: 2,
+          screen: :menu
         )
       ]
     )

data/lib/ruby_jard/layouts/tiny_layout.rb

@@ -17,6 +17,10 @@ module RubyJard
               height_ratio: 100
             )
           ]
+        ),
+        RubyJard::Templates::ScreenTemplate.new(
+          height: 2,
+          screen: :menu
         )
       ]
     )

data/lib/ruby_jard/pager.rb

@@ -29,17 +29,25 @@ module RubyJard
       !!@enabled
     end
 
+    ##
+    # Pager tracker in Pry does not expose enough
+    class JardPageTracker < Pry::Pager::PageTracker
+      attr_reader :row, :col
+    end
+
     ##
     # Pager using GNU Less
     class LessPager < Pry::Pager::NullPager
-      def initialize(pry_instance, force_open: false, pager_start_at_the_end: false)
+      def initialize(pry_instance, force_open: false, pager_start_at_the_end: false, prompt: nil)
         super(pry_instance.output)
         @pry_instance = pry_instance
         @buffer = ''
 
         @pager_start_at_the_end = pager_start_at_the_end
+        @prompt = prompt
 
-        @tracker = Pry::Pager::PageTracker.new(height, width)
+        @window_width, @window_height = RubyJard::Console.screen_size(@pry_instance.output)
+        @tracker = JardPageTracker.new(@window_height, @window_width)
         @pager = force_open ? open_pager : nil
       end
 
@@ -63,9 +71,11 @@ module RubyJard
           @pager.close
           @pry_instance.exec_hook :after_pager, self
 
-          prompt = @pry_instance.prompt.wait_proc.call
-          # TODO: should show this tip even pager not invoked, when the size exceed a certain height
-          @out.puts "#{prompt}Tips: You can use `list` command to show back debugger screens"
+          list_prompt
+        elsif @tracker.row > @window_height / 2
+          @out.write @buffer
+
+          list_prompt
         else
           @out.write @buffer
         end
@@ -78,6 +88,7 @@ module RubyJard
       def open_pager
         @pry_instance.exec_hook :before_pager, self
         less_command = ['less', '-R', '-X']
+        less_command << "--prompt \"#{@prompt}\"" if @prompt
         less_command << '+G' if @pager_start_at_the_end
 
         IO.popen(
@@ -91,6 +102,11 @@ module RubyJard
 
         @pager.write str.encode('UTF-8', undef: :replace)
       end
+
+      def list_prompt
+        prompt = @pry_instance.prompt.wait_proc.call
+        @out.puts "#{prompt}Tips: You can use `list` command to show back debugger screens"
+      end
     end
   end
 end

data/lib/ruby_jard/path_classifier.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'rbconfig'
+
+module RubyJard
+  ##
+  # Classify a particular path by its orign such as stdlib, gem, evaluation, etc.
+  # Usage
+  #   type, *info = PathClassifier.new.class('lib/abc')
+  class PathClassifier
+    GEM_PATTERN = /(.*)-(\d+\.\d+[.\d]*[.\d]*[-.\w]*)/i.freeze
+    STDLIB_PATTERN = /(.*)\.rb$/.freeze
+    INTERNAL_PATTERN = /<internal:[^>]+>/.freeze
+    EVALUATION_SIGNATURE = '(eval)'
+    RUBY_SCRIPT_SIGNATURE = '-e'
+
+    TYPES = [
+      TYPE_SOURCE_TREE = :source_tree,
+      TYPE_GEM = :gem,
+      TYPE_STDLIB = :stdlib,
+      TYPE_INTERNAL = :internal,
+      TYPE_EVALUATION = :evaluation,
+      TYPE_RUBY_SCRIPT = :ruby_script,
+      TYPE_UNKNOWN = :unknown
+    ].freeze
+
+    def initialize
+      @gem_paths = fetch_gem_paths
+    end
+
+    def classify(path)
+      return TYPE_UNKNOWN if path.nil?
+
+      return TYPE_INTERNAL if try_classify_internal(path)
+
+      return TYPE_EVALUATION if try_classify_evaluation(path)
+
+      return TYPE_RUBY_SCRIPT if try_classify_ruby_script(path)
+
+      return TYPE_SOURCE_TREE if try_classify_source_tree(path)
+
+      matched, *info = try_classify_gem(path)
+      return TYPE_GEM, *info if matched
+
+      matched, *info = try_classify_stdlib(path)
+      return TYPE_STDLIB, *info if matched
+
+      TYPE_UNKNOWN
+    end
+
+    private
+
+    def try_classify_gem(path)
+      @gem_paths.each do |gem_path|
+        next unless path.start_with?(gem_path)
+
+        splitted_path =
+          path[gem_path.length..-1]
+          .split('/')
+          .reject(&:empty?)
+        gem_name = splitted_path.shift
+        gem_version = nil
+
+        match = GEM_PATTERN.match(gem_name)
+        if match
+          gem_name = match[1]
+          gem_version = match[2]
+        end
+
+        return true, gem_name, gem_version, splitted_path.join('/')
+      end
+
+      false
+    end
+
+    def try_classify_internal(path)
+      # https://github.com/ruby/ruby/blob/master/template/prelude.c.tmpl#L18
+      path =~ INTERNAL_PATTERN
+    end
+
+    def try_classify_stdlib(path)
+      lib_dir = RbConfig::CONFIG['rubylibdir'].to_s.strip
+
+      return false if lib_dir.empty?
+      return false unless path.start_with?(lib_dir)
+
+      splitted_path =
+        path[lib_dir.length..-1]
+        .split('/')
+        .reject(&:empty?)
+      lib_name = splitted_path.first
+      match = STDLIB_PATTERN.match(lib_name)
+      lib_name = match[1] if match
+
+      [true, lib_name, splitted_path.join('/')]
+    rescue NameError
+      # RbConfig is not available
+      false
+    end
+
+    def try_classify_evaluation(path)
+      path == EVALUATION_SIGNATURE
+    end
+
+    def try_classify_ruby_script(path)
+      path == RUBY_SCRIPT_SIGNATURE
+    end
+
+    def try_classify_source_tree(path)
+      path.start_with?(Dir.pwd)
+    end
+
+    def fetch_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
+    end
+  end
+end

data/lib/ruby_jard/path_filter.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # Check whether a particular path should be passed when debugging.
+  # Filtering is based on path classification (from PathClassifier),
+  # program's current filter mode, and filter included, excluded.
+  class PathFilter
+    FILTERS = [
+      FILTER_SOURCE_TREE = :source_tree,
+      FILTER_APPLICATION = :application,
+      FILTER_GEMS = :gems,
+      FILTER_EVERYTHING = :everything
+    ].freeze
+    def initialize(config: nil, path_classifier: nil)
+      @config = config || RubyJard.config
+      @path_classifier = path_classifier || RubyJard::PathClassifier.new
+    end
+
+    def match?(path)
+      case @config.filter
+      when FILTER_EVERYTHING
+        match_everything?(path)
+      when FILTER_GEMS
+        match_gems?(path)
+      when FILTER_APPLICATION
+        match_application?(path)
+      when FILTER_SOURCE_TREE
+        match_source_tree?(path)
+      end
+    end
+
+    private
+
+    def match_everything?(path)
+      return true if @config.filter_excluded.empty?
+
+      type, *info = @path_classifier.classify(path)
+
+      case type
+      when RubyJard::PathClassifier::TYPE_SOURCE_TREE, RubyJard::PathClassifier::TYPE_UNKNOWN
+        !match_excluded?(path)
+      when RubyJard::PathClassifier::TYPE_GEM
+        !match_excluded?(info[0], expand_path: false) && !match_excluded?(path)
+      when RubyJard::PathClassifier::TYPE_STDLIB
+        !match_excluded?(info[0], expand_path: false) && !match_excluded?(path)
+      else
+        true
+      end
+    end
+
+    def match_gems?(path)
+      type, *info = @path_classifier.classify(path)
+
+      case type
+      when RubyJard::PathClassifier::TYPE_SOURCE_TREE, RubyJard::PathClassifier::TYPE_UNKNOWN
+        !match_excluded?(path)
+      when RubyJard::PathClassifier::TYPE_GEM
+        !match_excluded?(info[0], expand_path: false) && !match_excluded?(path)
+      when RubyJard::PathClassifier::TYPE_STDLIB
+        match_included?(info[0], expand_path: false) || match_included?(path)
+      when RubyJard::PathClassifier::TYPE_RUBY_SCRIPT, RubyJard::PathClassifier::TYPE_EVALUATION
+        true
+      when RubyJard::PathClassifier::TYPE_INTERNAL
+        false
+      end
+    end
+
+    def match_application?(path)
+      type, *info = @path_classifier.classify(path)
+
+      case type
+      when RubyJard::PathClassifier::TYPE_SOURCE_TREE, RubyJard::PathClassifier::TYPE_UNKNOWN
+        !match_excluded?(path)
+      when RubyJard::PathClassifier::TYPE_GEM, RubyJard::PathClassifier::TYPE_STDLIB
+        match_included?(info[0], expand_path: false) || match_included?(path)
+      when RubyJard::PathClassifier::TYPE_RUBY_SCRIPT
+        true
+      when RubyJard::PathClassifier::TYPE_EVALUATION
+        false
+      when RubyJard::PathClassifier::TYPE_INTERNAL
+        false
+      end
+    end
+
+    def match_source_tree?(path)
+      type, *info = @path_classifier.classify(path)
+
+      case type
+      when RubyJard::PathClassifier::TYPE_SOURCE_TREE
+        !match_excluded?(path)
+      when RubyJard::PathClassifier::TYPE_UNKNOWN
+        match_included?(path)
+      when RubyJard::PathClassifier::TYPE_GEM, RubyJard::PathClassifier::TYPE_STDLIB
+        match_included?(info[0], expand_path: false) || match_included?(path)
+      when RubyJard::PathClassifier::TYPE_RUBY_SCRIPT
+        true
+      when RubyJard::PathClassifier::TYPE_EVALUATION
+        false
+      when RubyJard::PathClassifier::TYPE_INTERNAL
+        false
+      end
+    end
+
+    def match_excluded?(path, expand_path: true)
+      @config.filter_excluded.any? do |excluded|
+        if expand_path
+          File.fnmatch(File.expand_path(excluded), path)
+        else
+          File.fnmatch(excluded, path)
+        end
+      end
+    end
+
+    def match_included?(path, expand_path: true)
+      @config.filter_included.any? do |included|
+        if expand_path
+          File.fnmatch(File.expand_path(included), path)
+        else
+          File.fnmatch(included, path)
+        end
+      end
+    end
+  end
+end