redlander 0.3.6 → 0.4.0

data/lib/redlander/parser_proxy.rb

@@ -1,22 +0,0 @@
-require 'redlander/stream'
-require 'redlander/stream_enumerator'
-
-module Redlander
-  class ParserProxy
-    include StreamEnumerator
-
-    def initialize(parser, content, options = {})
-      # TODO: consider a streaming content, as it may be large to fit in memory
-      @parser = parser
-      @content = content
-      @options = options
-    end
-
-
-    private
-
-    def reset_stream
-      @stream = Stream.new(@parser, @content, @options)
-    end
-  end
-end

data/lib/redlander/serializer.rb

@@ -1,85 +0,0 @@
-module Redlander
-  class Serializer
-    # Create a new serializer.
-    # Name can be either of [:rdfxml, :ntriples, :turtle, :json, :dot],
-    # or nil, which defaults to :rdfxml.
-    #
-    # TODO: Only a small subset of parsers is implemented,
-    # 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") if @rdf_serializer.null?
-      ObjectSpace.define_finalizer(self, proc { Redland.librdf_free_serializer(@rdf_serializer) })
-    end
-
-    # Serialize a model into a string.
-    #
-    # Options are:
-    #   :base_uri   base URI (String or URI)
-    def to_string(model, options = {})
-      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
-    # filename  -  the name of the file to serialize to
-    # model     -  model instance
-    #
-    # Options are:
-    #   :base_uri   base URI (String or URI)
-    #
-    # Returns true on success, or false.
-    def to_file(model, filename, options = {})
-      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)
-    end
-
-    def to_ntriples(options = {})
-      serializer = Serializer.new(:ntriples)
-      serializer.to_string(self, options)
-    end
-
-    def to_turtle(options = {})
-      serializer = Serializer.new(:turtle)
-      serializer.to_string(self, options)
-    end
-
-    def to_json(options = {})
-      serializer = Serializer.new(:json)
-      serializer.to_string(self, options)
-    end
-
-    def to_dot(options = {})
-      serializer = Serializer.new(:dot)
-      serializer.to_string(self, options)
-    end
-
-    # Serialize the model into a file.
-    #
-    # Options are:
-    #   :format   - output format [:rdfxml (default), :ntriples, :turtle, :json, :dot]
-    #   :base_uri - base URI
-    def to_file(filename, options = {})
-      serializer_options = options.dup
-      serializer = Serializer.new(serializer_options.delete(:format) || :rdfxml)
-      serializer.to_file(self, filename, serializer_options)
-    end
-  end
-end

data/lib/redlander/storage.rb

@@ -1,56 +0,0 @@
-module Redlander
-  class Storage
-    attr_reader :rdf_storage
-
-    # 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
-    #   :virtuoso
-    #   ... anything else that Redland can handle.
-    #
-    # Options are storage-specific.
-    # Read the documentation for the appropriate Redland Storage module.
-    #
-    #   :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 initialize(options = {})
-      storage_type, storage_options = split_options(options.dup)
-
-      @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_type}' storage") if @rdf_storage.null?
-      ObjectSpace.define_finalizer(self, proc { Redland.librdf_free_storage(@rdf_storage) })
-    end
-
-
-    private
-
-    def split_options(options)
-      storage_type = options.delete(:storage) || :memory
-      [storage_type, options]
-    end
-  end
-end

data/lib/redlander/stream.rb

@@ -1,57 +0,0 @@
-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_enumerator.rb

@@ -1,17 +0,0 @@
-module Redlander
-  module StreamEnumerator
-    include Enumerable
-
-    def each
-      if block_given?
-        reset_stream
-        while !@stream.eos?
-          yield @stream.current
-          @stream.succ
-        end
-      else
-        raise ::LocalJumpError.new("no block given")
-      end
-    end
-  end
-end

data/spec/redlander/model_spec.rb

@@ -1,255 +0,0 @@
-require "spec_helper"
-
-describe Model do
-
-  before { @model = Model.new }
-
-  describe "statements" do
-
-    it { @model.statements.should be_an_instance_of(ModelProxy) }
-
-    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 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 {
-        @model.statements.add(statement)
-      }.should change(@model.statements, :size).by(1)
-      @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.all.should eql([statement])
-    end
-
-    it "should be found with a block" do
-      statements = []
-      statement = @model.statements.create(statement_attributes)
-      lambda {
-        @model.statements.each 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).each 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").each 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 {
-        @model.statements.delete(statement)
-      }.should change(@model.statements, :size).by(-1)
-      @model.statements.should_not include(statement)
-    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
-      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
-
-    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
-
-  describe "transactions" do
-    before do
-      Redland.stub(:librdf_model_transaction_start => 0,
-                   :librdf_model_transaction_commit => 0,
-                   :librdf_model_transaction_rollback => 0)
-    end
-
-    context "when start fails" do
-      before { Redland.stub(:librdf_model_transaction_start => -1) }
-
-      it "should raise RedlandError" do
-        lambda {
-          @model.transaction { true }
-        }.should raise_exception RedlandError
-      end
-    end
-
-    context "when commit fails" do
-      before { Redland.stub(:librdf_model_transaction_commit => -1) }
-
-      it "should raise RedlandError" do
-        lambda {
-          @model.transaction { true }
-        }.should raise_exception RedlandError
-      end
-    end
-
-    context "when rollback fails" do
-      before { Redland.stub(:librdf_model_transaction_rollback => -1) }
-
-      it "should raise RedlandError" do
-        lambda {
-          @model.rollback
-        }.should raise_exception RedlandError
-      end
-    end
-  end
-
-end