redlander 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 404c236f798d03be422ed5dfdec8d8973d078bce
-  data.tar.gz: 9c03079988a15a3e7d0ac629f40200a0601c25f3
+  metadata.gz: 1adddb051e9cc3f1aeda6b6eaa46012b87647506
+  data.tar.gz: 0cf0890720062fbc51b5123d27837aeb0ce86d3c
 SHA512:
-  metadata.gz: 4c124c2143a8be75a94744e8f235749d9da5b94dc3da9fdc2cfdeb3031bc80091c7cb8b4d89ae6cb541b81360c13177ece23105142543734a7ed380f9a97317c
-  data.tar.gz: 51abbecbb0071b5014c004d0ea807b0a2a0a22f8ff94e6f87f4f67ec0e2e33be8b320dbbfb340c1f26f9ae64ccb4a00b863e2fb94f7167319cf5fc37369cb592
+  metadata.gz: 3a0e2236aa7a13cb3d71c97b12d43d4079e41cbf9472731b26bc18e22f178970acb340c417f91c3c0e0fe8a0796e2ed6aa14f92c90d9aa0f7f7ebeb3424807be
+  data.tar.gz: d5cb579ca3f38910c6346f7706c0ddd296695c22626559c323445b445fef5e75060095b0d36c120062e62970c7c8befa7fbd76fd41e6f2e60007055202450561

data/ChangeLog

@@ -1,3 +1,7 @@
+redlander (0.6.2)
+  * fixed a few memory (double-freeing) issues
+  * memoizing the accessors for Statement, Node and Uri
+
 redlander (0.6.1)
   * librdf_query_set_offset from low-level API is now available
 

data/README.md

@@ -5,6 +5,7 @@ which is used to manipulate RDF graphs. This is an alternative implementation
 of Ruby bindings (as opposed to the official bindings), aiming to be more
 intuitive, lightweight, high-performing and as bug-free as possible.
 
+
 # Installing
 
 Installing Redlander is simple:
@@ -13,6 +14,7 @@ Installing Redlander is simple:
 
 Note, that you will have to install Redland runtime library (librdf) for Redlander to work.
 
+
 # Usage
 
 This README outlines most obvious use cases.
@@ -29,6 +31,7 @@ for the list of available options.
 Naturally, you don't need to create a model if you just want to play around
 with independent statements, nodes and the like.
 
+
 ## RDF Statements
 
 Now that you have created a model, you can access its RDF statements:
@@ -52,7 +55,8 @@ The API is almost identical to [ActiveRecord](https://github.com/rails/rails/tre
 
     $ m.statements.each { |st| puts st }
 
-Finding statements:
+
+### Finding and enumerating statements
 
     $ m.statements.find(:first, :object => "subject!")
     $ m.statements.all(:object => "another label")
@@ -60,7 +64,20 @@ Finding statements:
         puts statement.subject
       }
 
-Note that `m.statements.each` is "lazy", while `m.statements.all` (and other finders) is not.
+Note that `m.statements.each` does not have to pull and instantiate all statements in one call,
+while `m.statements.all` (and other finders) can potentially create huge arrays of data
+before you can handle individual statements of it.
+
+For those interested in laziness, `m.statements` has `lazy` method which works exactly as users of
+Ruby 2+ would expect:
+
+    $ m.statements.lazy.each {|s| puts s.object }
+
+This, and other similar features are inherited by `m.statements` (which is actually an instance of
+`Redlander::ModelProxy`) from `Enumerable` module.
+
+
+### Accessing and querying subject, predicate and object
 
 You can access the subject, predicate or object of a statement:
 
@@ -82,6 +99,7 @@ hash for *SELECT* queries. Binding hash values are instances of `Redlander::Node
 
 For query options and available query languages refer to `Model#query` documentation.
 
+
 ### Localized string literals
 
 Localized string literals are instantiated as LocalizedString objects.
@@ -191,6 +209,7 @@ SPARQL DESCRIBE is not implemented in librdf.
 # Authors and Contributors
 
 [Slava Kravchenko](https://github.com/cordawyn)
+[Anthony Bargnesi](https://github.com/abargnesi)
 
 
 # Thanks

data/lib/redlander.rb

@@ -12,17 +12,19 @@ require 'redlander/statement'
 # Main Redlander namespace
 module Redlander
   class << self
+
     # @api private
     def rdf_world
       unless @rdf_world
         @rdf_world = Redland.librdf_new_world
         raise RedlandError, "Could not create a new RDF world" if @rdf_world.null?
-        ObjectSpace.define_finalizer(self, proc { Redland.librdf_free_world(@rdf_world) })
+        ObjectSpace.define_finalizer(self, finalize_world(@rdf_world))
         Redland.librdf_world_open(@rdf_world)
       end
       @rdf_world
     end
 
+
     # @api private
     # Convert options hash into a string for librdf.
     # What it does:
@@ -44,5 +46,13 @@ module Redlander
         opts << "#{key}='#{value}'"
       }.join(',')
     end
+
+
+    private
+
+    # @api private
+    def finalize_world(rdf_world_ptr)
+      proc { Redland.librdf_free_world(rdf_world_ptr) }
+    end
   end
 end

data/lib/redlander/model.rb

@@ -12,6 +12,19 @@ module Redlander
     # @api private
     attr_reader :rdf_model
 
+    class << self
+      private
+
+      # @api private
+      def finalize_storage(rdf_storage_ptr)
+        proc { Redland.librdf_free_storage(rdf_storage_ptr) }
+      end
+
+      def finalize_model(rdf_model_ptr)
+        proc { Redland.librdf_free_model(rdf_model_ptr) }
+      end
+    end
+
     # Create a new RDF model.
     # (For available storage options see http://librdf.org/docs/api/redland-storage-modules.html)
     #
@@ -50,11 +63,12 @@ module Redlander
                                                 storage_name.to_s,
                                                 Redlander.to_rdf_options(options))
       raise RedlandError, "Failed to initialize '#{storage_name}' storage (type: #{storage_type})" if @rdf_storage.null?
-      ObjectSpace.define_finalizer(self, proc { Redland.librdf_free_storage(@rdf_storage) })
+      ObjectSpace.define_finalizer(self, self.class.send(:finalize_storage, @rdf_storage))
 
       @rdf_model = Redland.librdf_new_model(Redlander.rdf_world, @rdf_storage, "")
       raise RedlandError, "Failed to create a new model" if @rdf_model.null?
-      ObjectSpace.define_finalizer(self, proc { Redland.librdf_free_model(@rdf_model) })
+
+      ObjectSpace.define_finalizer(self, self.class.send(:finalize_model, @rdf_model))
     end
 
     # Statements contained in the model.

data/lib/redlander/node.rb

@@ -1,11 +1,50 @@
 module Redlander
   # RDF node (usually, a part of an RDF statement)
   class Node
+    class << self
+      private
+
+      # @api private
+      def finalize_node(rdf_node_ptr)
+        proc { Redland.librdf_free_node(rdf_node_ptr) }
+      end
+    end
+
     # @api private
-    attr_reader :rdf_node
+    def rdf_node
+      unless instance_variable_defined?(:@rdf_node)
+        @rdf_node = case @arg
+                    when FFI::Pointer
+                      @arg
+                    when NilClass
+                      Redland.librdf_new_node_from_blank_identifier(Redlander.rdf_world, @options[:blank_id])
+                    when URI
+                      Redland.librdf_new_node_from_uri_string(Redlander.rdf_world, @arg.to_s)
+                    else
+                      value = @arg.respond_to?(:xmlschema) ? @arg.xmlschema : @arg.to_s
+                      lang = @arg.respond_to?(:lang) ? @arg.lang.to_s : nil
+                      dt = lang ? nil : Uri.new(XmlSchema.datatype_of(@arg)).rdf_uri
+                      Redland.librdf_new_node_from_typed_literal(Redlander.rdf_world, value, lang, dt)
+                    end
+        raise RedlandError, "Failed to create a new node" if @rdf_node.null?
+        ObjectSpace.define_finalizer(self, self.class.send(:finalize_node, @rdf_node))
+      end
+      @rdf_node
+    end
 
     # Datatype URI for the literal node, or nil
-    attr_reader :datatype
+    def datatype
+      if instance_variable_defined?(:@datatype)
+        @datatype
+      else
+        @datatype = if literal?
+                      rdf_uri = Redland.librdf_node_get_literal_value_datatype_uri(rdf_node)
+                      rdf_uri.null? ? XmlSchema.datatype_of("") : URI.parse(Redland.librdf_uri_to_string(rdf_uri))
+                    else
+                      nil
+                    end
+      end
+    end
 
     # Create a RDF node.
     #
@@ -19,47 +58,31 @@ module Redlander
     # @option options [String] :blank_id optional ID to use for a blank node.
     # @raise [RedlandError] if it fails to create a node from the given args.
     def initialize(arg = nil, options = {})
-      @rdf_node = case arg
-                  when FFI::Pointer
-                    unless Redland.librdf_node_is_literal(arg).zero?
-                      rdf_uri = Redland.librdf_node_get_literal_value_datatype_uri(arg)
-                      @datatype = rdf_uri.null? ? XmlSchema.datatype_of("") : URI(Redland.librdf_uri_to_string(rdf_uri))
-                    end
-                    wrap(arg)
-                  when NilClass
-                    Redland.librdf_new_node_from_blank_identifier(Redlander.rdf_world, options[:blank_id])
-                  when URI
-                    Redland.librdf_new_node_from_uri_string(Redlander.rdf_world, arg.to_s)
-                  else
-                    @datatype = XmlSchema.datatype_of(arg)
-                    value = arg.respond_to?(:xmlschema) ? arg.xmlschema : arg.to_s
-                    lang = arg.respond_to?(:lang) ? arg.lang.to_s : nil
-                    dt = lang ? nil : Uri.new(@datatype).rdf_uri
-                    Redland.librdf_new_node_from_typed_literal(Redlander.rdf_world, value, lang, dt)
-                  end
-      raise RedlandError, "Failed to create a new node" if @rdf_node.null?
-      ObjectSpace.define_finalizer(self, proc { Redland.librdf_free_node(@rdf_node) })
+      # If FFI::Pointer is passed, wrap it instantly,
+      # because it can be freed outside before it is used here.
+      @arg = arg.is_a?(FFI::Pointer) ? wrap(arg) : arg
+      @options = options
     end
 
     # Check whether the node is a resource (identified by a URI)
     #
     # @return [Boolean]
     def resource?
-      Redland.librdf_node_is_resource(@rdf_node) != 0
+      Redland.librdf_node_is_resource(rdf_node) != 0
     end
 
     # Return true if node is a literal.
     #
     # @return [Boolean]
     def literal?
-      Redland.librdf_node_is_literal(@rdf_node) != 0
+      Redland.librdf_node_is_literal(rdf_node) != 0
     end
 
     # Return true if node is a blank node.
     #
     # @return [Boolean]
     def blank?
-      Redland.librdf_node_is_blank(@rdf_node) != 0
+      Redland.librdf_node_is_blank(rdf_node) != 0
     end
 
     # Equivalency. Only works for comparing two Nodes.
@@ -67,7 +90,7 @@ module Redlander
     # @param [Node] other_node Node to be compared with.
     # @return [Boolean]
     def eql?(other_node)
-      Redland.librdf_node_equals(@rdf_node, other_node.rdf_node) != 0
+      Redland.librdf_node_equals(rdf_node, other_node.rdf_node) != 0
     end
     alias_method :==, :eql?
 
@@ -79,7 +102,7 @@ module Redlander
     #
     # @return [String]
     def to_s
-      Redland.librdf_node_to_string(@rdf_node)
+      Redland.librdf_node_to_string(rdf_node)
     end
 
     # Internal URI of the Node.
@@ -90,7 +113,7 @@ module Redlander
     # @return [URI, nil]
     def uri
       if resource?
-        URI(to_s[1..-2])
+        URI.parse(to_s[1..-2])
       elsif literal?
         datatype
       else
@@ -108,20 +131,19 @@ module Redlander
       if resource?
         uri
       elsif blank?
-        Redland.librdf_node_get_blank_identifier(@rdf_node).force_encoding("UTF-8")
+        Redland.librdf_node_get_blank_identifier(rdf_node).force_encoding("UTF-8")
       else
-        v = Redland.librdf_node_get_literal_value(@rdf_node).force_encoding("UTF-8")
+        v = Redland.librdf_node_get_literal_value(rdf_node).force_encoding("UTF-8")
         v << "@#{lang}" if lang
-        XmlSchema.instantiate(v, @datatype)
+        XmlSchema.instantiate(v, datatype)
       end
     end
 
     def lang
-      lng = Redland.librdf_node_get_literal_value_language(@rdf_node)
+      lng = Redland.librdf_node_get_literal_value_language(rdf_node)
       lng ? lng.to_sym : nil
     end
 
-
     private
 
     # @api private

data/lib/redlander/query/results.rb

@@ -4,6 +4,15 @@ module Redlander
     class Results
       include Enumerable
 
+      class << self
+        private
+
+        # @api private
+        def finalize_query(rdf_query_ptr)
+          proc { Redland.librdf_free_query(rdf_query_ptr) }
+        end
+      end
+
       # (see Model#query)
       def initialize(q, options = {})
         language = options[:language] || "sparql10"
@@ -13,7 +22,7 @@ module Redlander
         @rdf_query = Redland.librdf_new_query(Redlander.rdf_world, language, language_uri, q, base_uri)
         raise RedlandError, "Failed to create a #{language.upcase} query from '#{q}'" if @rdf_query.null?
 
-        ObjectSpace.define_finalizer(self, proc { Redland.librdf_free_query(@rdf_query) })
+        ObjectSpace.define_finalizer(self, self.class.send(:finalize_query, @rdf_query))
       end
 
       def process(model)
@@ -76,6 +85,7 @@ module Redlander
         !Redland.librdf_query_results_is_syntax(@rdf_results).zero?
       end
 
+
       private
 
       def process_bindings

data/lib/redlander/statement.rb

@@ -1,8 +1,35 @@
 module Redlander
   # RDF statement
   class Statement
+    class << self
+      private
+
+      # @api private
+      def finalize_statement(rdf_statement_ptr)
+        proc { Redland.librdf_free_statement(rdf_statement_ptr) }
+      end
+    end
+
     # @api private
-    attr_reader :rdf_statement
+    def rdf_statement
+      unless instance_variable_defined?(:@rdf_statement)
+        @rdf_statement = case @source
+                         when FFI::Pointer
+                           @source
+                         when Hash
+                           # Create a new statement from nodes
+                           s = rdf_node_from(@source[:subject])
+                           p = rdf_node_from(@source[:predicate])
+                           o = rdf_node_from(@source[:object])
+                           Redland.librdf_new_statement_from_nodes(Redlander.rdf_world, s, p, o)
+                         else
+                           raise NotImplementedError, "Cannot create Statement from '#{@source.inspect}'"
+                         end
+        raise RedlandError, "Failed to create a new statement" if @rdf_statement.null?
+        ObjectSpace.define_finalizer(self, self.class.send(:finalize_statement, @rdf_statement))
+      end
+      @rdf_statement
+    end
 
     # Create an RDF statement.
     #
@@ -13,44 +40,45 @@ module Redlander
     # @raise [NotImplementedError] if cannot create a Statement from the given source.
     # @raise [RedlandError] if it fails to create a Statement.
     def initialize(source = {})
-      @rdf_statement = case source
-                       when FFI::Pointer
-                         wrap(source)
-                       when Hash
-                         # Create a new statement from nodes
-                         s = rdf_node_from(source[:subject])
-                         p = rdf_node_from(source[:predicate])
-                         o = rdf_node_from(source[:object])
-                         Redland.librdf_new_statement_from_nodes(Redlander.rdf_world, s, p, o)
-                       else
-                         raise NotImplementedError, "Cannot create Statement from '#{source.inspect}'"
-                       end
-      raise RedlandError, "Failed to create a new statement" if @rdf_statement.null?
-      ObjectSpace.define_finalizer(self, proc { Redland.librdf_free_statement(@rdf_statement) })
+      # If FFI::Pointer is passed, wrap it instantly,
+      # because it can be freed outside before it is used here.
+      @source = source.is_a?(FFI::Pointer) ? wrap(source) : source
     end
 
     # Subject of the statment.
     #
     # @return [Node, nil]
     def subject
-      rdf_node = Redland.librdf_statement_get_subject(@rdf_statement)
-      rdf_node.null? ? nil : Node.new(rdf_node)
+      if instance_variable_defined?(:@subject)
+        @subject
+      else
+        rdf_node = Redland.librdf_statement_get_subject(rdf_statement)
+        @subject = rdf_node.null? ? nil : Node.new(rdf_node)
+      end
     end
 
     # Predicate of the statement.
     #
     # @return [Node, nil]
     def predicate
-      rdf_node = Redland.librdf_statement_get_predicate(@rdf_statement)
-      rdf_node.null? ? nil : Node.new(rdf_node)
+      if instance_variable_defined?(:@predicate)
+        @predicate
+      else
+        rdf_node = Redland.librdf_statement_get_predicate(rdf_statement)
+        @predicate = rdf_node.null? ? nil : Node.new(rdf_node)
+      end
     end
 
     # Object of the statement.
     #
     # @return [Node, nil]
     def object
-      rdf_node = Redland.librdf_statement_get_object(@rdf_statement)
-      rdf_node.null? ? nil : Node.new(rdf_node)
+      if instance_variable_defined?(:@object)
+        @object
+      else
+        rdf_node = Redland.librdf_statement_get_object(rdf_statement)
+        @object = rdf_node.null? ? nil : Node.new(rdf_node)
+      end
     end
 
     # Set the subject of the statement
@@ -58,7 +86,8 @@ module Redlander
     # @param [Node, nil] node
     # @return [void]
     def subject=(node)
-      Redland.librdf_statement_set_subject(@rdf_statement, rdf_node_from(node))
+      Redland.librdf_statement_set_subject(rdf_statement, rdf_node_from(node))
+      @subject = node
     end
 
     # Set the predicate of the statement
@@ -66,7 +95,8 @@ module Redlander
     # @param [Node, nil] node
     # @return [void]
     def predicate=(node)
-      Redland.librdf_statement_set_predicate(@rdf_statement, rdf_node_from(node))
+      Redland.librdf_statement_set_predicate(rdf_statement, rdf_node_from(node))
+      @predicate = node
     end
 
     # Set the object of the statement
@@ -74,7 +104,8 @@ module Redlander
     # @param [Node, nil] node
     # @return [void]
     def object=(node)
-      Redland.librdf_statement_set_object(@rdf_statement, rdf_node_from(node))
+      Redland.librdf_statement_set_object(rdf_statement, rdf_node_from(node))
+      @object = node
     end
 
     def eql?(other_statement)
@@ -89,7 +120,7 @@ module Redlander
     end
 
     def to_s
-      Redland.librdf_statement_to_string(@rdf_statement)
+      Redland.librdf_statement_to_string(rdf_statement)
     end
 
 
@@ -112,9 +143,9 @@ module Redlander
       when NilClass
         nil
       when Node
-        source.rdf_node
+        Redland.librdf_new_node_from_node(source.rdf_node)
       else
-        Node.new(source).rdf_node
+        Redland.librdf_new_node_from_node(Node.new(source).rdf_node)
       end
     end
   end

data/lib/redlander/uri.rb

@@ -3,7 +3,30 @@ module Redlander
   # Uri (for internal use)
   class Uri
     # @api private
-    attr_reader :rdf_uri
+    def rdf_uri
+      unless instance_variable_defined?(:@rdf_uri)
+        @rdf_uri = case @source
+                   when FFI::Pointer
+                     @source
+                   when URI, String
+                     Redland.librdf_new_uri(Redlander.rdf_world, @source.to_s)
+                   else
+                     raise NotImplementedError, "Cannot create Uri from '#{@source.inspect}'"
+                   end
+        raise RedlandError, "Failed to create Uri from '#{@source.inspect}'" if @rdf_uri.null?
+        ObjectSpace.define_finalizer(self, self.class.send(:finalize_uri, @rdf_uri))
+      end
+      @rdf_uri
+    end
+
+    class << self
+      private
+
+      # @api private
+      def finalize_uri(rdf_uri_ptr)
+        proc { Redland.librdf_free_uri(rdf_uri_ptr) }
+      end
+    end
 
     # Create Redlander::Uri
     #
@@ -11,24 +34,15 @@ module Redlander
     # @raise [NotImplementedError] if cannot create a Uri from the given source.
     # @raise [RedlandError] if it fails to create a Uri.
     def initialize(source)
-      @rdf_uri = case source
-                 when FFI::Pointer
-                   wrap(source)
-                 when URI, String
-                   Redland.librdf_new_uri(Redlander.rdf_world, source.to_s)
-                 else
-                   raise NotImplementedError, "Cannot create Uri from '#{source.inspect}'"
-                 end
-      raise RedlandError, "Failed to create Uri from '#{source.inspect}'" if @rdf_uri.null?
-      ObjectSpace.define_finalizer(self, proc { Redland.librdf_free_uri(@rdf_uri) })
+      @source = source.is_a?(FFI::Pointer) ? wrap(source) : source
     end
 
     def to_s
-      Redland.librdf_uri_to_string(@rdf_uri)
+      Redland.librdf_uri_to_string(rdf_uri)
     end
 
     def eql?(other_uri)
-      other_uri.is_a?(Uri) && (Redland.librdf_uri_equals(@rdf_uri, other_uri.rdf_uri) != 0)
+      other_uri.is_a?(Uri) && (Redland.librdf_uri_equals(rdf_uri, other_uri.rdf_uri) != 0)
     end
     alias_method :==, :eql?
 

data/lib/redlander/version.rb

@@ -1,4 +1,4 @@
 module Redlander
   # Redlander version number
-  VERSION = "0.6.1"
+  VERSION = "0.6.2"
 end

data/spec/integration/finalizer_gc_spec.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+
+describe "garbage collection" do
+
+  describe Uri do
+    it "is garbage collected when destroyed" do
+      Uri.new("http://example.com/subject")
+      expect(ObjectSpace.each_object(Uri).count).to eq(1)
+      GC.start
+      expect(ObjectSpace.each_object(Uri).count).to eq(0)
+    end 
+  end
+
+  describe Node do
+    it "is garbage collected when destroyed" do
+      Node.new(test_statement[:subject])
+      expect(ObjectSpace.each_object(Node).count).to eq(1)
+      GC.start
+      expect(ObjectSpace.each_object(Node).count).to eq(0)
+    end
+  end
+
+  describe Statement do
+    it "is garbage collected when destroyed" do
+      Statement.new(test_statement)
+      expect(ObjectSpace.each_object(Statement).count).to eq(1)
+      GC.start
+      expect(ObjectSpace.each_object(Statement).count).to eq(0)
+    end
+  end
+
+  describe Model do
+    it "is garbage collected when destroyed" do
+      Model.new
+      expect(ObjectSpace.each_object(Model).count).to eq(1)
+      GC.start
+      expect(ObjectSpace.each_object(Model).count).to eq(0)
+    end
+  end
+
+  describe Query::Results do
+    it "is garbage collected when destroyed" do
+      model = Model.new
+      model.statements.add(Statement.new(test_statement))
+      model.query("select * {?s ?p ?o}")
+      expect(ObjectSpace.each_object(Query::Results).count).to eq(1)
+      GC.start
+      expect(ObjectSpace.each_object(Query::Results).count).to eq(0)
+    end
+  end
+
+  it "collects all objects after using Model" do
+    model = Model.new
+    expect(ObjectSpace.each_object(Model).count).to eq(1)
+
+    model.statements.add(Statement.new(test_statement))
+    expect(ObjectSpace.each_object(Node).count).to eq(3)
+    expect(ObjectSpace.each_object(Statement).count).to eq(1)
+
+    model.query("select * {?s ?p ?o}")
+    expect(ObjectSpace.each_object(Node).count).to eq(6)
+    expect(ObjectSpace.each_object(Query::Results).count).to eq(1)
+
+    # allow model to be garbage collected
+    model = nil
+
+    GC.start
+    expect(ObjectSpace.each_object(Model).count).to eq(0)
+    expect(ObjectSpace.each_object(Statement).count).to eq(0)
+    expect(ObjectSpace.each_object(Query::Results).count).to eq(0)
+  end
+
+  private
+
+  def test_statement
+    {
+      :subject => URI.parse("http://example.com/subject"),
+      :predicate => URI.parse("http://example.com/predicate"),
+      :object => URI.parse("object!")
+    }
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redlander
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2
 platform: ruby
 authors:
 - Slava Kravchenko
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-10 00:00:00.000000000 Z
+date: 2014-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xml_schema
@@ -84,6 +84,7 @@ files:
 - spec/fixtures/doap.nt
 - spec/fixtures/doap.rdf
 - spec/fixtures/doap.ttl
+- spec/integration/finalizer_gc_spec.rb
 - spec/integration/memory_leak_spec.rb
 - spec/lib/redlander/model_spec.rb
 - spec/lib/redlander/node_spec.rb
@@ -118,6 +119,7 @@ test_files:
 - spec/fixtures/doap.nt
 - spec/fixtures/doap.rdf
 - spec/fixtures/doap.ttl
+- spec/integration/finalizer_gc_spec.rb
 - spec/integration/memory_leak_spec.rb
 - spec/lib/redlander/model_spec.rb
 - spec/lib/redlander/node_spec.rb