ruby_jard 0.1.0 → 0.3.0

data/lib/ruby_jard/screens/variables_screen.rb

@@ -1,208 +1,245 @@
 # frozen_string_literal: true
 
 module RubyJard
-  module Screens
+  class Screens
+    ##
+    # Display the relevant variables and constants of current context, scopes
     class VariablesScreen < RubyJard::Screen
-      TYPE_SYMBOLS = {
-        # 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 => :bool,
-        false.class => :bool,
-        1.class => :int,
-        1.1.class => :flt,
-        1.to_r.class => :rat, # Rational: (1/1)
-        1.to_c.class => :com, # Complex: (1+0i)
-        ''.class => :str,
-        :sym.class => :sym,
-        [].class => :arr,
-        {}.class => :hash,
-        //.class => :reg,
-        Class => :cls # Sorry, I lied, Class will never change
-      }.freeze
-      TYPE_SYMBOL_PADDING = TYPE_SYMBOLS.map { |_, s| s.to_s.length }.max + 1
-      DEFAULT_TYPE_SYMBOL = :var
-
-      INSPECTION_ELLIPSIS = ' [...]'
-
       KINDS = [
-        KIND_LOC = :loc,
-        KIND_INS = :ins,
-        KIND_CON = :con
+        KIND_SELF = :self,
+        KIND_LOC  = :local_variable,
+        KIND_INS  = :instance_variable,
+        KIND_CON  = :constant,
+        KIND_GLOB = :global_variable
       ].freeze
 
+      KIND_STYLES = {
+        KIND_SELF => :constant,
+        KIND_LOC  => :local_variable,
+        KIND_INS  => :instance_variable,
+        KIND_CON  => :constant,
+        KIND_GLOB => :instance_variable
+      }.freeze
+
       KIND_PRIORITIES = {
-        KIND_LOC => 1,
-        KIND_INS => 2,
-        KIND_CON => 3
+        KIND_SELF => 0,
+        KIND_LOC  => 1,
+        KIND_INS  => 2,
+        KIND_CON  => 3,
+        KIND_GLOB => 4
       }.freeze
 
-      KIND_COLORS = {
-        KIND_LOC => :yellow,
-        KIND_INS => :blue,
-        KIND_CON => :green
+      TOKEN_KIND_MAPS = {
+        ident: KIND_LOC,
+        instance_variable: KIND_INS,
+        constant: KIND_CON,
+        predefined_constant: KIND_CON,
+        global_variable: KIND_GLOB
       }.freeze
+      TOKEN_KINDS = TOKEN_KIND_MAPS.keys.flatten
 
-      def draw
-        @output.print TTY::Box.frame(
-          **default_frame_styles.merge(
-            top: @row, left: @col, width: @layout.width, height: @layout.height
-          )
-        )
+      def initialize(*args)
+        super
 
-        @output.print TTY::Cursor.move_to(@col + 1, @row)
-        @output.print decorate_text
-          .with_highlight(true)
-          .text('Variables ', :bright_yellow)
-          .content
+        @frame_file = @session.current_frame&.frame_file
+        @frame_line = @session.current_frame&.frame_line
+        @frame_self = @session.current_frame&.frame_self
+        @frame_class = @session.current_frame&.frame_class
+        @frame_binding = @session.current_frame&.frame_binding
 
-        decorated_variables.first(data_size).each_with_index do |variable, index|
-          @output.print TTY::Cursor.move_to(@col + 1, @row + index + 1)
-          @output.print variable.content
-        end
-      end
+        @inline_tokens = generate_inline_tokens(@frame_file, @frame_line)
+        @file_tokens = generate_file_tokens(@frame_file)
 
-      private
+        @inspection_decorator = RubyJard::Decorators::InspectionDecorator.new
 
-      def data_size
-        @layout.height - 1
+        @selected = 0
       end
 
-      def current_binding
-        RubyJard.current_session.frame._binding
+      def title
+        'Variables'
       end
 
-      def current_frame
-        RubyJard.current_session.frame
+      def build
+        variables = fetch_relevant_variables
+        @rows = variables.map do |variable|
+          name = span_name(variable)
+          size = span_size(variable)
+          assignment = RubyJard::Span.new(margin_right: 1, margin_left: 1, content: '=', styles: :text_primary)
+          inline_limit =
+            (@layout.width - 3) * 3 - name.content_length - size.content_length - assignment.content_length
+          inspections = @inspection_decorator.decorate_multiline(
+            variable[2], first_line_limit: inline_limit, line_limit: @layout.width - 3, lines: 7
+          )
+          base_inspection = inspections.shift
+          mark = span_mark(variable, inspections)
+          [
+            base_row(name, size, assignment, mark, base_inspection),
+            nested_rows(variable, inspections)
+          ]
+        end.flatten.compact
       end
 
-      def current_frame_scope
-        RubyJard.current_session.backtrace[RubyJard.current_session.frame.pos][1]
+      def fetch_relevant_variables
+        sort_variables(
+          self_variable +
+          fetch_local_variables +
+          fetch_instance_variables +
+          fetch_constants +
+          fetch_global_variables
+        )
       end
 
-      def current_frame_scope_class
-        RubyJard.current_session.backtrace[RubyJard.current_session.frame.pos][2]
+      def base_row(name, size, assignment, mark, base_inspection)
+        RubyJard::Row.new(
+          line_limit: 3,
+          columns: [
+            RubyJard::Column.new(spans: [mark]),
+            RubyJard::Column.new(
+              word_wrap: RubyJard::Column::WORD_WRAP_BREAK_WORD,
+              spans: [name, size, assignment, base_inspection].flatten.compact
+            )
+          ]
+        )
       end
 
-      def decorated_variables
-        return [] if current_frame.nil?
+      def nested_rows(variable, nested_inspections)
+        return nil if nested_inspections.empty? || variable[0] == KIND_SELF
+
+        nested_inspections.map do |spans|
+          RubyJard::Row.new(
+            line_limit: 1,
+            columns: [
+              RubyJard::Column.new,
+              RubyJard::Column.new(
+                word_wrap: RubyJard::Column::WORD_WRAP_BREAK_WORD,
+                spans: spans
+              )
+            ]
+          )
+        end
+      end
 
-        variables = fetch_local_variables + fetch_instance_variables + fetch_constants
+      def span_mark(variable, nested_inspections)
+        if variable[0] == KIND_SELF || nested_inspections.empty?
+          RubyJard::Span.new(
+            content: ' ',
+            styles: :text_dim
+          )
+        else
+          RubyJard::Span.new(
+            content: '▾',
+            styles: :text_dim
+          )
+        end
+      end
 
-        sort_variables(variables).map do |kind, name, value|
-          decorated_variable(kind, name, value)
-        end.flatten
+      def span_name(variable)
+        RubyJard::Span.new(
+          content: variable[1].to_s,
+          styles: [KIND_STYLES[variable[0].to_sym], inline?(variable[1]) ? :underline : nil]
+        )
       end
 
+      def span_size(variable)
+        value = variable[2]
+        size_label =
+          if RubyJard::Reflection.call_is_a?(value, Array) && !value.empty?
+            "(len:#{value.length})"
+          elsif RubyJard::Reflection.call_is_a?(value, String) && value.length > 20
+            "(len:#{value.length})"
+          elsif RubyJard::Reflection.call_is_a?(value, Hash) && !value.empty?
+            "(size:#{value.length})"
+          end
+        RubyJard::Span.new(
+          margin_left: 1,
+          content: size_label,
+          styles: :text_primary
+        )
+      end
+
+      private
+
       def fetch_local_variables
-        variables = current_binding.local_variables
+        return [] if @frame_binding == nil
+        return [] unless RubyJard::Reflection.call_is_a?(@frame_binding, ::Binding)
+
+        variables = @frame_binding.local_variables
         # Exclude Pry's sticky locals
         pry_sticky_locals =
           if variables.include?(:pry_instance)
-            current_binding.local_variable_get(:pry_instance).sticky_locals.keys
+            @frame_binding.local_variable_get(:pry_instance)&.sticky_locals&.keys || []
           else
             []
           end
         variables -= pry_sticky_locals
         variables.map do |variable|
-          [KIND_LOC, variable, current_binding.local_variable_get(variable)]
+          [KIND_LOC, variable, @frame_binding.local_variable_get(variable)]
         rescue NameError
           nil
         end.compact
       end
 
       def fetch_instance_variables
-        current_frame_scope.instance_variables.map do |variable|
-          [KIND_INS, variable, current_frame_scope.instance_variable_get(variable)]
+        return [] if @frame_self == nil
+
+        instance_variables =
+          RubyJard::Reflection
+          .call_instance_variables(@frame_self)
+          .select { |v| relevant?(KIND_INS, v) }
+
+        instance_variables.map do |variable|
+          [KIND_INS, variable, RubyJard::Reflection.call_instance_variable_get(@frame_self, variable)]
         rescue NameError
           nil
         end.compact
       end
 
       def fetch_constants
+        return [] if @frame_class == nil
+
         # Filter out truly constants (CONSTANT convention) only
         constant_source =
-          if current_frame_scope_class&.singleton_class?
-            current_frame_scope
+          if @frame_class&.singleton_class?
+            @frame_self
           else
-            current_frame_scope_class
+            @frame_class
           end
 
-        return [] unless constant_source.respond_to?(:constants)
-
-        constants = constant_source.constants.select { |v| v.to_s.upcase == v.to_s }
-        constants.map do |variable|
-          [KIND_CON, variable, constant_source.const_get(variable)]
-        rescue NameError
-          nil
-        end.compact
+        (@file_tokens[KIND_CON] || {})
+          .keys
+          .select { |c| c.upcase == c }
+          .uniq
+          .map { |const| fetch_constant(constant_source, const) }
+          .compact
       end
 
-      def decorated_variable(kind, name, value)
-        text =
-          decorate_text
-          .text(decorated_type(value))
-          .with_highlight(true)
-          .text(name.to_s, kind_color(kind))
-          .text(addition_data(value), :white)
-          .text(' = ')
-          .with_highlight(false)
-        inspect_texts = inspect_value(text, value)
-        text.text(inspect_texts.first, :bright_white)
-
-        # TODO: Fix this ugly code
-        [text] +
-          inspect_texts[1..-1].map do |line|
-            decorate_text
-          .with_highlight(false)
-          .text(' ' * TYPE_SYMBOL_PADDING)
-          .text(line, :bright_white)
-          end
-      end
+      def fetch_constant(constant_source, const)
+        return nil if %w[NIL TRUE FALSE].include?(const.to_s)
+        return nil unless RubyJard::Reflection.call_const_defined?(constant_source, const)
 
-      def addition_data(value)
-        if value.is_a?(Array) && !value.empty?
-          " (size: #{value.length})"
-        elsif value.is_a?(String) && value.length > 20
-          " (size: #{value.length})"
-        else
-          ''
-        end
+        [KIND_CON, const, RubyJard::Reflection.call_const_get(constant_source, const)]
+      rescue NameError
+        nil
       end
 
-      def inspect_value(text, value)
-        # Split the lines, add padding to align with kind
-        length = @layout.width - TYPE_SYMBOL_PADDING - 1
-        value_inspect = value.inspect.to_s
-
-        start_pos = 0
-        end_pos = @layout.width - 2 - text.length
-
-        texts = []
-        3.times do |_index|
-          texts << value_inspect[start_pos..end_pos]
-          break if end_pos >= value_inspect.length
-
-          start_pos = end_pos + 1
-          end_pos += length
-        end
+      def fetch_global_variables
+        return [] if @frame_self == nil
 
-        if end_pos < value_inspect.length
-          texts.last[texts.last.length - INSPECTION_ELLIPSIS.length - 1..texts.last.length - 1] = INSPECTION_ELLIPSIS
-        end
-
-        texts
-      end
-
-      def decorated_type(value)
-        type_name = TYPE_SYMBOLS[value.class] || DEFAULT_TYPE_SYMBOL
-        decorate_text
-          .with_highlight(false)
-          .text(type_name.to_s.ljust(TYPE_SYMBOL_PADDING), :white)
+        variables =
+          ::Kernel
+          .global_variables
+          .select { |v| relevant?(KIND_GLOB, v) }
+        variables.map do |variable|
+          [KIND_GLOB, variable, ::Kernel.instance_eval(variable.to_s)]
+        rescue NameError
+          nil
+        end.compact
       end
 
-      def kind_color(kind)
-        KIND_COLORS[kind] || :white
+      def self_variable
+        [[KIND_SELF, :self, @frame_self]]
+      rescue StandardError
+        []
       end
 
       def sort_variables(variables)
@@ -227,8 +264,53 @@ module RubyJard
           end
         end
       end
+
+      def inline?(name)
+        @inline_tokens[name]
+      end
+
+      def relevant?(kind, name)
+        @file_tokens[kind] != nil && @file_tokens[kind][name]
+      end
+
+      def generate_inline_tokens(file, line)
+        return [] if file == nil || line == nil
+
+        loc_decorator = RubyJard::Decorators::LocDecorator.new
+        source_decorator = RubyJard::Decorators::SourceDecorator.new(file, line, 1)
+        _spans, tokens = loc_decorator.decorate(
+          source_decorator.codes[line - source_decorator.window_start],
+          file
+        )
+
+        inline_tokens = {}
+        tokens.each_slice(2) do |token, kind|
+          next if TOKEN_KIND_MAPS[kind] == nil
+
+          inline_tokens[token.to_s.to_sym] = true
+        end
+        inline_tokens
+      end
+
+      def generate_file_tokens(file)
+        return [] if file == nil
+
+        loc_decorator = RubyJard::Decorators::LocDecorator.new
+        # TODO: This is a mess
+        source_decorator = RubyJard::Decorators::SourceDecorator.new(file, 1, 10_000)
+        _spans, tokens = loc_decorator.decorate(source_decorator.codes.join("\n"), file)
+
+        file_tokens = {}
+        tokens.each_slice(2) do |token, kind|
+          next if TOKEN_KIND_MAPS[kind] == nil
+
+          file_tokens[TOKEN_KIND_MAPS[kind]] ||= {}
+          file_tokens[TOKEN_KIND_MAPS[kind]][token.to_s.to_sym] = true
+        end
+        file_tokens
+      end
     end
   end
 end
 
-RubyJard::Screens.add_screen(:variables, RubyJard::Screens::VariablesScreen)
+RubyJard::Screens.add_screen('variables', RubyJard::Screens::VariablesScreen)

data/lib/ruby_jard/session.rb

@@ -4,34 +4,96 @@ module RubyJard
   ##
   # Centralized flow control and data storage to feed into screens. Each
   # process supposes to have only one instance of this class.
-  # TODO: If attachment event happens after any threads are created, race
-  # condition may happen. Should use a mutex to wrap around.
   # TODO: This class is created to store data, but byebug data structures are
   # leaked, and accessible from outside and this doesn't work if screens stay in
   # other processes. Therefore, an internal, jard-specific data mapping should
   # be built.
   class Session
-    attr_reader :screen_manager, :backtrace, :frame, :contexts, :current_context
+    class << self
+      extend Forwardable
+
+      def_delegators :instance,
+                     :attach, :lock,
+                     :sync, :should_stop?,
+                     :step_over, :step_into, :frame=,
+                     :threads, :current_frame, :current_thread, :current_backtrace,
+                     :output_buffer, :append_output_buffer
+
+      def instance
+        @instance ||= new
+      end
+    end
+
+    OUTPUT_BUFFER_LENGTH = 10_000 # 10k lines
+
+    attr_accessor :output_buffer
 
     def initialize(options = {})
       @options = options
+      @started = false
+      @session_lock = Mutex.new
+      @output_buffer = []
 
-      @backtrace = []
-      @frame = nil
-      @contexts = []
+      @current_frame = nil
+      @current_backtrace = []
+      @threads = []
+      @current_thread = nil
 
-      @started = false
-      @screen_manager = RubyJard::ScreenManager.new(session: self)
+      @path_filter = RubyJard::PathFilter.new
     end
 
     def start
       return if started?
 
-      @screen_manager.start
+      ##
+      # Globally configure Byebug. Byebug doesn't allow configuration by instance.
+      # So, I have no choice.
+      # TODO: Byebug autoloaded configuration may override those values.
+      Byebug::Setting[:autolist] = false
+      Byebug::Setting[:autoirb] = false
+      Byebug::Setting[:autopry] = false
+      Byebug::Context.processor = RubyJard::ReplProcessor
+      # Exclude all files in Ruby Jard source code from the stacktrace.
+      Byebug::Context.ignored_files = Byebug::Context.all_files + Dir.glob(
+        File.join(
+          File.expand_path(__dir__, '../lib'),
+          '**',
+          '*.rb'
+        )
+      )
+      # rubocop:disable Lint/NestedMethodDefinition
+      def $stdout.write(*string, from_jard: false)
+        # NOTE: `RubyJard::ScreenManager.instance` is a must. Jard doesn't work well with delegator
+        # TODO: Debug and fix the issues permanently
+        if from_jard
+          super(*string)
+          return
+        end
+
+        unless RubyJard::ScreenManager.instance.updating?
+          RubyJard::Session.instance.append_output_buffer(string)
+        end
+
+        super(*string)
+      end
+      # rubocop:enable Lint/NestedMethodDefinition
+
+      at_exit { stop }
 
       @started = true
     end
 
+    def append_output_buffer(string)
+      @output_buffer.shift if @output_buffer.length > OUTPUT_BUFFER_LENGTH
+      @output_buffer << string
+    end
+
+    def stop
+      return unless started?
+
+      RubyJard::ScreenManager.stop
+    end
+
     def started?
       @started == true
     end
@@ -40,15 +102,88 @@ module RubyJard
       start unless started?
 
       Byebug.attach
-      Byebug.current_context.step_out(2, false)
+      Byebug.current_context.step_out(3, true)
+    end
+
+    def should_stop?
+      @path_filter.match?(@current_context.frame_file)
+    end
+
+    def sync(context)
+      @current_context = context
+      # Remove cache
+      @current_frame = nil
+      @current_thread = nil
+      @current_backtrace = nil
+      @threads = nil
     end
 
-    def refresh
-      @backtrace = Byebug.current_context.backtrace
-      @frame = Byebug.current_context.frame
-      @contexts = Byebug.contexts
-      @current_context = Byebug.current_context
-      @screen_manager.refresh
+    def current_frame
+      @current_frame ||=
+        begin
+          frame = RubyJard::Frame.new(@current_context, @current_context.frame.pos)
+          frame.visible = @path_filter.match?(frame.frame_file)
+          frame
+        end
+    end
+
+    def current_thread
+      @current_thread ||= RubyJard::ThreadInfo.new(@current_context.thread)
+    end
+
+    def current_backtrace
+      @current_backtrace ||= generate_backtrace
+    end
+
+    def threads
+      @threads ||=
+        Thread
+        .list
+        .select(&:alive?)
+        .reject { |t| t.name.to_s =~ /<<Jard:.*>>/ }
+        .map { |t| RubyJard::ThreadInfo.new(t) }
+    end
+
+    def frame=(real_pos)
+      @current_context.frame = @current_backtrace[real_pos].real_pos
+      @current_frame = @current_backtrace[real_pos]
+    end
+
+    def step_into(times)
+      @current_context.step_into(times, current_frame.real_pos)
+    end
+
+    def step_over(times)
+      @current_context.step_over(times, current_frame.real_pos)
+    end
+
+    def lock
+      raise RubyJard::Error, 'This method requires a block' unless block_given?
+
+      # TODO: This doesn't solve anything. However, debugging a multi-threaded process is hard.
+      # Let's deal with that later.
+      @session_lock.synchronize do
+        yield
+      end
+    end
+
+    private
+
+    def generate_backtrace
+      virtual_pos = 0
+      backtrace = @current_context.backtrace.map.with_index do |_frame, index|
+        frame = RubyJard::Frame.new(@current_context, index)
+        if @path_filter.match?(frame.frame_file)
+          frame.visible = true
+          frame.virtual_pos = virtual_pos
+          virtual_pos += 1
+        else
+          frame.visible = false
+        end
+        frame
+      end
+      current_frame.virtual_pos = backtrace[current_frame.real_pos].virtual_pos
+      backtrace
     end
   end
 end