objspace_helpers 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c64bb3dba9f6e3592d48191859735a4a982057d4
+  data.tar.gz: af65ffc525b86d06a64c0bcd75852512408bee98
+SHA512:
+  metadata.gz: 07223b0ee7fe06143270fd91f66f07da4a324e832e57875b4941bd3059eb9e40da01dbae0e127624f21dc0a012c9c6a855cd682e8ece0a7e6b69716d97052621
+  data.tar.gz: 31e9b72f8f15653f86b2853965470504b82c9165370315a8ba520b4d98df8360023f0490b4affe5ef74ccad0e39cc88c3f2758dd5f8fd73485c02044006df4cc

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2014, Lukas Fittl <lukas@fittl.com>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

data/Rakefile

@@ -0,0 +1,20 @@
+require "bundler/gem_tasks"
+require "rake/extensiontask"
+require "rspec/core/rake_task"
+
+Rake::ExtensionTask.new "objspace_helpers" do |ext|
+  ext.lib_dir = "lib/objspace_helpers"
+end
+
+RSpec::Core::RakeTask.new
+
+task spec: :compile
+
+task default: :spec
+task test: :spec
+
+task :clean do
+  FileUtils.rm_rf File.join(File.dirname(__FILE__), "tmp/")
+  FileUtils.rm_f Dir.glob(File.join(File.dirname(__FILE__), "ext/objspace_helpers/*.o"))
+  FileUtils.rm_f File.join(File.dirname(__FILE__), "lib/objspace_helpers/objspace_helpers.bundle")
+end

data/ext/objspace_helpers/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+$objs = ["objspace_info.o", "objspace_helpers.o"]
+
+create_makefile 'objspace_helpers/objspace_helpers'

data/ext/objspace_helpers/objspace_helpers.c

@@ -0,0 +1,60 @@
+#include <objspace_info.h>
+
+void Init_objspace_helpers(void);
+
+static int
+collect_addresses(void *vstart, void *vend, size_t stride, void *data)
+{
+  VALUE v = (VALUE)vstart;
+  for (; v != (VALUE)vend; v += stride) {
+    if (RBASIC(v)->flags)
+      rb_ary_push((VALUE) data, INT2FIX((void *)v));
+  }
+  return 0;
+}
+
+static VALUE oh_dump_addresses(VALUE self)
+{
+  VALUE ary = rb_ary_new();
+  rb_objspace_each_objects(collect_addresses, (void *)ary);
+  return ary;
+}
+
+static VALUE oh_addresses_to_info(VALUE self, VALUE ary)
+{
+  VALUE hash, obj_addr, info_hash;
+  long i;
+
+  hash = rb_hash_new();
+
+  for (i = 0; i < RARRAY_LEN(ary); i += 1) {
+    obj_addr = rb_ary_entry(ary, i);
+    info_hash = rb_hash_new();
+    objspace_info(FIX2PTR(obj_addr), info_hash);
+    rb_hash_aset(hash, obj_addr, info_hash);
+  }
+
+  return hash;
+}
+
+static VALUE oh_address_of_obj(VALUE self, VALUE obj)
+{
+  return PTR2FIX(obj);
+}
+
+static VALUE oh_obj_for_address(VALUE self, VALUE address)
+{
+  return FIX2PTR(address);
+}
+
+void Init_objspace_helpers(void)
+{
+  VALUE cObjspaceHelpers;
+
+  cObjspaceHelpers = rb_const_get(rb_cObject, rb_intern("ObjspaceHelpers"));
+
+  rb_define_singleton_method(cObjspaceHelpers, "_dump_addresses", oh_dump_addresses, 0);
+  rb_define_singleton_method(cObjspaceHelpers, "_addresses_to_info", oh_addresses_to_info, 1);
+  rb_define_singleton_method(cObjspaceHelpers, "_address_of_obj", oh_address_of_obj, 1);
+  rb_define_singleton_method(cObjspaceHelpers, "_obj_for_address", oh_obj_for_address, 1);
+}

data/ext/objspace_helpers/objspace_helpers.h

@@ -0,0 +1,10 @@
+#ifndef RUBY_OBJSPACE_HELPERS
+#define RUBY_OBJSPACE_HELPERS
+
+#include <ruby.h>
+#include <ruby_private/gc.h>
+
+#define PTR2FIX(v) INT2FIX((void *)v)
+#define FIX2PTR(v) ((VALUE)NUM2SIZET(v))
+
+#endif

data/ext/objspace_helpers/objspace_info.c

@@ -0,0 +1,175 @@
+#include <objspace_info.h>
+
+static inline const char *
+obj_type(VALUE obj)
+{
+  switch (BUILTIN_TYPE(obj)) {
+  #define CASE_TYPE(type) case T_##type: return #type; break
+  CASE_TYPE(NONE);
+  CASE_TYPE(NIL);
+  CASE_TYPE(OBJECT);
+  CASE_TYPE(CLASS);
+  CASE_TYPE(ICLASS);
+  CASE_TYPE(MODULE);
+  CASE_TYPE(FLOAT);
+  CASE_TYPE(STRING);
+  CASE_TYPE(REGEXP);
+  CASE_TYPE(ARRAY);
+  CASE_TYPE(HASH);
+  CASE_TYPE(STRUCT);
+  CASE_TYPE(BIGNUM);
+  CASE_TYPE(FILE);
+  CASE_TYPE(FIXNUM);
+  CASE_TYPE(TRUE);
+  CASE_TYPE(FALSE);
+  CASE_TYPE(DATA);
+  CASE_TYPE(MATCH);
+  CASE_TYPE(SYMBOL);
+  CASE_TYPE(RATIONAL);
+  CASE_TYPE(COMPLEX);
+  CASE_TYPE(UNDEF);
+  CASE_TYPE(NODE);
+  CASE_TYPE(ZOMBIE);
+  #undef CASE_TYPE
+  }
+  return "UNKNOWN";
+}
+
+static void
+reachable_object_i(VALUE ref, void *data)
+{
+  rb_ary_push((VALUE)data, PTR2FIX(ref));
+}
+
+#define HASH_SET(k,v) rb_hash_aset(target_hash, rb_str_new2(k), v)
+#define HASH_SET_PTR(k,v) HASH_SET(k,INT2FIX((void *)v))
+#define HASH_SET_INT(k,v) HASH_SET(k,INT2FIX(v))
+#define HASH_SET_UINT(k,v) HASH_SET(k,UINT2NUM(v))
+#define HASH_SET_ULONG(k,v) HASH_SET(k,ULONG2NUM(v))
+#define HASH_SET_STR(k,v) HASH_SET(k,rb_str_new2(v))
+#define HASH_SET_TRUE(k)  HASH_SET(k,Qtrue)
+
+void
+objspace_info(VALUE obj, VALUE target_hash)
+{
+  size_t memsize;
+  struct allocation_info *ainfo;
+  rb_io_t *fptr;
+  ID flags[RB_OBJ_GC_FLAGS_MAX];
+  size_t n, i;
+  VALUE obj_klass, references;
+
+  obj_klass = BUILTIN_TYPE(obj) == T_NODE ? 0 : RBASIC_CLASS(obj);
+  references = rb_ary_new();
+
+  if (obj == target_hash)
+    return;
+
+  HASH_SET_STR("type", obj_type(obj));
+
+  if (obj_klass)
+    HASH_SET_PTR("class", obj_klass);
+  if (rb_obj_frozen_p(obj))
+    HASH_SET_TRUE("frozen");
+
+  switch (BUILTIN_TYPE(obj)) {
+  case T_NODE:
+    HASH_SET_STR("node_type", ruby_node_name(nd_type(obj)));
+    break;
+
+  case T_STRING:
+    if (STR_EMBED_P(obj))
+      HASH_SET_TRUE("embedded");
+    if (STR_ASSOC_P(obj))
+      HASH_SET_TRUE("associated");
+    if (is_broken_string(obj))
+      HASH_SET_TRUE("broken");
+    if (FL_TEST(obj, RSTRING_FSTR))
+      HASH_SET_TRUE("fstring");
+    if (STR_SHARED_P(obj))
+      HASH_SET_TRUE("shared");
+    else {
+      HASH_SET_INT("bytesize", RSTRING_LEN(obj));
+
+      if (!STR_EMBED_P(obj) && !STR_NOCAPA_P(obj) && (long)rb_str_capacity(obj) != RSTRING_LEN(obj))
+        HASH_SET_INT("capacity", rb_str_capacity(obj));
+
+      if (is_ascii_string(obj))
+        HASH_SET("value", obj);
+    }
+
+    if (!ENCODING_IS_ASCII8BIT(obj))
+      HASH_SET_STR("encoding", rb_enc_name(rb_enc_from_index(ENCODING_GET(obj))));
+
+    break;
+
+  case T_HASH:
+    HASH_SET_INT("size", RHASH_SIZE(obj));
+
+    if (FL_TEST(obj, HASH_PROC_DEFAULT))
+      HASH_SET_PTR("default", RHASH_IFNONE(obj));
+      break;
+
+  case T_ARRAY:
+    HASH_SET_INT("length", RARRAY_LEN(obj));
+
+    if (RARRAY_LEN(obj) > 0 && FL_TEST(obj, ELTS_SHARED))
+      HASH_SET_TRUE("shared");
+    if (RARRAY_LEN(obj) > 0 && FL_TEST(obj, RARRAY_EMBED_FLAG))
+      HASH_SET_TRUE("embedded");
+
+    break;
+
+  case T_CLASS:
+  case T_MODULE:
+    if (obj_klass)
+      HASH_SET_STR("name", rb_class2name(obj));
+    break;
+
+  case T_DATA:
+    if (RTYPEDDATA_P(obj))
+      HASH_SET_STR("struct", RTYPEDDATA_TYPE(obj)->wrap_struct_name);
+    break;
+
+  case T_FLOAT:
+    HASH_SET("value", obj);
+    break;
+
+  case T_OBJECT:
+    HASH_SET_INT("ivars", ROBJECT_NUMIV(obj));
+    break;
+
+  case T_FILE:
+    fptr = RFILE(obj)->fptr;
+    if (fptr)
+      HASH_SET_INT("fd", fptr->fd);
+    break;
+
+  case T_ZOMBIE:
+    return;
+  }
+
+  rb_objspace_reachable_objects_from(obj, reachable_object_i, (void*)references);
+  rb_ary_delete(references, PTR2FIX(obj_klass));
+  HASH_SET("references", references);
+
+  if ((ainfo = objspace_lookup_allocation_info(obj))) {
+    HASH_SET_STR("file", ainfo->path);
+    HASH_SET_ULONG("line", ainfo->line);
+    HASH_SET_UINT("generation", ainfo->generation);
+
+    if (RTEST(ainfo->mid))
+      HASH_SET_STR("method", rb_id2name(SYM2ID(ainfo->mid)));
+  }
+
+  if ((memsize = rb_obj_memsize_of(obj)) > 0)
+    HASH_SET_UINT("memsize", memsize);
+
+  if ((n = rb_obj_gc_flags(obj, flags, sizeof(flags))) > 0) {
+    VALUE flags_hash = rb_hash_new();
+    for (i=0; i<n; i++) {
+      rb_hash_aset(flags_hash, rb_str_new2(rb_id2name(flags[i])), Qtrue);
+    }
+    HASH_SET("flags", flags_hash);
+  }
+}

data/ext/objspace_helpers/objspace_info.h

@@ -0,0 +1,15 @@
+#ifndef RUBY_OBJSPACE_INFO
+#define RUBY_OBJSPACE_INFO
+
+#include <ruby.h>
+#include <ruby/io.h>
+
+#include <ruby_private/internal_defs.h>
+#include <ruby_private/objspace.h>
+
+#include <objspace_helpers.h>
+
+void
+objspace_info(VALUE obj, VALUE target_hash);
+
+#endif

data/ext/objspace_helpers/ruby_private/gc.h

@@ -0,0 +1,107 @@
+
+#ifndef RUBY_GC_H
+#define RUBY_GC_H 1
+
+#if defined(__x86_64__) && !defined(_ILP32) && defined(__GNUC__) && !defined(__native_client__)
+#define SET_MACHINE_STACK_END(p) __asm__ __volatile__ ("movq\t%%rsp, %0" : "=r" (*(p)))
+#elif defined(__i386) && defined(__GNUC__) && !defined(__native_client__)
+#define SET_MACHINE_STACK_END(p) __asm__ __volatile__ ("movl\t%%esp, %0" : "=r" (*(p)))
+#else
+NOINLINE(void rb_gc_set_stack_end(VALUE **stack_end_p));
+#define SET_MACHINE_STACK_END(p) rb_gc_set_stack_end(p)
+#define USE_CONSERVATIVE_STACK_END
+#endif
+
+/* for GC debug */
+
+#ifndef RUBY_MARK_FREE_DEBUG
+#define RUBY_MARK_FREE_DEBUG 0
+#endif
+
+#if RUBY_MARK_FREE_DEBUG
+extern int ruby_gc_debug_indent;
+
+static inline void
+rb_gc_debug_indent(void)
+{
+    printf("%*s", ruby_gc_debug_indent, "");
+}
+
+static inline void
+rb_gc_debug_body(const char *mode, const char *msg, int st, void *ptr)
+{
+    if (st == 0) {
+	ruby_gc_debug_indent--;
+    }
+    rb_gc_debug_indent();
+    printf("%s: %s %s (%p)\n", mode, st ? "->" : "<-", msg, ptr);
+
+    if (st) {
+	ruby_gc_debug_indent++;
+    }
+
+    fflush(stdout);
+}
+
+#define RUBY_MARK_ENTER(msg) rb_gc_debug_body("mark", (msg), 1, ptr)
+#define RUBY_MARK_LEAVE(msg) rb_gc_debug_body("mark", (msg), 0, ptr)
+#define RUBY_FREE_ENTER(msg) rb_gc_debug_body("free", (msg), 1, ptr)
+#define RUBY_FREE_LEAVE(msg) rb_gc_debug_body("free", (msg), 0, ptr)
+#define RUBY_GC_INFO         rb_gc_debug_indent(); printf
+
+#else
+#define RUBY_MARK_ENTER(msg)
+#define RUBY_MARK_LEAVE(msg)
+#define RUBY_FREE_ENTER(msg)
+#define RUBY_FREE_LEAVE(msg)
+#define RUBY_GC_INFO if(0)printf
+#endif
+
+#define RUBY_MARK_UNLESS_NULL(ptr) if(RTEST(ptr)){rb_gc_mark(ptr);}
+#define RUBY_FREE_UNLESS_NULL(ptr) if(ptr){ruby_xfree(ptr);(ptr)=NULL;}
+
+#if STACK_GROW_DIRECTION > 0
+# define STACK_UPPER(x, a, b) (a)
+#elif STACK_GROW_DIRECTION < 0
+# define STACK_UPPER(x, a, b) (b)
+#else
+RUBY_EXTERN int ruby_stack_grow_direction;
+int ruby_get_stack_grow_direction(volatile VALUE *addr);
+# define stack_growup_p(x) (			\
+	(ruby_stack_grow_direction ?		\
+	 ruby_stack_grow_direction :		\
+	 ruby_get_stack_grow_direction(x)) > 0)
+# define STACK_UPPER(x, a, b) (stack_growup_p(x) ? (a) : (b))
+#endif
+
+#if STACK_GROW_DIRECTION
+#define STACK_GROW_DIR_DETECTION
+#define STACK_DIR_UPPER(a,b) STACK_UPPER(0, (a), (b))
+#else
+#define STACK_GROW_DIR_DETECTION VALUE stack_grow_dir_detection
+#define STACK_DIR_UPPER(a,b) STACK_UPPER(&stack_grow_dir_detection, (a), (b))
+#endif
+#define IS_STACK_DIR_UPPER() STACK_DIR_UPPER(1,0)
+
+RUBY_SYMBOL_EXPORT_BEGIN
+
+/* exports for objspace module */
+size_t rb_objspace_data_type_memsize(VALUE obj);
+void rb_objspace_reachable_objects_from(VALUE obj, void (func)(VALUE, void *), void *data);
+void rb_objspace_reachable_objects_from_root(void (func)(const char *category, VALUE, void *), void *data);
+int rb_objspace_markable_object_p(VALUE obj);
+int rb_objspace_internal_object_p(VALUE obj);
+int rb_objspace_marked_object_p(VALUE obj);
+int rb_objspace_garbage_object_p(VALUE obj);
+
+void rb_objspace_each_objects(
+    int (*callback)(void *start, void *end, size_t stride, void *data),
+    void *data);
+
+void rb_objspace_each_objects_without_setup(
+    int (*callback)(void *, void *, size_t, void *),
+    void *data);
+
+RUBY_SYMBOL_EXPORT_END
+
+#endif /* RUBY_GC_H */

data/ext/objspace_helpers/ruby_private/internal_defs.h

@@ -0,0 +1,87 @@
+/* internal.h */
+
+#define STR_NOEMBED FL_USER1
+#define STR_SHARED  FL_USER2 /* = ELTS_SHARED */
+#define STR_ASSOC   FL_USER3
+#define STR_SHARED_P(s) FL_ALL((s), STR_NOEMBED|ELTS_SHARED)
+#define STR_ASSOC_P(s)  FL_ALL((s), STR_NOEMBED|STR_ASSOC)
+#define STR_NOCAPA  (STR_NOEMBED|ELTS_SHARED|STR_ASSOC)
+#define STR_NOCAPA_P(s) (FL_TEST((s),STR_NOEMBED) && FL_ANY((s),ELTS_SHARED|STR_ASSOC))
+#define STR_EMBED_P(str) (!FL_TEST((str), STR_NOEMBED))
+#define is_ascii_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT)
+#define is_broken_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN)
+
+#define HASH_DELETED  FL_USER1
+#define HASH_PROC_DEFAULT FL_USER2
+
+size_t rb_obj_memsize_of(VALUE);
+#define RB_OBJ_GC_FLAGS_MAX 5
+size_t rb_obj_gc_flags(VALUE, ID[], size_t);
+void rb_gc_mark_values(long n, const VALUE *values);
+
+
+/* vm_core.h */
+
+const char *ruby_node_name(int node);
+
+/* debug.h */
+
+VALUE rb_tracepoint_new(VALUE target_thread_not_supported_yet, rb_event_flag_t events, void (*func)(VALUE, void *), void *data);
+VALUE rb_tracepoint_enable(VALUE tpval);
+VALUE rb_tracepoint_disable(VALUE tpval);
+VALUE rb_tracepoint_enabled_p(VALUE tpval);
+
+typedef struct rb_trace_arg_struct rb_trace_arg_t;
+rb_trace_arg_t *rb_tracearg_from_tracepoint(VALUE tpval);
+
+rb_event_flag_t rb_tracearg_event_flag(rb_trace_arg_t *trace_arg);
+VALUE rb_tracearg_event(rb_trace_arg_t *trace_arg);
+VALUE rb_tracearg_lineno(rb_trace_arg_t *trace_arg);
+VALUE rb_tracearg_path(rb_trace_arg_t *trace_arg);
+VALUE rb_tracearg_method_id(rb_trace_arg_t *trace_arg);
+VALUE rb_tracearg_defined_class(rb_trace_arg_t *trace_arg);
+VALUE rb_tracearg_binding(rb_trace_arg_t *trace_arg);
+VALUE rb_tracearg_self(rb_trace_arg_t *trace_arg);
+VALUE rb_tracearg_return_value(rb_trace_arg_t *trace_arg);
+VALUE rb_tracearg_raised_exception(rb_trace_arg_t *trace_arg);
+VALUE rb_tracearg_object(rb_trace_arg_t *trace_arg);
+
+/* node.h */
+
+typedef struct RNode {
+    VALUE flags;
+    VALUE nd_reserved;		/* ex nd_file */
+    union {
+	struct RNode *node;
+	ID id;
+	VALUE value;
+	VALUE (*cfunc)(ANYARGS);
+	ID *tbl;
+    } u1;
+    union {
+	struct RNode *node;
+	ID id;
+	long argc;
+	VALUE value;
+    } u2;
+    union {
+	struct RNode *node;
+	ID id;
+	long state;
+	struct rb_global_entry *entry;
+	struct rb_args_info *args;
+	long cnt;
+	VALUE value;
+    } u3;
+} NODE;
+
+#define RNODE(obj)  (R_CAST(RNode)(obj))
+
+#define NODE_FL_NEWLINE             (((VALUE)1)<<7)
+#define NODE_FL_CREF_PUSHED_BY_EVAL (((VALUE)1)<<15)
+#define NODE_FL_CREF_OMOD_SHARED    (((VALUE)1)<<16)
+
+#define NODE_TYPESHIFT 8
+#define NODE_TYPEMASK  (((VALUE)0x7f)<<NODE_TYPESHIFT)
+
+#define nd_type(n) ((int) (((RNODE(n))->flags & NODE_TYPEMASK)>>NODE_TYPESHIFT))

data/ext/objspace_helpers/ruby_private/objspace.h

@@ -0,0 +1,15 @@
+/* object_tracing.c */
+struct allocation_info {
+  /* all of information don't need marking. */
+  int living;
+  VALUE flags;
+  VALUE klass;
+
+  /* allocation info */
+  const char *path;
+  unsigned long line;
+  const char *class_path;
+  VALUE mid;
+  size_t generation;
+};
+extern struct allocation_info *objspace_lookup_allocation_info(VALUE obj);

data/lib/objspace_helpers/helpers.rb

@@ -0,0 +1,28 @@
+class ObjspaceHelpers
+  def self.dump_all_addresses
+    _dump_addresses
+  end
+
+  def self.info_for_address(addresses)
+    _addresses_to_info(addresses)
+  end
+
+  def self.info_for_obj(obj)
+    _addresses_to_info([address_of(obj)]).values.first
+  end
+
+  def self.obj_for(address)
+    _obj_for_address(address)
+  end
+
+  def self.address_of(obj)
+    _address_of_obj(obj)
+  end
+
+  def self.diff(&block)
+    objs_before = dump_all_addresses
+    block.call
+    objs_after = dump_all_addresses
+    objs_after - objs_before - [address_of(objs_after)]
+  end
+end

data/lib/objspace_helpers/version.rb

@@ -0,0 +1,3 @@
+class ObjspaceHelpers
+  VERSION = '0.0.1'
+end

data/lib/objspace_helpers.rb

@@ -0,0 +1,6 @@
+require 'objspace'
+
+require 'objspace_helpers/version'
+require 'objspace_helpers/objspace_helpers'
+
+require 'objspace_helpers/helpers'

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: objspace_helpers
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Lukas Fittl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: Diff the heap to find leaks & get other ObjectSpace info more easily.
+email: lukas@fittl.com
+executables: []
+extensions:
+- ext/objspace_helpers/extconf.rb
+extra_rdoc_files: []
+files:
+- LICENSE
+- Rakefile
+- ext/objspace_helpers/extconf.rb
+- ext/objspace_helpers/objspace_helpers.c
+- ext/objspace_helpers/objspace_helpers.h
+- ext/objspace_helpers/objspace_info.c
+- ext/objspace_helpers/objspace_info.h
+- ext/objspace_helpers/ruby_private/gc.h
+- ext/objspace_helpers/ruby_private/internal_defs.h
+- ext/objspace_helpers/ruby_private/objspace.h
+- lib/objspace_helpers.rb
+- lib/objspace_helpers/helpers.rb
+- lib/objspace_helpers/version.rb
+homepage: http://github.com/lfittl/objspace_helpers
+licenses:
+- BSD-2-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Helper library to work with ObjectSpace in MRI Ruby 2.1+
+test_files: []