Share variable inspection logic between CDP and DAP

Author: amomchilov

lib/debug/mirrors/variable_inspector.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module DEBUGGER__
+  module Mirrors
+    class VariableInspector
+      class Member
+        attr_reader :name, :value
+
+        def initialize(name:, value:, internal: false)
+          @name = name
+          @value = value
+          @is_internal = internal
+        end
+
+        def internal?
+          @is_internal
+        end
+
+        def self.internal name:, value:
+          new(name:, value:, internal: true)
+        end
+      end
+
+      def indexed_members_of obj, start:, count:
+        (start ... (start + count)).map { |i| Member.new(name: i.to_s, value: obj[i]) }
+      end
+
+      def named_members_of obj
+        members = case obj
+        when Array then obj.map.with_index { |o, i| Member.new(name: i.to_s, value: o) }
+        when Hash then obj.map { |k, v| Member.new(name: value_inspect(k), value: v) }
+        when Struct then obj.members.map { |name| Member.new(name:, value: obj[name]) }
+        when String
+          members = [
+            Member.internal(name: '#length', value: obj.length),
+            Member.internal(name: '#encoding', value: obj.encoding),
+          ]
+          if defined?(DEBUGGER__::NaiveString)
+            printed_str = value_inspect(obj)
+            members << Member.internal(name: "#dump", value: DEBUGGER__::NaiveString.new(obj)) if printed_str.end_with?('...')
+          end
+          members
+        when Class, Module then [Member.internal(name: "%ancestors", value: obj.ancestors[1..])]
+        when Range then [Member.internal(name: "#begin", value: obj.begin), Member.internal(name: "#end", value: obj.end)]
+        else []
+        end
+
+        unless defined?(DEBUGGER__::NaiveString) && DEBUGGER__::NaiveString === obj
+          members += M_INSTANCE_VARIABLES.bind_call(obj).sort.map{|iv|
+            Member.new(name: iv, value: M_INSTANCE_VARIABLE_GET.bind_call(obj, iv))
+          }
+          members.unshift  Member.internal(name: '#class', value: M_CLASS.bind_call(obj))
+        end
+
+        members
+      end
+
+      private
+
+      MAX_LENGTH = 180
+
+      def value_inspect obj, short: true
+        # TODO: max length should be configurable?
+        str = DEBUGGER__.safe_inspect obj, short: short, max_length: MAX_LENGTH
+
+        if str.encoding == Encoding::UTF_8
+          str.scrub
+        else
+          str.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+        end
+      end
+    end
+  end
+end

lib/debug/server_cdp.rb

@@ -1113,46 +1113,25 @@ def process_cdp args
         event! :protocol_result, :scope, req, vars
       when :properties
         oid = args.shift
-        result = []
-        prop = []
 
         if obj = @obj_map[oid]
-          case obj
-          when Array
-            result = obj.map.with_index{|o, i|
-              variable i.to_s, o
-            }
-          when Hash
-            result = obj.map{|k, v|
-              variable(k, v)
-            }
-          when Struct
-            result = obj.members.map{|m|
-              variable(m, obj[m])
-            }
-          when String
-            prop = [
-              internalProperty('#length', obj.length),
-              internalProperty('#encoding', obj.encoding)
-            ]
-          when Class, Module
-            result = obj.instance_variables.map{|iv|
-              variable(iv, obj.instance_variable_get(iv))
-            }
-            prop = [internalProperty('%ancestors', obj.ancestors[1..])]
-          when Range
-            prop = [
-              internalProperty('#begin', obj.begin),
-              internalProperty('#end', obj.end),
-            ]
+          members = Mirrors::VariableInspector.new.named_members_of(obj)
+
+          result = members.filter_map do |member|
+            next if member.internal?
+            variable(member.name, member.value)
           end
 
-          result += M_INSTANCE_VARIABLES.bind_call(obj).map{|iv|
-            variable(iv, M_INSTANCE_VARIABLE_GET.bind_call(obj, iv))
-          }
-          prop += [internalProperty('#class', M_CLASS.bind_call(obj))]
+          internal_properties = members.filter_map do |member|
+            next unless member.internal?
+            internalProperty(member.name, member.value)
+          end
+        else
+          result = []
+          internal_properties = []
         end
-        event! :protocol_result, :properties, req, result: result, internalProperties: prop
+
+        event! :protocol_result, :properties, req, result: result, internalProperties: internal_properties
       when :exception
         oid = args.shift
         exc = nil

lib/debug/server_dap.rb

@@ -776,7 +776,7 @@ class ThreadClient
     MAX_LENGTH = 180
 
     def value_inspect obj, short: true
-      # TODO: max length should be configuarable?
+      # TODO: max length should be configurable?
       str = DEBUGGER__.safe_inspect obj, short: short, max_length: MAX_LENGTH
 
       if str.encoding == Encoding::UTF_8
@@ -875,48 +875,18 @@ def process_dap args
         vid = args.shift
         obj = @var_map[vid]
         if obj
-          case req.dig('arguments', 'filter')
+          members = case req.dig('arguments', 'filter')
           when 'indexed'
-            start = req.dig('arguments', 'start') || 0
-            count = req.dig('arguments', 'count') || obj.size
-            vars = (start ... (start + count)).map{|i|
-              variable(i.to_s, obj[i])
-            }
+            Mirrors::VariableInspector.new.indexed_members_of(
+              obj,
+              start: req.dig('arguments', 'start') || 0,
+              count: req.dig('arguments', 'count') || obj.size,
+            )
           else
-            vars = []
-
-            case obj
-            when Hash
-              vars = obj.map{|k, v|
-                variable(value_inspect(k), v,)
-              }
-            when Struct
-              vars = obj.members.map{|m|
-                variable(m, obj[m])
-              }
-            when String
-              vars = [
-                variable('#length', obj.length),
-                variable('#encoding', obj.encoding),
-              ]
-              printed_str = value_inspect(obj)
-              vars << variable('#dump', NaiveString.new(obj)) if printed_str.end_with?('...')
-            when Class, Module
-              vars << variable('%ancestors', obj.ancestors[1..])
-            when Range
-              vars = [
-                variable('#begin', obj.begin),
-                variable('#end', obj.end),
-              ]
-            end
-
-            unless NaiveString === obj
-              vars += M_INSTANCE_VARIABLES.bind_call(obj).sort.map{|iv|
-                variable(iv, M_INSTANCE_VARIABLE_GET.bind_call(obj, iv))
-              }
-              vars.unshift variable('#class', M_CLASS.bind_call(obj))
-            end
+            Mirrors::VariableInspector.new.named_members_of(obj)
           end
+
+          vars = members.map { |member| variable(member.name, member.value) }
         end
         event! :protocol_result, :variable, req, variables: (vars || []), tid: self.id