redlander 0.2.2 → 0.3.1

data/lib/redlander/parser_proxy.rb

@@ -1,18 +1,19 @@
-require 'redlander/statement'
-
 module Redlander
-
   class ParserProxy
-
-    include StatementIterator
+    include StreamEnumerator
 
     def initialize(parser, content, options = {})
-      @model = nil  # the yielded statements will not be bound to a model
-      @rdf_stream = Redland.librdf_parser_parse_string_as_stream(parser.rdf_parser, content, Redlander.to_rdf_uri(options[:base_uri]))
-      raise RedlandError.new("Failed to create a new stream") unless @rdf_stream
-      ObjectSpace.define_finalizer(@rdf_stream, proc { Redland.librdf_free_stream(@rdf_stream) })
+      # TODO: consider a streaming content, as it may be large to fit in memory
+      @parser = parser
+      @content = content
+      @options = options
     end
 
-  end
 
+    private
+
+    def reset_stream
+      @stream = Stream.new(@parser, @content, @options)
+    end
+  end
 end

data/lib/redlander/serializer.rb

@@ -1,7 +1,5 @@
 module Redlander
-
   class Serializer
-
     # Create a new serializer.
     # Name can be either of [:rdfxml, :ntriples, :turtle, :json, :dot],
     # or nil, which defaults to :rdfxml.
@@ -10,8 +8,8 @@ module Redlander
     # because the rest seem to be very buggy.
     def initialize(name = :rdfxml)
       @rdf_serializer = Redland.librdf_new_serializer(Redlander.rdf_world, name.to_s, nil, nil)
-      raise RedlandError.new("Failed to create a new serializer") unless @rdf_serializer
-      ObjectSpace.define_finalizer(@rdf_serializer, proc { Redland.librdf_free_serializer(@rdf_serializer) })
+      raise RedlandError.new("Failed to create a new serializer") if @rdf_serializer.null?
+      ObjectSpace.define_finalizer(self, proc { Redland.librdf_free_serializer(@rdf_serializer) })
     end
 
     # Serialize a model into a string.
@@ -19,7 +17,12 @@ module Redlander
     # Options are:
     #   :base_uri   base URI (String or URI)
     def to_string(model, options = {})
-      Redland.librdf_serializer_serialize_model_to_string(@rdf_serializer, Redlander.to_rdf_uri(options[:base_uri]), model.rdf_model)
+      base_uri = if options.has_key?(:base_uri)
+                   Uri.new(options[:base_uri]).rdf_uri
+                 else
+                   nil
+                 end
+      Redland.librdf_serializer_serialize_model_to_string(@rdf_serializer, base_uri, model.rdf_model)
     end
 
     # Serializes a model and stores it in a file
@@ -31,14 +34,18 @@ module Redlander
     #
     # Returns true on success, or false.
     def to_file(model, filename, options = {})
-      Redland.librdf_serializer_serialize_model_to_file(@rdf_serializer, filename, Redlander.to_rdf_uri(options[:base_uri]), model.rdf_model).zero?
+      base_uri = if options.has_key?(:base_uri)
+                   Uri.new(options[:base_uri]).rdf_uri
+                 else
+                   nil
+                 end
+      Redland.librdf_serializer_serialize_model_to_file(@rdf_serializer, filename, base_uri, model.rdf_model).zero?
     end
-
   end
 
 
+  # Applied to Model
   module SerializingInstanceMethods
-
     def to_rdfxml(options = {})
       serializer = Serializer.new(:rdfxml)
       serializer.to_string(self, options)
@@ -74,7 +81,5 @@ module Redlander
       serializer = Serializer.new(serializer_options.delete(:format) || :rdfxml)
       serializer.to_file(self, filename, serializer_options)
     end
-
   end
-
 end

data/lib/redlander/statement.rb

@@ -1,105 +1,73 @@
 module Redlander
-
   class Statement
-
     include ErrorContainer
 
     attr_reader :rdf_statement
 
     # Create an RDF statement.
-    # Options are:
-    #   :subject
-    #   :predicate
-    #   :object
-    def initialize(options = {})
-      @rdf_statement = if options.is_a?(SWIG::TYPE_p_librdf_statement_s)
-                         # A special case, where you can pass an instance of SWIG::TYPE_p_librdf_statement_s
-                         # in order to create a Statement from an internal RDF statement representation.
-                         options
-                       else
-                         s = options[:subject] && Node.new(options[:subject]).rdf_node
-                         p = options[:predicate] && Node.new(options[:predicate]).rdf_node
-                         o = options[:object] && Node.new(options[:object]).rdf_node
+    # Source can be:
+    #   Hash, where
+    #     :subject
+    #     :predicate
+    #     :object
+    #   Stream, so that a statement is extracted from its current position
+    def initialize(source = {})
+      @rdf_statement = case source
+                       when Stream
+                         # Pull a (current) statement from the stream
+                         Redland.librdf_stream_get_object(source.rdf_stream)
+                       when Hash
+                         # Create a new statement from nodes
+                         s = source[:subject] && Node.new(source[:subject]).rdf_node
+                         p = source[:predicate] && Node.new(source[:predicate]).rdf_node
+                         o = source[:object] && Node.new(source[:object]).rdf_node
                          Redland.librdf_new_statement_from_nodes(Redlander.rdf_world, s, p, o)
+                       else
+                         # TODO
+                         raise NotImplementedError.new
                        end
-
-      raise RedlandError.new("Failed to create a new statement") unless @rdf_statement
-      ObjectSpace.define_finalizer(@rdf_statement, proc { Redland.librdf_free_statement(@rdf_statement) })
+      raise RedlandError.new("Failed to create a new statement") if @rdf_statement.null?
+      ObjectSpace.define_finalizer(self, proc { Redland.librdf_free_statement(@rdf_statement) })
     end
 
     def subject
-      rdf_node = Redland.librdf_statement_get_subject(@rdf_statement)
-      rdf_node && Node.new(rdf_node)
+      node = Node.new(self, :subject)
+      node.rdf_node.null? ? nil : node
     end
 
     def predicate
-      rdf_node = Redland.librdf_statement_get_predicate(@rdf_statement)
-      rdf_node && Node.new(rdf_node)
+      node = Node.new(self, :predicate)
+      node.rdf_node.null? ? nil : node
     end
 
     def object
-      rdf_node = Redland.librdf_statement_get_object(@rdf_statement)
-      rdf_node && Node.new(rdf_node)
+      node = Node.new(self, :object)
+      node.rdf_node.null? ? nil : node
     end
 
     # set the subject of the statement
     def subject=(node)
-      Redland.librdf_statement_set_subject(@rdf_statement, rdf_node_from(node))
+      binding_to_statement(node) {
+        Redland.librdf_statement_set_subject(@rdf_statement, node.rdf_node)
+      }
     end
 
     # set the predicate of the statement
     def predicate=(node)
-      Redland.librdf_statement_set_predicate(@rdf_statement, rdf_node_from(node))
+      binding_to_statement(node) {
+        Redland.librdf_statement_set_predicate(@rdf_statement, node.rdf_node)
+      }
     end
 
     # set the object of the statement
     def object=(node)
-      Redland.librdf_statement_set_object(@rdf_statement, rdf_node_from(node))
-    end
-
-    def model
-      @model
-    end
-
-    # Add the statement to the given model.
-    #
-    # Returns the model on success, or nil.
-    # NOTE: Duplicate statements are not added to the model.
-    # However, this doesn't result in an error here.
-    def model=(model)
-      if model.nil?
-        @model = nil
-      else
-        if self.valid?
-          if Redland.librdf_model_add_statement(model.rdf_model, @rdf_statement).zero?
-            @model = model
-          else
-            nil
-          end
-        end
-      end
-    end
-
-    # Destroy the statement (remove it from the model, if possible).
-    #
-    # Returns true if successfully removed from the model, or false.
-    # If the statement is not bound to a model, false is returned.
-    def destroy
-      if @model
-        if Redland.librdf_model_remove_statement(@model.rdf_model, @rdf_statement).zero?
-          self.model = nil
-          true
-        else
-          false
-        end
-      else
-        false
-      end
+      binding_to_statement(node) {
+        Redland.librdf_statement_set_object(@rdf_statement, node.rdf_node)
+      }
     end
 
     def eql?(other_statement)
-      model == other_statement.model &&
-        subject == other_statement.subject &&
+      subject == other_statement.subject &&
         predicate == other_statement.predicate &&
         object == other_statement.object
     end
@@ -116,38 +84,26 @@ module Redlander
     # A valid statement satisfies the following:
     # URI or blank subject, URI predicate and URI or blank or literal object (i.e. anything).
     def valid?
-      if is_valid = attributes_satisfy?
-        errors.clear
-      else
-        errors.add("is invalid")
-      end
-      is_valid
+      attributes_satisfy? ? errors.clear : errors.add("is invalid")
+      errors.empty?
     end
 
 
     private
 
-    def rdf_node_from(node)
-      if node.nil?
-        nil
-      else
-        # According to Redland docs,
-        # the node here becomes a part of the statement
-        # and must not be used by the caller!
-        if node.frozen?
-          raise RedlandError.new("The node is already bound to a statement and cannot be added.")
-        else
-          node.freeze.rdf_node
-        end
-      end
-    end
-
     def attributes_satisfy?
       !subject.nil? && (subject.resource? || subject.blank?) &&
         !predicate.nil? && predicate.resource? &&
         !object.nil?
     end
 
+    def binding_to_statement(node)
+      if node.frozen?
+        raise RedlandError.new("Cannot assign a bound node")
+      else
+        node.freeze
+        yield
+      end
+    end
   end
-
 end

data/lib/redlander/storage.rb

@@ -1,9 +1,9 @@
 module Redlander
-
-  module Storage
-
+  class Storage
     VALID_STORAGE_TYPES = [:memory, :hashes, :file, :uri, :tstore, :mysql, :sqlite, :postgresql]
 
+    attr_reader :rdf_storage
+
     # Creates a store of the given type
     #
     # Store types (:storage option) are:
@@ -31,49 +31,27 @@ module Redlander
     #
     # NOTE: When dealing with databases,
     # Redland (1.0.7) just crashes when the required tables aren't available!
-    def self.initialize_storage(options = {})
-      storage_type, storage_options = split_options(options)
-      storage_type ||= :memory
+    def initialize(options = {})
+      storage_type, storage_options = split_options(options.dup)
 
       unless VALID_STORAGE_TYPES.include?(storage_type)
         raise RedlandError.new("Unknown storage type: #{storage_type}")
       end
 
-      rdf_storage = Redland.librdf_new_storage(Redlander.rdf_world,
-                                           storage_type.to_s,
-                                           storage_options.delete(:name).to_s,
-                                           Redlander.to_rdf_options(storage_options))
-      raise RedlandError.new("Failed to initialize storage") unless rdf_storage
-      ObjectSpace.define_finalizer(rdf_storage, proc { Redland.librdf_free_storage(rdf_storage) })
-
-      rdf_storage
-    end
-
-    # Wrap changes to the given model in a transaction.
-    # If an exception is raised in the block, the transaction is rolled back.
-    # (Does not work for all storages, in which case the changes are instanteous).
-    def self.transaction(model, &block)
-      Redland.librdf_model_transaction_start(model.rdf_model).zero? || RedlandError.new("Failed to initialize a transaction")
-      block.call
-      Redland.librdf_model_transaction_commit(model.rdf_model).zero? || RedlandError.new("Failed to commit the transaction")
-    rescue
-      rollback(model)
-    end
-
-    # Rollback a latest transaction for the given model.
-    def self.rollback(model)
-      Redland.librdf_model_transaction_rollback(model.rdf_model).zero? || RedlandError.new("Failed to rollback the latest transaction")
+      @rdf_storage = Redland.librdf_new_storage(Redlander.rdf_world,
+                                                storage_type.to_s,
+                                                storage_options.delete(:name).to_s,
+                                                Redlander.to_rdf_options(storage_options))
+      raise RedlandError.new("Failed to initialize storage") if @rdf_storage.null?
+      ObjectSpace.define_finalizer(self, proc { Redland.librdf_free_storage(@rdf_storage) })
     end
 
 
     private
 
-    def self.split_options(options = {})
-      storage_options = options.dup
-      storage_type = storage_options.delete(:storage)
-      [storage_type, storage_options]
+    def split_options(options)
+      storage_type = options.delete(:storage) || :memory
+      [storage_type, options]
     end
-
   end
-
 end

data/lib/redlander/stream.rb

@@ -0,0 +1,57 @@
+module Redlander
+  class Stream
+    attr_reader :rdf_stream
+
+    # Convert something to an RDF stream.
+    # Source can be:
+    #   Parser - to parse content into a stream
+    #   Model - to convert a model to an RDF stream, or
+    #           if content (Statement) supplied,
+    #           produce a stream of statements from the given model,
+    #           matching the non-empty nodes of the given statement.
+    def initialize(source, content = nil, options = {})
+      @rdf_stream = case source
+                    when Model
+                      if content.is_a?(Statement)
+                        Redland.librdf_model_find_statements(source.rdf_model, content.rdf_statement)
+                      else
+                        Redland.librdf_model_as_stream(source.rdf_model)
+                      end
+                    when Parser
+                      base_uri = options[:base_uri] ? Uri.new(options[:base_uri]).rdf_uri : nil
+                      Redland.librdf_parser_parse_string_as_stream(source.rdf_parser, content, base_uri)
+                    else
+                      # TODO
+                      raise NotImplementedError.new
+                    end
+      raise RedlandError.new("Failed to create a new stream") if @rdf_stream.null?
+      ObjectSpace.define_finalizer(self, proc { Redland.librdf_free_stream(@rdf_stream) })
+    end
+
+    # End-of-stream?
+    def eos?
+      Redland.librdf_stream_end(@rdf_stream) != 0
+    end
+
+    # Move stream pointer forward
+    def succ
+      Redland.librdf_stream_next(@rdf_stream).zero?
+    end
+
+    # Current statement in the stream, or nil
+    def current
+      Statement.new(self) unless eos?
+    end
+
+    # Return all the remaining statements in the stream
+    # from the current position.
+    def tail
+      [].tap do |all|
+        while !eos?
+          all << current
+          succ
+        end
+      end
+    end
+  end
+end

data/lib/redlander/stream.rb~

@@ -0,0 +1,43 @@
+module Redlander
+  class Stream
+    attr_reader :rdf_stream
+
+    def initialize(source)
+      @rdf_stream = case source
+                    when Statement
+                      Redland.librdf_model_find_statements(source.model.rdf_model, source.rdf_statement)
+                    when Model
+                      Redland.librdf_model_as_stream(source.rdf_model)
+                    else
+                      # TODO
+                      raise NotImplementedError.new
+                    end
+      raise RedlandError.new("Failed to create a new stream") if @rdf_stream.null?
+      ObjectSpace.define_finalizer(self, proc { Redland.librdf_free_stream(@rdf_stream) })
+    end
+
+    # End-of-stream?
+    def eos?
+      Redland.librdf_stream_end(@rdf_stream) != 0
+    end
+
+    def succ
+      Redland.librdf_stream_next(@rdf_stream).zero?
+    end
+
+    def current
+      Statement.new(self)
+    end
+
+    # Return all the remaining statements in the stream
+    # from the current position.
+    def tail
+      [].tap do |all|
+        while !eos?
+          all << current
+          succ
+        end
+      end
+    end
+  end
+end