Class: Sheap::HeapObject

Inherits:
Object
  • Object
show all
Defined in:
lib/sheap.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(heap, json) ⇒ HeapObject

Returns a new instance of HeapObject.



212
213
214
215
 
# File 'lib/sheap.rb', line 212

def initialize(heap, json)
  @heap = heap
  @json = json
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args) ⇒ Object 



403
404
405
406
407
408
409
 
# File 'lib/sheap.rb', line 403

def method_missing(name, *args)
  if value = data[name.to_s]
    value
  else
    super
  end
end

Instance Attribute Details

#heap ⇒ Object (readonly)

Returns the value of attribute heap.



210
211
212
 
# File 'lib/sheap.rb', line 210

def heap
  @heap
end

#json ⇒ Object (readonly)

Returns the value of attribute json.



210
211
212
 
# File 'lib/sheap.rb', line 210

def json
  @json
end

Instance Method Details

#[](key) ⇒ Object 



415
416
417
 
# File 'lib/sheap.rb', line 415

def [](key)
  data[key.to_s]
end

#address ⇒ Object 



225
226
227
 
# File 'lib/sheap.rb', line 225

def address
  @json[/"address":"(0x[0-9a-f]+)"/, 1] || @json[/"root":"([a-z_]+)"/, 1]
end

#class_addr ⇒ Object 



262
263
264
 
# File 'lib/sheap.rb', line 262

def class_addr
  @json[/"class":"(0x[0-9a-f]+)"/, 1]
end

#data ⇒ Object 



254
255
256
 
# File 'lib/sheap.rb', line 254

def data
  JSON.parse(@json)
end

#eql?(other) ⇒ Boolean Also known as: ==

Returns:

  • (Boolean) 


385
386
387
388
389
390
391
392
 
# File 'lib/sheap.rb', line 385

def eql?(other)
  if @heap.equal?(other.heap)
    @json == other.json
  else
    address == other.address &&
      type_str == other.type_str
  end
end

#file ⇒ Object 



368
369
370
 
# File 'lib/sheap.rb', line 368

def file
  data["file"]
end

#frozen? ⇒ Boolean

Returns:

  • (Boolean) 


381
382
383
 
# File 'lib/sheap.rb', line 381

def frozen?
  @json.include?('"frozen":true')
end

#hash ⇒ Object 



399
400
401
 
# File 'lib/sheap.rb', line 399

def hash
  address.hash
end

#imemo_type ⇒ Object 



266
267
268
 
# File 'lib/sheap.rb', line 266

def imemo_type
  @json[/"imemo_type":"([a-z_]+)"/, 1]
end

#inspect ⇒ Object 



299
300
301
302
 
# File 'lib/sheap.rb', line 299

def inspect
  type_str = self.type_str
  s = +"<#{type_str} #{address} #{inspect_hint}>"
end

#inspect_hint ⇒ Object 



304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
 
# File 'lib/sheap.rb', line 304

def inspect_hint
  s = +""
  case type_str
  when "CLASS"
    s << (name || "(anonymous)")
  when "MODULE"
    s << (name || "(anonymous)")
  when "STRING"
    s << data["value"].inspect
  when "IMEMO"
    s << (imemo_type || "unknown")
  when "OBJECT"
    s << (klass.name || "(#{klass.address})")
  when "DATA"
    s << struct.to_s
  end

  refs = referenced_addrs
  unless refs.empty?
    s << " (#{referenced_addrs.size} refs)"
  end

  s
end

#instances ⇒ Object 



290
291
292
293
 
# File 'lib/sheap.rb', line 290

def instances
  raise unless type_str == "CLASS"
  heap.instances_of(self)
end

#inverse_references ⇒ Object 



247
248
249
250
251
252
 
# File 'lib/sheap.rb', line 247

def inverse_references
  HeapObjectCollection.new(
    (@heap.inverse_references[address] || EMPTY_ARRAY),
    heap
  )
end

#klass ⇒ Object 



286
287
288
 
# File 'lib/sheap.rb', line 286

def klass
  @heap.at(class_addr)
end

#line ⇒ Object 



372
373
374
 
# File 'lib/sheap.rb', line 372

def line
  data["line"]
end

#location ⇒ Object 



376
377
378
379
 
# File 'lib/sheap.rb', line 376

def location
  f = file
  "#{f}:#{line}" if f
end

#memsize ⇒ Object 



258
259
260
 
# File 'lib/sheap.rb', line 258

def memsize
  @json[/"memsize":(\d+),/, 1].to_i
end

#name ⇒ Object 



282
283
284
 
# File 'lib/sheap.rb', line 282

def name
  data["name"]
end

#old? ⇒ Boolean

Returns:

  • (Boolean) 


278
279
280
 
# File 'lib/sheap.rb', line 278

def old?
  @json.include?('"old":true')
end

#pretty_print(q) ⇒ Object 



329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
 
# File 'lib/sheap.rb', line 329

def pretty_print(q)
  current_depth = q.current_group.depth
  q.group(1, "#<#{type_str}", '>') do
    q.text " "
    q.text address
    if current_depth <= 1
      data = self.data
      attributes = data.keys - ["address"]
      q.seplist(attributes, lambda { q.text ',' }) {|v|
        q.breakable
        q.text v
        q.text "="
        q.group(1) {
          q.breakable ''
          case v
          when "class"
            q.pp klass
          when "superclass"
            q.pp superclass
          when "flags"
            q.text flags.keys.join("|")
          when "references"
            q.text "(#{referenced_addrs.size} refs)"
          else
            q.pp data[v]
          end
        }
      }
    else
      q.breakable
      q.text inspect_hint
    end
  end
end

#referenced_addrs ⇒ Object 



229
230
231
232
233
234
235
236
 
# File 'lib/sheap.rb', line 229

def referenced_addrs
  str = @json[/"references":\[([",0-9a-fx ]+)\]/, 1]
  if str
    str.tr('"', '').split(", ")
  else
    EMPTY_ARRAY
  end
end

#references ⇒ Object 



238
239
240
241
242
243
244
245
 
# File 'lib/sheap.rb', line 238

def references
  HeapObjectCollection.new(
    referenced_addrs.map do |addr|
      @heap.at(addr)
    end,
    heap
  )
end

#references_address?(addr) ⇒ Boolean

Returns:

  • (Boolean) 


395
396
397
 
# File 'lib/sheap.rb', line 395

def references_address?(addr)
  @json.include?(addr) && referenced_addrs.include?(addr)
end

#respond_to_missing?(name) ⇒ Boolean

Returns:

  • (Boolean) 


411
412
413
 
# File 'lib/sheap.rb', line 411

def respond_to_missing?(name, *)
  data.key?(name.to_s) || super
end

#root? ⇒ Boolean

Returns:

  • (Boolean) 


221
222
223
 
# File 'lib/sheap.rb', line 221

def root?
  @json.include?('"type":"ROOT"')
end

#struct ⇒ Object 



270
271
272
 
# File 'lib/sheap.rb', line 270

def struct
  @json[/"struct":"([^"]+)"/, 1]
end

#superclass ⇒ Object 



295
296
297
 
# File 'lib/sheap.rb', line 295

def superclass
  heap.at(data["superclass"])
end

#type_str ⇒ Object 



217
218
219
 
# File 'lib/sheap.rb', line 217

def type_str
  @json[/"type":"([A-Z]+)"/, 1]
end

#value ⇒ Object 



364
365
366
 
# File 'lib/sheap.rb', line 364

def value
  data["value"]
end

#wb_protected? ⇒ Boolean

Returns:

  • (Boolean) 


274
275
276
 
# File 'lib/sheap.rb', line 274

def wb_protected?
  @json.include?('"wb_protected":true')
end