ruby_jard 0.2.3 → 0.3.0

data/lib/ruby_jard/screens/variables_screen.rb

@@ -5,209 +5,239 @@ module RubyJard
     ##
     # 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,
-        (0..0).class => :rng,
-        Class => :cls # Sorry, I lied, Class will never change
-      }.freeze
-      DEFAULT_TYPE_SYMBOL = :var
-
       KINDS = [
+        KIND_SELF = :self,
         KIND_LOC  = :local_variable,
         KIND_INS  = :instance_variable,
         KIND_CON  = :constant,
-        KIND_SELF = :self
+        KIND_GLOB = :global_variable
       ].freeze
 
       KIND_STYLES = {
+        KIND_SELF => :constant,
         KIND_LOC  => :local_variable,
         KIND_INS  => :instance_variable,
         KIND_CON  => :constant,
-        KIND_SELF => :constant
+        KIND_GLOB => :instance_variable
       }.freeze
 
       KIND_PRIORITIES = {
         KIND_SELF => 0,
-        KIND_LOC => 1,
-        KIND_INS => 2,
-        KIND_CON => 3
+        KIND_LOC  => 1,
+        KIND_INS  => 2,
+        KIND_CON  => 3,
+        KIND_GLOB => 4
       }.freeze
 
-      INLINE_TOKEN_KIND_MAPS = {
-        KIND_LOC => :ident,
-        KIND_INS => :instance_variable,
-        KIND_CON => :constant
+      TOKEN_KIND_MAPS = {
+        ident: KIND_LOC,
+        instance_variable: KIND_INS,
+        constant: KIND_CON,
+        predefined_constant: KIND_CON,
+        global_variable: KIND_GLOB
       }.freeze
-      INLINE_TOKEN_KINDS = INLINE_TOKEN_KIND_MAPS.values
+      TOKEN_KINDS = TOKEN_KIND_MAPS.keys.flatten
+
+      def initialize(*args)
+        super
+
+        @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
+
+        @inline_tokens = generate_inline_tokens(@frame_file, @frame_line)
+        @file_tokens = generate_file_tokens(@frame_file)
+
+        @inspection_decorator = RubyJard::Decorators::InspectionDecorator.new
+
+        @selected = 0
+      end
 
       def title
         'Variables'
       end
 
       def build
-        variables =
+        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 fetch_relevant_variables
+        sort_variables(
           self_variable +
           fetch_local_variables +
           fetch_instance_variables +
-          fetch_constants
-        variables = sort_variables(variables)
-        @rows = variables.map do |variable|
+          fetch_constants +
+          fetch_global_variables
+        )
+      end
+
+      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 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: 3,
+            line_limit: 1,
             columns: [
+              RubyJard::Column.new,
               RubyJard::Column.new(
-                spans: [
-                  span_inline(variable)
-                ]
-              ),
-              RubyJard::Column.new(
-                spans: [
-                  span_name(variable),
-                  span_size(variable),
-                  RubyJard::Span.new(margin_right: 1, content: '=', styles: :variable_assignment),
-                  span_inspection(variable)
-                ]
+                word_wrap: RubyJard::Column::WORD_WRAP_BREAK_WORD,
+                spans: spans
               )
             ]
           )
         end
-        @selected = 0
       end
 
-      def span_inline(variable)
-        if inline?(variable[0], variable[1])
+      def span_mark(variable, nested_inspections)
+        if variable[0] == KIND_SELF || nested_inspections.empty?
           RubyJard::Span.new(
-            content: '•',
-            styles: :variable_mark_inline
+            content: ' ',
+            styles: :text_dim
           )
         else
           RubyJard::Span.new(
-            content: ' ',
-            styles: :variable_mark
+            content: '▾',
+            styles: :text_dim
           )
         end
       end
 
       def span_name(variable)
         RubyJard::Span.new(
-          margin_right: 1,
           content: variable[1].to_s,
-          styles: KIND_STYLES[variable[0].to_sym]
+          styles: [KIND_STYLES[variable[0].to_sym], inline?(variable[1]) ? :underline : nil]
         )
       end
 
       def span_size(variable)
         value = variable[2]
         size_label =
-          if value.is_a?(Array) && !value.empty?
+          if RubyJard::Reflection.call_is_a?(value, Array) && !value.empty?
             "(len:#{value.length})"
-          elsif value.is_a?(String) && value.length > 20
+          elsif RubyJard::Reflection.call_is_a?(value, String) && value.length > 20
             "(len:#{value.length})"
-          elsif value.is_a?(Hash) && !value.empty?
+          elsif RubyJard::Reflection.call_is_a?(value, Hash) && !value.empty?
             "(size:#{value.length})"
           end
         RubyJard::Span.new(
-          margin_right: 1,
+          margin_left: 1,
           content: size_label,
-          styles: :variable_size
-        )
-      end
-
-      def span_inspection(variable)
-        inspection =
-          case variable[0]
-          when KIND_SELF
-            variable[2].to_s
-          else
-            variable[2].inspect
-          end
-        # Hard limit: screen area
-        inspection = inspection[0..@layout.height * @layout.width]
-        # TODO: This is just a workable. Should write a decorator to inspect objects accurately
-        ["\n", "\r", "\r\n"].each do |esc|
-          inspection.gsub!(esc, esc.inspect)
-        end
-        RubyJard::Span.new(
-          content: inspection,
-          styles: :variable_inspection
-        )
-      rescue StandardError
-        RubyJard::Span.new(
-          content: '<Fail to inspect>',
-          styles: :variable_inspection
+          styles: :text_primary
         )
       end
 
       private
 
       def fetch_local_variables
-        variables = @session.current_frame.frame_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)
-            @session.current_frame.frame_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, @session.current_frame.frame_binding.local_variable_get(variable)]
+          [KIND_LOC, variable, @frame_binding.local_variable_get(variable)]
         rescue NameError
           nil
         end.compact
       end
 
       def fetch_instance_variables
-        @session.current_frame.frame_self.instance_variables.map do |variable|
-          [KIND_INS, variable, @session.current_frame.frame_self.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 @session.current_frame.frame_class&.singleton_class?
-            @session.current_frame.frame_self
+          if @frame_class&.singleton_class?
+            @frame_self
           else
-            @session.current_frame.frame_class
+            @frame_class
           end
 
-        return [] unless constant_source.respond_to?(:constants)
-        return [] if toplevel_binding?
+        (@file_tokens[KIND_CON] || {})
+          .keys
+          .select { |c| c.upcase == c }
+          .uniq
+          .map { |const| fetch_constant(constant_source, const) }
+          .compact
+      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)
+
+        [KIND_CON, const, RubyJard::Reflection.call_const_get(constant_source, const)]
+      rescue NameError
+        nil
+      end
 
-        constants = constant_source.constants.select { |v| v.to_s.upcase == v.to_s }
-        constants.map do |variable|
-          next if %w[NIL TRUE FALSE].include?(variable.to_s)
+      def fetch_global_variables
+        return [] if @frame_self == nil
 
-          [KIND_CON, variable, constant_source.const_get(variable)]
+        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 toplevel_binding?
-        @session.current_frame.frame_self == TOPLEVEL_BINDING.receiver
-      rescue StandardError
-        false
-      end
-
       def self_variable
-        [[KIND_SELF, :self, @session.current_frame.frame_self]]
+        [[KIND_SELF, :self, @frame_self]]
       rescue StandardError
         []
       end
@@ -235,35 +265,49 @@ module RubyJard
         end
       end
 
-      def inline?(kind, name)
-        tokens = inline_tokens[INLINE_TOKEN_KIND_MAPS[kind]] || []
-        tokens.include?(name)
+      def inline?(name)
+        @inline_tokens[name]
+      end
+
+      def relevant?(kind, name)
+        @file_tokens[kind] != nil && @file_tokens[kind][name]
       end
 
-      def inline_tokens
-        return @inline_tokens if defined?(@inline_tokens)
+      def generate_inline_tokens(file, line)
+        return [] if file == nil || line == nil
 
-        current_file = @session.current_frame.frame_file
-        current_line = @session.current_frame.frame_line
-        source_decorator = RubyJard::Decorators::SourceDecorator.new(current_file, current_line, 1)
+        loc_decorator = RubyJard::Decorators::LocDecorator.new
+        source_decorator = RubyJard::Decorators::SourceDecorator.new(file, line, 1)
         _spans, tokens = loc_decorator.decorate(
-          source_decorator.codes[current_line - source_decorator.window_start],
-          current_file
+          source_decorator.codes[line - source_decorator.window_start],
+          file
         )
 
-        @inline_tokens = {}
+        inline_tokens = {}
         tokens.each_slice(2) do |token, kind|
-          next unless INLINE_TOKEN_KINDS.include?(kind)
+          next if TOKEN_KIND_MAPS[kind] == nil
 
-          @inline_tokens[kind] ||= []
-          @inline_tokens[kind] << token.to_s.to_sym
+          inline_tokens[token.to_s.to_sym] = true
         end
-
-        @inline_tokens
+        inline_tokens
       end
 
-      def loc_decorator
-        @loc_decorator ||= RubyJard::Decorators::LocDecorator.new
+      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

data/lib/ruby_jard/session.rb

@@ -4,23 +4,42 @@ 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_accessor :threads, :current_frame, :current_backtrace
+    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 = []
 
       @current_frame = nil
       @current_backtrace = []
       @threads = []
+      @current_thread = nil
+
+      @path_filter = RubyJard::PathFilter.new
     end
 
     def start
@@ -42,9 +61,39 @@ module RubyJard
           '*.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
@@ -56,22 +105,58 @@ module RubyJard
       Byebug.current_context.step_out(3, true)
     end
 
-    def update
-      current_context = Byebug.current_context
-      @current_frame = RubyJard::Frame.new(current_context, current_context.frame.pos)
-      @current_backtrace = current_context.backtrace.map.with_index do |_frame, index|
-        RubyJard::Frame.new(current_context, index)
-      end
-      @threads =
-        Byebug
-        .contexts
-        .reject(&:ignored?)
-        .reject { |c| c.thread.name.to_s =~ /<<Jard:.*>>/ }
-        .map do |context|
-          RubyJard::Frame.new(context, 0)
+    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 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?
 
@@ -81,5 +166,24 @@ module RubyJard
         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