librtree 0.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 35028e6e74b4682479656b89086bf47fb42a43bd09ce7c9070df53adffcf4cec
+  data.tar.gz: d58480430dada176e90f0e42e316b82be990fc4c414a993ce627a1b4b11ba707
+SHA512:
+  metadata.gz: 5bcb8f2b41ccab397f5accef4846912e9932dd07fa540c020c114a079ed9252296a8324ae647452170a445babcceb03984f258d053eb55d45566ad1b6da03d67
+  data.tar.gz: 8de9c0cbcfde749d139590c81d41b55bc78c73aa826cb5385f65e9b4a1c36e8a08abc3e1f5b751a082f33fadb3e56001dd8a391f93c6314f4728e5ec772454ab

data/ext/rtree/extconf.rb

@@ -0,0 +1,31 @@
+require 'mkmf'
+
+$CFLAGS << ' -std=c99'
+
+INCLUDEDIR = RbConfig::CONFIG['includedir']
+HEADER_DIRS = [
+  '/usr/local/include',
+  INCLUDEDIR,
+  '/usr/include',
+]
+
+LIBDIR = RbConfig::CONFIG['libdir']
+LIB_DIRS = [
+  '/usr/local/lib',
+  LIBDIR,
+  '/usr/lib'
+]
+
+puts LIB_DIRS.inspect
+
+dir_config('librtree', HEADER_DIRS, LIB_DIRS)
+
+abort 'missing csv.h' unless find_header('csv.h')
+abort 'missing jansson.h' unless find_header('jansson.h')
+abort 'missing rtree.h' unless find_header('rtree.h')
+
+abort "libcsv is missing" unless find_library('csv', 'csv_init')
+abort "libjansson is missing" unless find_library('jansson', 'json_pack')
+abort "librtree is missing" unless find_library('rtree', 'rtree_new')
+
+create_makefile 'rtree/rtree'

data/ext/rtree/rtree.c

@@ -0,0 +1,362 @@
+#include <ruby.h>
+#include <ruby/io.h>
+
+#include <rtree.h>
+
+#include <errno.h>
+#include <stdint.h>
+
+typedef struct
+{
+  void *rtree;
+} lrt_t;
+
+static void lrt_free(void *p)
+{
+  lrt_t *lrt = p;
+
+  if (lrt->rtree)
+    {
+      rtree_destroy(lrt->rtree);
+      lrt->rtree = NULL;
+    }
+}
+
+static VALUE lrt_alloc(VALUE cls)
+{
+  lrt_t *lrt;
+  VALUE obj = Data_Make_Struct(cls, lrt_t, NULL, lrt_free, lrt);
+
+  lrt->rtree = NULL;
+
+  return obj;
+}
+
+static VALUE lrt_init(VALUE self, VALUE dim_obj, VALUE flags_obj)
+{
+  Check_Type(dim_obj, T_FIXNUM);
+  size_t dim = FIX2ULONG(dim_obj);
+
+  Check_Type(dim_obj, T_FIXNUM);
+  state_flags_t flags = FIX2UINT(flags_obj);
+
+  lrt_t *lrt;
+  Data_Get_Struct(self, lrt_t, lrt);
+
+  if ((lrt->rtree = rtree_new(dim, flags)) == NULL)
+    rb_raise(rb_eNoMemError, "failed to create rtree");
+
+  return self;
+}
+
+static VALUE lrt_release(VALUE self)
+{
+  lrt_t *lrt;
+  Data_Get_Struct(self, lrt_t, lrt);
+
+  free(lrt->rtree);
+
+  return self;
+}
+
+static VALUE lrt_height(VALUE self)
+{
+  lrt_t *lrt;
+  Data_Get_Struct(self, lrt_t, lrt);
+
+  return INT2NUM(rtree_height(lrt->rtree));
+}
+
+static VALUE lrt_add_rect(VALUE self, VALUE id_obj, VALUE coord_obj)
+{
+  Check_Type(coord_obj, T_ARRAY);
+  Check_Type(id_obj, T_FIXNUM);
+
+  lrt_t *lrt;
+  Data_Get_Struct(self, lrt_t, lrt);
+
+  rtree_t
+    *rtree = lrt->rtree;
+  rtree_id_t
+    id = FIX2ULONG(id_obj);
+  size_t
+    len = RARRAY_LEN(coord_obj),
+    dim = state_dims(rtree->state);
+
+  if (len != 2 * dim)
+    rb_raise(rb_eArgError, "expected array length %zi, got %zi", 2 * dim, len);
+
+  rtree_coord_t coord[len];
+
+  for (size_t i = 0 ; i < len ; i++)
+    coord[i] = NUM2DBL(rb_ary_entry(coord_obj, i));
+
+  int err;
+
+  if ((err = rtree_add_rect(rtree, id, coord)) != 0)
+    {
+      if (errno)
+        rb_sys_fail("add_rect");
+      else
+        rb_raise(rb_eRuntimeError, "%s", rtree_strerror(err));
+    }
+
+  return self;
+}
+
+/* update rectangles in the tree without changing its structure */
+
+static int update_cb(rtree_id_t id, rtree_coord_t *coord, void *context)
+{
+  size_t len = *(size_t*)context;
+  VALUE id_obj = INT2NUM(id);
+  VALUE coord_obj = rb_ary_new2(len);
+
+  for (size_t i = 0 ; i < len ; i++)
+    rb_ary_store(coord_obj, i, DBL2NUM(coord[i]));
+
+  coord_obj = rb_yield_values(2, id_obj, coord_obj);
+
+  Check_Type(coord_obj, T_ARRAY);
+  if (len != (size_t)RARRAY_LEN(coord_obj))
+    rb_raise(rb_eArgError, "Array of wrong size");
+
+  for (size_t i = 0 ; i < len ; i++)
+    coord[i] = NUM2DBL(rb_ary_entry(coord_obj, i));
+
+  return 0;
+}
+
+static VALUE lrt_update(VALUE self)
+{
+  if (!rb_block_given_p())
+    rb_raise(rb_eArgError, "Expected block");
+
+  lrt_t *lrt;
+  Data_Get_Struct(self, lrt_t, lrt);
+  rtree_t *rtree = lrt->rtree;
+  size_t len = 2 * state_dims(rtree->state);
+
+  int err = rtree_update(rtree, update_cb, &len);
+
+  if (err != 0)
+    rb_raise(rb_eRuntimeError, "librtree: %s", strerror(err));
+
+  return self;
+}
+
+/*
+  The librtree API expects the search callback to return zero to
+  continue the search, non-zero to terminate. I was expecting to
+  need to wrap the 'yield' in 'rescue's and 'ensure's to handle
+  exceptions and breaks, but find that doing nothing actually does
+  the right thing (see specs).  The search implemetation is just
+  a recursive search through the tree (as you would expect) so
+  there is no end-of-search cleanup to do, so I think this is all
+  just fine ... wild
+*/
+
+static int search_cb(rtree_id_t id, void *context)
+{
+  rb_yield(INT2NUM(id));
+  return 0;
+}
+
+static VALUE lrt_search(VALUE self, VALUE coord_obj)
+{
+  if (!rb_block_given_p())
+    rb_raise(rb_eArgError, "Expected block");
+
+  Check_Type(coord_obj, T_ARRAY);
+
+  lrt_t *lrt;
+  Data_Get_Struct(self, lrt_t, lrt);
+
+  rtree_t
+    *rtree = lrt->rtree;
+  size_t
+    len = RARRAY_LEN(coord_obj),
+    dim = state_dims(rtree->state);
+
+  if (len != 2 * dim)
+    rb_raise(rb_eArgError, "expected array length %zi, got %zi", 2 * dim, len);
+
+  rtree_coord_t coord[len];
+
+  for (size_t i = 0 ; i < len ; i++)
+    coord[i] = NUM2DBL(rb_ary_entry(coord_obj, i));
+
+  rtree_search(rtree, coord, search_cb, NULL);
+
+  return Qnil;
+}
+
+/* deserialisation */
+
+typedef rtree_t* (deserialise_t)(FILE*);
+
+static VALUE deserialise(VALUE cls, VALUE io_obj, deserialise_t *f)
+{
+  Check_Type(io_obj, T_FILE);
+
+  rb_io_t *io;
+  GetOpenFile(io_obj, io);
+  rb_io_check_initialized(io);
+  rb_io_check_readable(io);
+  FILE *fp = rb_io_stdio_file(io);
+
+  rtree_t *rtree;
+  errno = 0;
+  if ((rtree = f(fp)) == NULL)
+    {
+      if (errno)
+        rb_sys_fail(__func__);
+      else
+        rb_raise(rb_eRuntimeError, "Failed read from stream");
+    }
+
+  lrt_t *lrt;
+  VALUE obj = Data_Make_Struct(cls, lrt_t, NULL, lrt_free, lrt);
+
+  lrt->rtree = rtree;
+
+  return obj;
+}
+
+static VALUE lrt_json_read(VALUE cls, VALUE io_obj)
+{
+  return deserialise(cls, io_obj, rtree_json_read);
+}
+
+static VALUE lrt_bsrt_read(VALUE cls, VALUE io_obj)
+{
+  return deserialise(cls, io_obj, rtree_bsrt_read);
+}
+
+static VALUE lrt_csv_read(VALUE cls,
+                          VALUE io_obj, VALUE dim_obj, VALUE flags_obj)
+{
+  Check_Type(io_obj, T_FILE);
+  rb_io_t *io;
+  GetOpenFile(io_obj, io);
+  rb_io_check_initialized(io);
+  rb_io_check_readable(io);
+  FILE *fp = rb_io_stdio_file(io);
+
+  Check_Type(dim_obj, T_FIXNUM);
+  size_t dim = FIX2ULONG(dim_obj);
+
+  Check_Type(dim_obj, T_FIXNUM);
+  state_flags_t flags = FIX2UINT(flags_obj);
+
+  rtree_t *rtree;
+  errno = 0;
+  if ((rtree = rtree_csv_read(fp, dim, flags)) == NULL)
+    {
+      if (errno)
+        rb_sys_fail(__func__);
+      else
+        rb_raise(rb_eRuntimeError, "Failed read from stream");
+    }
+
+  lrt_t *lrt;
+  VALUE obj = Data_Make_Struct(cls, lrt_t, NULL, lrt_free, lrt);
+
+  lrt->rtree = rtree;
+
+  return obj;
+}
+
+/* serialisation */
+
+typedef int (serialise_t)(const rtree_t*, FILE*);
+
+static VALUE serialise(VALUE self, VALUE io_obj, serialise_t *f)
+{
+  Check_Type(io_obj, T_FILE);
+
+  rb_io_t *io;
+  GetOpenFile(io_obj, io);
+  rb_io_check_initialized(io);
+  rb_io_check_writable(io);
+  FILE *fp = rb_io_stdio_file(io);
+
+  lrt_t *lrt;
+  Data_Get_Struct(self, lrt_t, lrt);
+  rtree_t *rtree = lrt->rtree;
+
+  int err = f(rtree, fp);
+  if (err != 0)
+    rb_raise(rb_eRuntimeError, "librtree: %s", rtree_strerror(err));
+
+  return self;
+}
+
+static VALUE lrt_json_write(VALUE self, VALUE io_obj)
+{
+  return serialise(self, io_obj, rtree_json_write);
+}
+
+static VALUE lrt_bsrt_write(VALUE self, VALUE io_obj)
+{
+  return serialise(self, io_obj, rtree_bsrt_write);
+}
+
+static VALUE lrt_identical(VALUE self, VALUE other)
+{
+  lrt_t *lrt_self, *lrt_other;
+  Data_Get_Struct(self, lrt_t, lrt_self);
+  Data_Get_Struct(other, lrt_t, lrt_other);
+  rtree_t
+    *rtree_self = lrt_self->rtree,
+    *rtree_other = lrt_other->rtree;
+
+  if (rtree_identical(rtree_self, rtree_other))
+    return Qtrue;
+  else
+    return Qfalse;
+}
+
+static VALUE lrt_clone(VALUE self)
+{
+  lrt_t *lrt;
+  Data_Get_Struct(self, lrt_t, lrt);
+  rtree_t *rtree;
+
+  errno = 0;
+  if ((rtree = rtree_clone(lrt->rtree)) == NULL)
+    {
+      if (errno)
+        rb_sys_fail(__func__);
+      else
+        rb_raise(rb_eRuntimeError, "Failed clone");
+    }
+
+  lrt_t *lrt_cloned;
+  VALUE cls = CLASS_OF(self);
+  VALUE obj = Data_Make_Struct(cls, lrt_t, NULL, lrt_free, lrt_cloned);
+
+  lrt_cloned->rtree = rtree;
+
+  return obj;
+}
+
+void Init_rtree(void)
+{
+  VALUE cls = rb_const_get(rb_cObject, rb_intern("RTreeC"));
+
+  rb_define_alloc_func(cls, lrt_alloc);
+  rb_define_method(cls, "initialize", lrt_init, 2);
+  rb_define_method(cls, "free", lrt_release, 0);
+  rb_define_method(cls, "clone", lrt_clone, 0);
+  rb_define_method(cls, "update!", lrt_update, 0);
+  rb_define_method(cls, "height", lrt_height, 0);
+  rb_define_method(cls, "add_rect", lrt_add_rect, 2);
+  rb_define_method(cls, "search", lrt_search, 1);
+  rb_define_method(cls, "json_write", lrt_json_write, 1);
+  rb_define_method(cls, "bsrt_write", lrt_bsrt_write, 1);
+  rb_define_method(cls, "eq?", lrt_identical, 1);
+  rb_define_singleton_method(cls, "json_read", lrt_json_read, 1);
+  rb_define_singleton_method(cls, "bsrt_read", lrt_bsrt_read, 1);
+  rb_define_singleton_method(cls, "csv_read", lrt_csv_read, 3);
+}

data/lib/rtree.rb

@@ -0,0 +1,328 @@
+# The C extension
+class RTreeC ; end
+
+# @author RTree J. J. Green
+#
+# A Ruby wrapper around
+# {http://soliton.vm.bytemark.co.uk/pub/jjg/en/code/librtree librtree}
+# implementing the R-tree spatial index of Guttman-Green.
+#
+# Given a set or rectangles (or higher dimensional cuboids) and their
+# associated ids, one can build an {RTree} using the {.csv_read} class
+# method or repeated calls to the {#add_rect} instance method.  The
+# former is more performant since it avoids routing the rectangles
+# through the Ruby-C interface.
+#
+# Once the {RTree} instance is created one can make spatial queries
+# against it with the {#search} method; one passes a rectangle to the
+# method and it returns the ids of all of the input rectangles which
+# intersect it (or yields them one at a time to a block, if given).
+#
+# It may be convenient to serialise the {RTree} for faster loading, the
+# library implements a custom binary format, BSRT (binary serialised
+# R-tree) which can be written by {#bsrt_write} and read with {.bsrt_read}.
+# One can also serialise to JSON, but this results in a much larger file
+# (a factor of ten) and so correspondingly slow to read/write.  Useful,
+# nevertheless, for debugging and loading into a native Ruby hash format
+# (see {#to_h}).
+#
+# All rectangles used in the library are simply arrays of floats, the
+# lower value for each dimension, followed by the upper value for each
+# dimension.  Thus
+#
+#    [0, 0, 1, 2]
+#
+# is the rectangle with 0 ≤ _x_ ≤ 1 and 0 ≤ _y_ ≤ 2. Upper and lower
+# values may coincide (to create a line segment in 2-space, for example)
+# but a lower value larger than the upper value will cause an error.
+#
+# It is anticipated that the ids passed to the library will be used as
+# an index for application specific data to which this rectangle relates
+# (its location in an array, or a DB id) but this is entirely at the
+# discretion of the caller, the library makes no use of the value, treating
+# it as payload. In particular, the value may be non-unique and may be zero.
+# One should note that the id type used internally by the library is
+# determined at compile-time (with the RTREE_ID_TYPE variable) and by
+# default this is a 32-bit unsigned integer.
+#
+class RTree < RTreeC
+
+  class << self
+
+    # Create a new RTree instance from JSON stream
+    # @param io [IO] a readable stream object
+    # @return [RTree] the newly instantiated RTree
+    # @see #json_write
+    # @example Read from file
+    #   rtree = File.open('rtree.json', 'r') { |io| RTree.json_read(io) }
+    def json_read(io)
+      super
+    end
+
+    # Create a new RTree instance from JSON string
+    # @param json [String] a JSON string
+    # @return [RTree] the newly instantiated RTree
+    # @see #to_json
+    def from_json(json)
+      deserialise(json, Encoding::UTF_8) { |io| json_read(io) }
+    end
+
+    # Create a new RTree instance from BSRT (binary serialised R-tree)
+    # stream
+    # @param io [IO] a readable stream object
+    # @return [RTree] the newly instantiated RTree
+    # @see #bsrt_write
+    # @example Read from file
+    #   rtree = File.open('rtree.bsrt', 'r') { |io| RTree.bsrt_read(io) }
+    def bsrt_read(io)
+      super
+    end
+
+    # Create a new RTree instance from BSRT (binary serialised R-tree)
+    # string
+    # @param bsrt [String] a binary encoded string
+    # @return [RTree] the newly instantiated RTree
+    # @see #to_bsrt
+    def from_bsrt(bsrt)
+      deserialise(bsrt, Encoding::BINARY) { |io| bsrt_read(io) }
+    end
+
+    # Build a new RTree instance from CSV stream
+    # @param io [IO] a readable stream object
+    # @param dim [Integer] the dimension of the tree
+    # @param split [:linear, :quadratic] See {#initialize}
+    # @param node_page [Integer] See {#initialize}
+    # @return [RTree] the newly built RTree
+    def csv_read(io, dim, split: :quadratic, node_page: 0)
+      flags = split_flag(split) | node_page_flag(node_page)
+      super(io, dim, flags)
+    end
+
+    # Build a new RTree instance from CSV string
+    # @param csv [String] the CSV data in a string
+    # @param dim [Integer] the dimension of the tree
+    # @param kwarg [Hash] As for {.csv_read}
+    # @return [RTree] the newly built RTree
+    def from_csv(csv, dim, **kwarg)
+      deserialise(csv, Encoding::UTF_8) do |io|
+        csv_read(io, dim, **kwarg)
+      end
+    end
+
+    # @!visibility private
+    def split_flag(split)
+      case split
+      when :quadratic
+        0
+      when :linear
+        1
+      else
+        raise ArgumentError, "bad split value: #{split}"
+      end
+    end
+
+    # @!visibility private
+    def node_page_flag(node_page)
+      node_page << 2
+    end
+
+    private
+
+    def deserialise(string, encoding)
+      raise TypeError unless string.is_a? String
+      rd, wr = IO.pipe(encoding)
+      if fork then
+        wr.close
+        begin
+          result = yield(rd)
+        ensure
+          rd.close
+          Process.wait
+        end
+      else
+        rd.close
+        begin
+          wr.write(string)
+        ensure
+          wr.close
+          exit!
+        end
+      end
+      result
+    end
+  end
+
+  # Initialize a new (empty) RTree
+  # @param dim [Integer] the dimension of the tree
+  # @param split [:linear, :quadratic] determines the splitting strategy,
+  #   the linear strategy is faster to build, the quadratic produces a
+  #   better-quality R-tree which is faster to query.
+  # @param node_page [Integer] the nodes-per-page value. This value can
+  #   affect performance quite dramatically, particularly build time. A
+  #   value which is too large would result in an infeasible branching
+  #   factor for the R-tree and will case the function to error with errno
+  #   set to EINVAL. A value of zero is permitted and the default; in
+  #   this case the function will choose a good value based on heuristics.
+  #   You may get better performance for your use-case by manual
+  #   experimentation, but zero is a good place to start.
+  # @return [RTree] the newly instantiated RTree
+  def initialize(dim, split: :quadratic, node_page: 0)
+    @split = split
+    @node_page = node_page
+    super(dim, flags)
+  end
+
+  # Create a deep copy
+  # @return [RTree] a deep copy of the RTree
+  def clone
+    super
+  end
+
+  # Add a rectangle to the RTree
+  # @param id [Integer] the id of the rectangle. It is anticipated that
+  #   the id will be used as an index for application specific data to
+  #   which this rectangle relates, but this is entirely at the discretion
+  #   of the caller, the library makes no use of the value, treating it as
+  #   payload. In particular, the value may be non-unique and may be zero.
+  # @param coords [Array<Float>] the extent of the rectangle, the minima
+  #   for each dimension, then the maxima for each dimension.
+  # @return [self]
+  # @example Add a rectangle to a dimension two RTree
+  #   rtree = RTree.new(2)
+  #   rtree.add_rect(7, [0, 0, 1, 1])
+  def add_rect(id, coords)
+    super
+  end
+
+  # Search the RTree
+  # @param coords [Array<Float>] the search rectangle, as {#add_rect}
+  # @return [Array<Integer>] the ids of all rectangles which intersect
+  #   the search rectangle. If a block is given then these values will
+  #   be yielded to the block (one at a time).
+  def search(coords)
+    if block_given? then
+      super
+    else
+      ids = []
+      super(coords) { |id| ids << id }
+      ids
+    end
+  end
+
+  # Update the RTree.  Modifies the rectangles in-place without changing
+  # the tree structure.  Provided that the changes are small, the search
+  # efficiency should be close to that of freshly built RTree.
+  # @yieldparam id [Integer] see {#add_rect}
+  # @yieldparam coords [Array<Float>] see {#add_rect}
+  # @yieldreturn [Array<Float>] the modified rectangle extent
+  # @return [self]
+  # @example Shift all rectangles by ε
+  #   rtree.update! { |id, coords| coords.map { |x| x + ε } }
+  # @note In the C library, the implementation (via a C callback function)
+  #   is much faster than rebuilding the R-tree; in this Ruby interface
+  #   the callback must convert C floats to Ruby, yield them to the
+  #   block and then convert the returned Ruby Floats to C; so we would
+  #   expect that it loses much of its competetive advantage when
+  #   compared to an R-tree rebuild.
+  def update!
+    super
+  end
+
+  # The height to the tree in the usual mathematical sense
+  # @return [Integer] the tree height
+  def height
+    super
+  end
+
+  # Whether the RTree has any rectangles or not
+  # @return [Boolean] true if the RTree is empty
+  def empty?
+    height == 0
+  end
+
+  # Serialise to JSON stream
+  # @param io [IO] a writeable stream
+  # @return [self]
+  # @see .json_read
+  # @example Write to file
+  #   File.open('rtree.json', 'w') { |io| rtree.json_write(io) }
+  def json_write(io)
+    super
+  end
+
+  # Serialise to BSRT (binary serialised R-tree) stream
+  # @param io [IO] a writeable stream
+  # @return [self]
+  # @see .bsrt_read
+  # @example Write to file
+  #   File.open('rtree.bsrt', 'w') { |io| rtree.bsrt_write(io) }
+  def bsrt_write(io)
+    super
+  end
+
+  # Serialise to JSON string
+  # @return [String] the UTF-8 encoded JSON
+  # @see .from_json
+  def to_json
+    serialise(Encoding::UTF_8) { |io| json_write(io) }
+  end
+
+  # Serialise to BSRT string
+  # @return [String] the binary encoded BSRT
+  # @see .from_bsrt
+  def to_bsrt
+    serialise(Encoding::BINARY) { |io| bsrt_write(io) }
+  end
+
+  # The RTree structure in hash form
+  # @return [Hash]
+  def to_h
+    JSON.parse(to_json, symbolize_names: true)
+  end
+
+  # Equality of RTrees.  This is a rather strict equality,
+  # not only must the tree have the same rectangkes, they
+  # must be in the same order. Certainly {#clone} will produce
+  # an instance which is equal in this sense.
+  # @return [Boolean] true if the instances are identical
+  def eq?(other)
+    super
+  end
+
+  alias_method(:==, :eq?)
+
+  private
+
+  attr_reader :split, :node_page
+
+  def split_flag
+    self.class.split_flag(split)
+  end
+
+  def node_page_flag
+    self.class.node_page_flag(node_page)
+  end
+
+  def flags
+    node_page_flag | split_flag
+  end
+
+  def serialise(encoding)
+    rd, wr = IO.pipe(encoding)
+    if fork then
+      wr.close
+      result = rd.read
+      rd.close
+      Process.wait
+    else
+      rd.close
+      yield(wr)
+      wr.close
+      exit!
+    end
+    result
+  end
+
+end
+
+require 'rtree/rtree'

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: librtree
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+platform: ruby
+authors:
+- J.J. Green
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-05-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 0.2.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 0.2.4
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+description: |
+  A Ruby native extension for librtree implementing the R-tree
+  spatial-index of Guttman-Green.
+email: j.j.green@gmx.co.uk
+executables: []
+extensions:
+- ext/rtree/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/rtree/extconf.rb
+- ext/rtree/rtree.c
+- lib/rtree.rb
+homepage: https://gitlab.com/jjg/librtree-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- ext
+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:
+- The librtree library
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: R-tree spatial index
+test_files: []