ruby_jard 0.1.0 → 0.3.0

data/lib/ruby_jard/layout_picker.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # Pick layout smartly depending on current window height and width
+  class LayoutPicker
+    def initialize(width, height, layouts: RubyJard::Layouts, config: RubyJard.config)
+      @width = width
+      @height = height
+      @layouts = layouts
+      @config = config
+    end
+
+    def pick
+      unless @config.layout.nil?
+        return @layouts[@config.layout] || @layouts.fallback_layout
+      end
+
+      @layouts.each do |_name, template|
+        matched = true
+        matched &&= (
+          template.min_width.nil? ||
+          @width > template.min_width
+        )
+        matched &&= (
+          template.min_height.nil? ||
+          @height > template.min_height
+        )
+        return template if matched
+      end
+      @layouts.fallback_layout
+    end
+  end
+end

data/lib/ruby_jard/layouts.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'ruby_jard/layout'
+require 'ruby_jard/templates/layout_template'
+require 'ruby_jard/templates/screen_template'
+require 'ruby_jard/layout_picker'
+require 'ruby_jard/layout_calculator'
+
+module RubyJard
+  ##
+  # Layouts registry.
+  class Layouts
+    class << self
+      extend Forwardable
+      def_delegators :instance, :fallback_layout, :add_layout, :[], :get, :each
+
+      def instance
+        @instance ||= new
+      end
+    end
+
+    attr_reader :fallback_layout
+
+    def initialize(fallback_layout = RubyJard::Layouts::WideLayout)
+      @layout_registry = {}
+      @fallback_layout = fallback_layout
+    end
+
+    def add_layout(name, layout_class)
+      unless layout_class.is_a?(RubyJard::Templates::LayoutTemplate)
+        raise RubyJard::Error, "#{layout_class} must be a #{RubyJard::Templates::LayoutTemplate}"
+      end
+
+      @layout_registry[name] = layout_class
+    end
+
+    def [](name)
+      @layout_registry[name.to_s.strip]
+    end
+    alias_method :get, :[]
+
+    def each(&block)
+      @layout_registry.each(&block)
+    end
+  end
+end
+
+# Registering order is also priority when picking layout
+require 'ruby_jard/layouts/wide_layout'
+require 'ruby_jard/layouts/narrow_vertical_layout'
+require 'ruby_jard/layouts/narrow_horizontal_layout'
+require 'ruby_jard/layouts/tiny_layout'

data/lib/ruby_jard/layouts/narrow_horizontal_layout.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyJard
+  class Layouts
+    NarrowHorizontalLayout = RubyJard::Templates::LayoutTemplate.new(
+      min_width: 80,
+      min_height: 10,
+      fill_height: false,
+      children: [
+        RubyJard::Templates::LayoutTemplate.new(
+          height_ratio: 80,
+          width_ratio: 100,
+          children: [
+            RubyJard::Templates::ScreenTemplate.new(
+              screen: :source,
+              width_ratio: 60
+            ),
+            RubyJard::Templates::ScreenTemplate.new(
+              screen: :variables,
+              width_ratio: 40
+            )
+          ]
+        ),
+        RubyJard::Templates::ScreenTemplate.new(
+          height: 2,
+          screen: :menu
+        )
+      ]
+    )
+  end
+end
+RubyJard::Layouts.add_layout('narrow-horizontal', RubyJard::Layouts::NarrowHorizontalLayout)

data/lib/ruby_jard/layouts/narrow_vertical_layout.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyJard
+  class Layouts
+    NarrowVerticalLayout = RubyJard::Templates::LayoutTemplate.new(
+      min_width: 40,
+      min_height: 24,
+      fill_height: false,
+      children: [
+        RubyJard::Templates::LayoutTemplate.new(
+          height_ratio: 80,
+          width_ratio: 100,
+          children: [
+            RubyJard::Templates::ScreenTemplate.new(
+              screen: :source,
+              height_ratio: 60
+            ),
+            RubyJard::Templates::ScreenTemplate.new(
+              screen: :variables,
+              height_ratio: 40
+            )
+          ]
+        ),
+        RubyJard::Templates::ScreenTemplate.new(
+          height: 2,
+          screen: :menu
+        )
+      ]
+    )
+  end
+end
+RubyJard::Layouts.add_layout('narrow-vertical', RubyJard::Layouts::NarrowVerticalLayout)

data/lib/ruby_jard/layouts/tiny_layout.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RubyJard
+  class Layouts
+    TinyLayout = RubyJard::Templates::LayoutTemplate.new(
+      min_height: 10,
+      fill_height: false,
+      children: [
+        RubyJard::Templates::LayoutTemplate.new(
+          height_ratio: 80,
+          width_ratio: 100,
+          min_height: 7,
+          fill_height: true,
+          children: [
+            RubyJard::Templates::ScreenTemplate.new(
+              screen: :source,
+              height_ratio: 100
+            )
+          ]
+        ),
+        RubyJard::Templates::ScreenTemplate.new(
+          height: 2,
+          screen: :menu
+        )
+      ]
+    )
+  end
+end
+RubyJard::Layouts.add_layout('tiny', RubyJard::Layouts::TinyLayout)

data/lib/ruby_jard/layouts/wide_layout.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RubyJard
+  class Layouts
+    WideLayout = RubyJard::Templates::LayoutTemplate.new(
+      min_width: 120,
+      min_height: 24,
+      fill_height: false,
+      children: [
+        RubyJard::Templates::LayoutTemplate.new(
+          height_ratio: 80,
+          width_ratio: 50,
+          children: [
+            RubyJard::Templates::ScreenTemplate.new(
+              screen: :source,
+              height_ratio: 70,
+              adjust_mode: :expand
+            ),
+            RubyJard::Templates::ScreenTemplate.new(
+              screen: :backtrace,
+              height_ratio: 30,
+              min_height: 3
+            )
+          ]
+        ),
+        RubyJard::Templates::LayoutTemplate.new(
+          height_ratio: 80,
+          width_ratio: 50,
+          children: [
+            RubyJard::Templates::ScreenTemplate.new(
+              screen: :variables,
+              height_ratio: 80,
+              adjust_mode: :expand
+            ),
+            RubyJard::Templates::ScreenTemplate.new(
+              screen: :threads,
+              height_ratio: 20,
+              min_height: 3
+            )
+          ]
+        ),
+        RubyJard::Templates::ScreenTemplate.new(
+          height: 2,
+          screen: :menu
+        )
+      ]
+    )
+  end
+end
+RubyJard::Layouts.add_layout('wide', RubyJard::Layouts::WideLayout)

data/lib/ruby_jard/pager.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # Override Pry's pager system. Again, Pry doesn't support customizing pager. So...
+  class Pager
+    def initialize(pry_instance)
+      @pry_instance = pry_instance
+    end
+
+    def page(text)
+      open do |pager|
+        pager << text
+      end
+    end
+
+    def open(options = {})
+      pager = LessPager.new(@pry_instance, **options)
+      yield pager
+    rescue Pry::Pager::StopPaging
+      # Ignore
+    ensure
+      pager.close
+    end
+
+    private
+
+    def enabled?
+      !!@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, prompt: nil)
+        super(pry_instance.output)
+        @pry_instance = pry_instance
+        @buffer = ''
+
+        @pager_start_at_the_end = pager_start_at_the_end
+        @prompt = prompt
+
+        @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
+
+      def write(str)
+        if invoked_pager?
+          write_into_pager str
+        else
+          @tracker.record str
+          @buffer += str
+          if @tracker.page?
+            @pager = open_pager
+            write_into_pager(@buffer)
+          end
+        end
+      rescue Errno::EPIPE
+        raise Pry::Pager::StopPaging
+      end
+
+      def close
+        if invoked_pager?
+          @pager.close
+          @pry_instance.exec_hook :after_pager, self
+
+          list_prompt
+        elsif @tracker.row > @window_height / 2
+          @out.write @buffer
+
+          list_prompt
+        else
+          @out.write @buffer
+        end
+      end
+
+      def invoked_pager?
+        @pager
+      end
+
+      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(
+          less_command.join(' '), 'w',
+          out: @pry_instance.output, err: @pry_instance.output
+        )
+      end
+
+      def write_into_pager(str)
+        return unless invoked_pager?
+
+        @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