redlander 0.2.1

data/lib/redlander/statement.rb

@@ -0,0 +1,153 @@
+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
+                         Redland.librdf_new_statement_from_nodes(Redlander.rdf_world, s, p, o)
+                       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) })
+    end
+
+    def subject
+      rdf_node = Redland.librdf_statement_get_subject(@rdf_statement)
+      rdf_node && Node.new(rdf_node)
+    end
+
+    def predicate
+      rdf_node = Redland.librdf_statement_get_predicate(@rdf_statement)
+      rdf_node && Node.new(rdf_node)
+    end
+
+    def object
+      rdf_node = Redland.librdf_statement_get_object(@rdf_statement)
+      rdf_node && Node.new(rdf_node)
+    end
+
+    # set the subject of the statement
+    def subject=(node)
+      Redland.librdf_statement_set_subject(@rdf_statement, rdf_node_from(node))
+    end
+
+    # set the predicate of the statement
+    def predicate=(node)
+      Redland.librdf_statement_set_predicate(@rdf_statement, rdf_node_from(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
+    end
+
+    def eql?(other_statement)
+      model == other_statement.model &&
+        subject == other_statement.subject &&
+        predicate == other_statement.predicate &&
+        object == other_statement.object
+    end
+    alias_method :==, :eql?
+
+    def hash
+      self.class.hash + to_s.hash
+    end
+
+    def to_s
+      Redland.librdf_statement_to_string(@rdf_statement)
+    end
+
+    # 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
+    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
+
+  end
+
+end

data/lib/redlander/statement_iterator.rb

@@ -0,0 +1,37 @@
+module Redlander
+
+  # Wrapper for a librdf_stream object.
+  module StatementIterator
+
+    include Enumerable
+
+    # Iterate over statements in the stream.
+    def each
+      # TODO: The options specify matching criteria: subj, pred, obj;
+      #   if an option is not specified, it matches any value,
+      #   so with no options given, all statements will be returned.
+      if block_given?
+        while Redland.librdf_stream_end(@rdf_stream).zero?
+          yield current
+          Redland.librdf_stream_next(@rdf_stream).zero?
+        end
+      else
+        raise ::LocalJumpError.new("no block given")
+      end
+    end
+
+
+    private
+
+    # Get the current Statement in the stream.
+    def current
+      rdf_statement = Redland.librdf_stream_get_object(@rdf_stream)
+      statement = Statement.new(rdf_statement)
+      # not using Statement#model= in order to avoid re-adding the statement to the model
+      statement.instance_variable_set(:@model, @model)
+      statement
+    end
+
+  end
+
+end

data/lib/redlander/storage.rb

@@ -0,0 +1,79 @@
+module Redlander
+
+  module Storage
+
+    VALID_STORAGE_TYPES = [:memory, :hashes, :file, :uri, :tstore, :mysql, :sqlite, :postgresql]
+
+    # Creates a store of the given type
+    #
+    # Store types (:storage option) are:
+    #   :memory
+    #   :hashes
+    #   :file       - memory model initialized from RDF/XML file
+    #   :uri        - read-only memory model with URI provided in 'name' arg
+    #   :mysql
+    #   :sqlite
+    #   :postgresql
+    #   :tstore
+    # Options are:
+    #   :name       - ?
+    #   :host       - database host name (for store types: :postgres, :mysql, :tstore)
+    #   :port       - database host port (for store types: :postgres, :mysql, :tstore)
+    #   :database   - database name (for store types: :postgres, :mysql, :tstore)
+    #   :user       - database user name (for store types: :postgres, :mysql, :tstore)
+    #   :password   - database user password (for store types: :postgres, :mysql, :tstore)
+    #   :hash_type  - hash type (for store types: :bdb)
+    #                 can be either 'memory' or 'bdb'
+    #   :new        - force creation of a new store
+    #   :dir        - directory path (for store types: :hashes)
+    #   :contexts   - support contexts (for store types: :hashes, :memory)
+    #   :write      - allow writing data to the store (for store types: :hashes)
+    #
+    # 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
+
+      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")
+    end
+
+
+    private
+
+    def self.split_options(options = {})
+      storage_options = options.dup
+      storage_type = storage_options.delete(:storage)
+      [storage_type, storage_options]
+    end
+
+  end
+
+end

data/lib/redlander/version.rb

@@ -0,0 +1,3 @@
+module Redlander
+  VERSION = "0.2.1"
+end

data/spec/redlander/model_spec.rb

@@ -0,0 +1,239 @@
+require "spec_helper"
+
+describe Model do
+
+  it "should be created with default options" do
+    lambda { Model.new }.should_not raise_exception
+  end
+
+  describe "statements" do
+
+    before :each do
+      @model = Model.new
+    end
+
+    it do
+      @model.statements.should be_an_instance_of(ModelProxy)
+    end
+
+    it "should be created in the model" do
+      lambda {
+        @model.statements.create(statement_attributes)
+      }.should change(@model.statements, :size).by(1)
+    end
+
+    it "should be bound to the model" do
+      statement = @model.statements.create(statement_attributes)
+      statement.model.should be(@model)
+    end
+
+    it "should be iterated over" do
+      statement = @model.statements.create(statement_attributes)
+      statements = []
+      lambda {
+        @model.statements.each do |s|
+          statements << s
+        end
+      }.should change(statements, :size).by(1)
+      statements.first.should eql(statement)
+    end
+
+    it "should be added to the model" do
+      statement = Statement.new(statement_attributes)
+      lambda {
+        lambda {
+          @model.statements.add(statement)
+        }.should change(@model.statements, :size).by(1)
+      }.should change(statement, :model).from(nil).to(@model)
+      @model.statements.should include(statement)
+    end
+
+    it "should be found without a block" do
+      statement = @model.statements.create(statement_attributes)
+      @model.statements.find(:first).should eql(statement)
+      @model.statements.first.should eql(statement)
+      @model.statements.find(:all).should eql([statement])
+      @model.statements.all.should eql([statement])
+    end
+
+    it "should be found with a block" do
+      statements = []
+      statement = @model.statements.create(statement_attributes)
+      lambda {
+        @model.statements.find(:all) do |st|
+          statements << st
+        end
+      }.should change(statements, :size).by(1)
+      statements.first.should eql(statement)
+    end
+
+    it "should be found by an attribute" do
+      statements = []
+      statement = @model.statements.create(statement_attributes)
+      lambda {
+        @model.statements.find(:all, :object => statement.object) do |st|
+          statements << st
+        end
+      }.should change(statements, :size).by(1)
+      statements.first.should eql(statement)
+    end
+
+    it "should not be found with a block" do
+      statements = []
+      statement = @model.statements.create(statement_attributes)
+      lambda {
+        @model.statements.find(:all, :object => "another object") do |st|
+          statements << st
+        end
+      }.should_not change(statements, :size)
+    end
+
+    it "should be removed from the model" do
+      statement = @model.statements.create(statement_attributes)
+      lambda {
+        statement.destroy
+      }.should change(@model.statements, :size).by(-1)
+      @model.statements.should_not include(statement)
+      statement.model.should be_nil
+    end
+
+
+    private
+
+    def statement_attributes
+      s = URI.parse('http://example.com/concepts#subject')
+      p = URI.parse('http://example.com/concepts#label')
+      o = "subject!"
+      {
+        :subject => s,
+        :predicate => p,
+        :object => o
+      }
+    end
+
+  end
+
+  describe "serialization" do
+
+    before :each do
+      @model = Model.new
+      s = URI.parse("http://example.com/concepts#two-dimensional_seismic_imaging")
+      p = URI.parse("http://www.w3.org/2000/01/rdf-schema#label")
+      o = "2-D seismic imaging@en"
+      @model.statements.create(:subject => s, :predicate => p, :object => o)
+    end
+
+    it "should produce RDF/XML content" do
+      content = @model.to_rdfxml
+      content.should be_an_instance_of(String)
+      content.should include('2-D seismic imaging')
+    end
+
+    it "should produce N-Triples content" do
+      content = @model.to_ntriples
+      content.should be_an_instance_of(String)
+      content.should include('2-D seismic imaging@en')
+    end
+
+    it "should produce Turtle content" do
+      content = @model.to_turtle
+      content.should be_an_instance_of(String)
+      content.should include('2-D seismic imaging@en')
+    end
+
+    it "should produce JSON content" do
+      content = @model.to_json
+      content.should be_an_instance_of(String)
+      content.should include('2-D seismic imaging@en')
+    end
+
+    it "should produce DOT content" do
+      content = @model.to_dot
+      content.should be_an_instance_of(String)
+      content.should include('2-D seismic imaging@en')
+    end
+
+    describe "file source" do
+
+      before :each do
+        content = '<?xml version="1.0" encoding="utf-8"?><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"><rdf:Description rdf:about="http://example.com/concepts#two-dimensional_seismic_imaging"><ns0:label xmlns:ns0="http://www.w3.org/2000/01/rdf-schema#" xml:lang="en">2-D seismic imaging</ns0:label></rdf:Description></rdf:RDF>'
+        reference_model = Model.new
+        reference_model.from_rdfxml(content, :base_uri => 'http://example.com/concepts')
+        reference_model.to_file(filename)
+      end
+
+      after :each do
+        cleanup
+      end
+
+      it "should be loaded from a file" do
+        lambda {
+          @model.from_file(filename, :base_uri => 'http://example.com/concepts')
+        }.should change(@model.statements, :size).by(1)
+      end
+
+    end
+
+    describe "file destination" do
+
+      before :each do
+        cleanup
+      end
+
+      after :each do
+        cleanup
+      end
+
+      it "should produce a file" do
+        @model.to_file(filename)
+        File.should be_exists(filename)
+        File.size(filename).should_not be_zero
+      end
+
+    end
+
+    private
+
+    def cleanup
+      File.delete(filename) if File.exists?(filename)
+    end
+
+    def filename
+      "test_model.rdf"
+    end
+
+  end
+
+  describe "deserialization" do
+
+    before :each do
+      @model = Model.new
+    end
+
+    it "should be successful for RDF/XML data" do
+      content = '<?xml version="1.0" encoding="utf-8"?><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"><rdf:Description rdf:about="http://example.com/concepts#two-dimensional_seismic_imaging"><ns0:label xmlns:ns0="http://www.w3.org/2000/01/rdf-schema#" xml:lang="en">2-D seismic imaging</ns0:label></rdf:Description></rdf:RDF>'
+      lambda {
+        @model.from_rdfxml(content, :base_uri => 'http://example.com/concepts')
+      }.should change(@model.statements, :size).by(1)
+    end
+
+    it "should be successful for N-Triples data" do
+      content = '<http://example.org/ns/a2> <http://example.org/ns/b2> <http://example.org/ns/c2> .'
+      lambda {
+        @model.from_ntriples(content)
+      }.should change(@model.statements, :size).by(1)
+    end
+
+    it "should be successful for Turtle data" do
+      content = '# this is a complete turtle document
+@prefix foo: <http://example.org/ns#> .
+@prefix : <http://other.example.org/ns#> .
+foo:bar foo: : .'
+      lambda {
+        @model.from_turtle(content, :base_uri => 'http://example.com/concepts')
+      }.should change(@model.statements, :size).by(1)
+    end
+
+  end
+
+end