toolbox 0.2.0 → 0.3.0

data/data/toolbox/rbignum.py

@@ -31,15 +31,11 @@ class RBignumObject:
 			return f"<T_BIGNUM@0x{addr:x} heap length={len(self)}>"
 	
 	def print_to(self, terminal):
-		"""Return formatted bignum representation."""
+		"""Print formatted bignum representation."""
 		addr = int(self.value)
 		storage = "embedded" if self.is_embedded() else "heap"
-		return terminal.print(
-			format.metadata, '<',
-			format.type, 'T_BIGNUM',
-			format.metadata, f'@0x{addr:x} {storage} length={len(self)}>',
-			format.reset
-		)
+		details = f"{storage} length={len(self)}"
+		terminal.print_type_tag('T_BIGNUM', addr, details)
 	
 	def print_recursive(self, printer, depth):
 		"""Print this bignum (no recursion needed)."""

data/data/toolbox/rclass.py

@@ -1,6 +1,6 @@
 import debugger
 import constants
-import value
+import rvalue
 import rstring
 
 class RClass:
@@ -86,13 +86,13 @@ class RClass:
 			
 			# Strategy 2: Try modern rb_classext_struct.classpath (Ruby 3.4+)
 			try:
-				rclass = self.klass.cast(debugger.lookup_type('struct RClass').pointer())
+				rclass = self.klass.cast(constants.type_struct('struct RClass').pointer())
 				# Try to access classext.classpath
 				try:
 					# Try embedded classext (RCLASS_EXT_EMBEDDED)
 					rclass_size = debugger.parse_and_eval("sizeof(struct RClass)")
 					classext_addr = int(self.klass) + int(rclass_size)
-					classext_type = debugger.lookup_type('rb_classext_t')
+					classext_type = constants.type_struct('rb_classext_t')
 					classext_ptr = debugger.create_value_from_address(classext_addr, classext_type).address
 					classpath_val = classext_ptr['classpath']
 				except:
@@ -103,9 +103,9 @@ class RClass:
 					except:
 						classpath_val = None
 				
-				if classpath_val and int(classpath_val) != 0 and not value.is_nil(classpath_val):
+				if classpath_val and int(classpath_val) != 0 and not rvalue.is_nil(classpath_val):
 					# Decode the classpath string
-					class_name_obj = value.interpret(classpath_val)
+					class_name_obj = rvalue.interpret(classpath_val)
 					if hasattr(class_name_obj, 'to_str'):
 						class_name = class_name_obj.to_str()
 						if class_name and not class_name.startswith('<'):

data/data/toolbox/readme.md

@@ -14,7 +14,7 @@ data/toolbox/
 │   └── *.md                # Documentation
 │
 # Ruby debugging extensions (currently GDB-specific, migrating to abstraction)
-├── object.py               # Object inspection (rb-object-print)
+├── object.py               # Object inspection (rb-print)
 ├── fiber.py                # Fiber debugging (rb-fiber-scan-heap, rb-fiber-switch)
 ├── heap.py                 # Heap scanning (rb-heap-scan)
 ├── stack.py                # Stack inspection
@@ -89,7 +89,7 @@ value_cast = value.cast(type.pointer())
 ### GDB
 ```bash
 gem install toolbox
-bake toolbox:gdb:install
+bake -g toolbox toolbox:gdb:install
 ```
 
 This adds to `~/.gdbinit`:
@@ -101,7 +101,7 @@ source /path/to/gem/data/toolbox/init.py
 ### LLDB
 ```bash
 gem install toolbox
-bake toolbox:lldb:install
+bake -g toolbox toolbox:lldb:install
 ```
 
 This adds to `~/.lldbinit`:
@@ -113,7 +113,7 @@ command script import /path/to/gem/data/toolbox/init.py
 ## Available Commands
 
 ### Object Inspection
-- `rb-object-print <expression> [--depth N]` - Print Ruby objects with recursion
+- `rb-print <expression> [--depth N]` - Print Ruby objects with recursion
 
 ### Fiber Debugging
 - `rb-fiber-scan-heap [--limit N]` - Scan heap for fiber objects
@@ -125,7 +125,7 @@ command script import /path/to/gem/data/toolbox/init.py
 - `rb-heap-scan [--type TYPE] [--limit N]` - Scan Ruby heap for objects
 
 ### Stack Inspection
-- `rb-stack-print` - Print Ruby stack (coming soon)
+- `rb-stack-trace` - Print combined Ruby/C stack trace
 
 ## Migration Status
 
@@ -151,14 +151,14 @@ command script import /path/to/gem/data/toolbox/init.py
 Test with GDB:
 ```bash
 gdb -q ruby
-(gdb) help rb-object-print
+(gdb) help rb-print
 (gdb) help rb-fiber-scan-heap
 ```
 
 Test with LLDB (once migrated):
 ```bash
 lldb ruby
-(lldb) help rb-object-print
+(lldb) help rb-print
 (lldb) help rb-fiber-scan-heap
 ```
 
@@ -192,7 +192,7 @@ if toolbox_dir not in sys.path:
 This allows:
 ```python
 import debugger      # data/toolbox/debugger.py
-import object        # data/toolbox/object.py
+import print         # data/toolbox/print.py
 import fiber         # data/toolbox/fiber.py
 from debugger import gdb   # data/toolbox/debugger/gdb.py
 ```

data/data/toolbox/rexception.py

@@ -1,7 +1,7 @@
 import debugger
 import constants
 import format
-import value
+import rvalue
 import rstring
 import rclass
 
@@ -21,7 +21,7 @@ class RException:
 		self._message = None
 		
 		# Validate it's an object
-		if value.is_immediate(exception_value):
+		if rvalue.is_immediate(exception_value):
 			raise ValueError("Exception VALUE cannot be an immediate value")
 	
 	@property
@@ -116,7 +116,7 @@ def is_exception(val):
 	Returns:
 		True if the value appears to be an exception object, False otherwise
 	"""
-	if not value.is_object(val):
+	if not rvalue.is_object(val):
 		return False
 	
 	try:

data/data/toolbox/rfloat.py

@@ -32,15 +32,10 @@ class RFloatImmediate:
 		return f"<T_FLOAT> {self.float_value()}"
 	
 	def print_to(self, terminal):
-		"""Return formatted float representation."""
-		tag = terminal.print(
-			format.metadata, '<',
-			format.type, 'T_FLOAT',
-			format.metadata, '>',
-			format.reset
-		)
-		num_val = terminal.print(format.number, str(self.float_value()), format.reset)
-		return f"{tag} {num_val}"
+		"""Print formatted float representation."""
+		terminal.print_type_tag('T_FLOAT')
+		terminal.print(' ', end='')
+		terminal.print(format.number, str(self.float_value()), format.reset, end='')
 	
 	def print_recursive(self, printer, depth):
 		"""Print this float (no recursion needed)."""
@@ -59,16 +54,11 @@ class RFloatObject:
 		return f"<T_FLOAT@0x{addr:x}> {self.float_value()}"
 	
 	def print_to(self, terminal):
-		"""Return formatted float representation."""
+		"""Print formatted float representation."""
 		addr = int(self.value.address)
-		tag = terminal.print(
-			format.metadata, '<',
-			format.type, 'T_FLOAT',
-			format.metadata, f'@0x{addr:x}>',
-			format.reset
-		)
-		num_val = terminal.print(format.number, str(self.float_value()), format.reset)
-		return f"{tag} {num_val}"
+		terminal.print_type_tag('T_FLOAT', addr)
+		terminal.print(' ', end='')
+		terminal.print(format.number, str(self.float_value()), format.reset, end='')
 	
 	def print_recursive(self, printer, depth):
 		"""Print this float (no recursion needed)."""

data/data/toolbox/rhash.py

@@ -51,12 +51,8 @@ class RHashSTTable(RHashBase):
 	def print_to(self, terminal):
 		"""Print this hash with formatting."""
 		addr = int(self.value)
-		return terminal.print(
-			format.metadata, '<', 
-			format.type, 'T_HASH',
-			format.metadata, f'@0x{addr:x} ST-Table entries={self.size()}>',
-			format.reset
-		)
+		details = f"ST-Table entries={self.size()}"
+		terminal.print_type_tag('T_HASH', addr, details)
 	
 	def print_recursive(self, printer, depth):
 		"""Print this hash recursively."""
@@ -121,12 +117,8 @@ class RHashARTable(RHashBase):
 	def print_to(self, terminal):
 		"""Print this hash with formatting."""
 		addr = int(self.value)
-		return terminal.print(
-			format.metadata, '<',
-			format.type, 'T_HASH',
-			format.metadata, f'@0x{addr:x} AR-Table size={self.size()} bound={self.bound()}>',
-			format.reset
-		)
+		details = f"AR-Table size={self.size()} bound={self.bound()}"
+		terminal.print_type_tag('T_HASH', addr, details)
 	
 	def print_recursive(self, printer, depth):
 		"""Print this hash recursively."""

data/data/toolbox/rstring.py

@@ -71,15 +71,11 @@ class RStringBase:
 		addr = int(self.value)
 		storage = "embedded" if self._is_embedded() else "heap"
 		content = self.to_str()
-		tag = terminal.print(
-			format.metadata, '<',
-			format.type, 'T_STRING',
-			format.metadata, f'@0x{addr:x} {storage} length={self.length()}>',
-			format.reset
-		)
+		details = f"{storage} length={self.length()}"
+		terminal.print_type_tag('T_STRING', addr, details)
+		terminal.print(' ', end='')
 		# Use repr() to properly escape quotes, newlines, etc.
-		string_val = terminal.print(format.string, repr(content), format.reset)
-		return f"{tag} {string_val}"
+		terminal.print(format.string, repr(content), format.reset, end='')
 	
 	def print_recursive(self, printer, depth):
 		"""Print this string (no recursion needed for strings)."""

data/data/toolbox/rstruct.py

@@ -60,14 +60,10 @@ class RStructEmbedded(RStructBase):
 		return f"<T_STRUCT@0x{addr:x} embedded length={len(self)}>"
 	
 	def print_to(self, terminal):
-		"""Return formatted struct representation."""
+		"""Print formatted struct representation."""
 		addr = int(self.value)
-		return terminal.print(
-			format.metadata, '<',
-			format.type, 'T_STRUCT',
-			format.metadata, f'@0x{addr:x} embedded length={len(self)}>',
-			format.reset
-		)
+		details = f"embedded length={len(self)}"
+		terminal.print_type_tag('T_STRUCT', addr, details)
 	
 	def print_recursive(self, printer, depth):
 		"""Print this struct recursively."""
@@ -101,14 +97,10 @@ class RStructHeap(RStructBase):
 		return f"<T_STRUCT@0x{addr:x} heap length={len(self)}>"
 	
 	def print_to(self, terminal):
-		"""Return formatted struct representation."""
+		"""Print formatted struct representation."""
 		addr = int(self.value)
-		return terminal.print(
-			format.metadata, '<',
-			format.type, 'T_STRUCT',
-			format.metadata, f'@0x{addr:x} heap length={len(self)}>',
-			format.reset
-		)
+		details = f"heap length={len(self)}"
+		terminal.print_type_tag('T_STRUCT', addr, details)
 	
 	def print_recursive(self, printer, depth):
 		"""Print this struct recursively."""

data/data/toolbox/rsymbol.py

@@ -138,25 +138,13 @@ class RSymbolImmediate:
 	
 	def print_to(self, terminal):
 		"""Return formatted symbol representation."""
+		terminal.print_type_tag('T_SYMBOL')
+		terminal.print(' ', end='')
 		name = self.to_str()
 		if name:
-			tag = terminal.print(
-				format.metadata, '<',
-				format.type, 'T_SYMBOL',
-				format.metadata, '>',
-				format.reset
-			)
-			symbol_val = terminal.print(format.symbol, f':{name}', format.reset)
-			return f"{tag} {symbol_val}"
+			terminal.print(format.symbol, f':{name}', format.reset, end='')
 		else:
-			tag = terminal.print(
-				format.metadata, '<',
-				format.type, 'T_SYMBOL',
-				format.metadata, '>',
-				format.reset
-			)
-			symbol_val = terminal.print(format.symbol, f':id_0x{self.id():x}', format.reset)
-			return f"{tag} {symbol_val}"
+			terminal.print(format.symbol, f':id_0x{self.id():x}', format.reset, end='')
 	
 	def print_recursive(self, printer, depth):
 		"""Print this symbol (no recursion needed)."""
@@ -208,28 +196,16 @@ class RSymbolObject:
 			return f"<T_SYMBOL@0x{addr:x}> :<Symbol:0x{int(fstr_val):x}>"
 	
 	def print_to(self, terminal):
-		"""Return formatted symbol representation."""
+		"""Print formatted symbol representation."""
 		name = self.to_str()
 		addr = int(self.value)
+		terminal.print_type_tag('T_SYMBOL', addr)
+		terminal.print(' ', end='')
 		if name:
-			tag = terminal.print(
-				format.metadata, '<',
-				format.type, 'T_SYMBOL',
-				format.metadata, f'@0x{addr:x}>',
-				format.reset
-			)
-			symbol_val = terminal.print(format.symbol, f':{name}', format.reset)
-			return f"{tag} {symbol_val}"
+			terminal.print(format.symbol, f':{name}', format.reset, end='')
 		else:
 			fstr_val = self.fstr()
-			tag = terminal.print(
-				format.metadata, '<',
-				format.type, 'T_SYMBOL',
-				format.metadata, f'@0x{addr:x}>',
-				format.reset
-			)
-			symbol_val = terminal.print(format.symbol, f':<Symbol:0x{int(fstr_val):x}>', format.reset)
-			return f"{tag} {symbol_val}"
+			terminal.print(format.symbol, f':<Symbol:0x{int(fstr_val):x}>', format.reset, end='')
 	
 	def print_recursive(self, printer, depth):
 		"""Print this symbol (no recursion needed)."""

data/data/toolbox/{value.py → rvalue.py}

@@ -1,7 +1,8 @@
-import debugger
+import sys
 import constants
 import format
 
+
 import rbasic
 import rfloat
 import rsymbol
@@ -35,19 +36,19 @@ class RImmediate:
 	def print_to(self, terminal):
 		"""Print this value with formatting to the given terminal."""
 		if self.val_int == 0:
-			return terminal.print(format.metadata, '<', format.type, 'T_FALSE', format.metadata, '>', format.reset)
+			terminal.print_type_tag('T_FALSE')
 		elif self.val_int == 0x04 or self.val_int == 0x08:
-			return terminal.print(format.metadata, '<', format.type, 'T_NIL', format.metadata, '>', format.reset)
+			terminal.print_type_tag('T_NIL')
 		elif self.val_int == 0x14:
-			return terminal.print(format.metadata, '<', format.type, 'T_TRUE', format.metadata, '>', format.reset)
+			terminal.print_type_tag('T_TRUE')
 		elif (self.val_int & 0x01) != 0:
 			# Fixnum - shift right to get actual value
-			tag = terminal.print(format.metadata, '<', format.type, 'T_FIXNUM', format.metadata, '>', format.reset)
-			num = terminal.print(format.number, str(self.val_int >> 1), format.reset)
-			return f"{tag} {num}"
+			terminal.print_type_tag('T_FIXNUM')
+			terminal.print(' ', end='')
+			terminal.print(format.number, str(self.val_int >> 1), format.reset, end='')
 		else:
 			# Unknown immediate
-			return f"<Immediate:0x{self.val_int:x}>"
+			terminal.print_type_tag('Immediate', self.val_int)
 	
 	def print_recursive(self, printer, depth):
 		"""Print this immediate value (no recursion needed)."""
@@ -138,7 +139,6 @@ def interpret(value):
 	Returns:
 		An instance of the appropriate type class (never None)
 	"""
-	import sys
 	val_int = int(value)
 	
 	# Check for immediate flonum (must be before fixnum check)