rdf-raptor 0.0.1 → 0.1.0

data/README

@@ -12,25 +12,68 @@ Examples
 
     require 'rdf/raptor'
 
-### Parsing an RDF/XML file
+### Ensuring Raptor is installed and obtaining the version number
 
-    RDF::Reader.open('http://datagraph.org/jhacker/foaf.rdf') do |reader|
+    RDF::Raptor.available?         #=> true
+    RDF::Raptor.version            #=> "1.4.21"
+
+### Parsing RDF statements from an RDF/XML file
+
+    RDF::Reader.open("http://datagraph.org/jhacker/foaf.rdf") do |reader|
       reader.each_statement do |statement|
         puts statement.inspect
       end
     end
 
-### Parsing a Turtle file
+### Parsing RDF statements from a Turtle file
 
-    RDF::Reader.open('http://datagraph.org/jhacker/foaf.ttl') do |reader|
+    RDF::Reader.open("http://datagraph.org/jhacker/foaf.ttl") do |reader|
       reader.each_statement do |statement|
         puts statement.inspect
       end
     end
 
+### Serializing RDF statements into an RDF/XML file
+
+    data = RDF::Repository.load("http://datagraph.org/jhacker/foaf.nt")
+    
+    RDF::Writer.open("output.rdf") do |writer|
+      data.each_statement do |statement|
+        writer << statement
+      end
+    end
+
+### Serializing RDF statements into a Turtle file
+
+    data = RDF::Repository.load("http://datagraph.org/jhacker/foaf.nt")
+    
+    RDF::Writer.open("output.ttl") do |writer|
+      data.each_statement do |statement|
+        writer << statement
+      end
+    end
+
+### Obtaining the RDF/XML format specification class
+
+    RDF::Format.for(:rdfxml)       #=> RDF::Raptor::RDFXML::Format
+    RDF::Format.for("input.rdf")
+    RDF::Format.for(:file_name      => "input.rdf")
+    RDF::Format.for(:file_extension => "rdf")
+    RDF::Format.for(:content_type   => "application/rdf+xml")
+
+### Obtaining the Turtle format specification class
+
+    RDF::Format.for(:turtle)       #=> RDF::Raptor::Turtle::Format
+    RDF::Format.for("input.ttl")
+    RDF::Format.for(:file_name      => "input.ttl")
+    RDF::Format.for(:file_extension => "ttl")
+    RDF::Format.for(:content_type   => "text/turtle")
+
 Documentation
 -------------
 
+<http://rdf.rubyforge.org/raptor/>
+
 * {RDF::Raptor}
   * {RDF::Raptor::RDFXML}
   * {RDF::Raptor::Turtle}
@@ -39,7 +82,8 @@ Dependencies
 ------------
 
 * [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.1.3)
-* [Raptor](http://librdf.org/raptor/) (>= 1.4.21)
+* [Raptor](http://librdf.org/raptor/) (>= 1.4.21),
+  specifically the `rapper` binary
 
 Installation
 ------------

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.1.0

data/lib/rdf/raptor/rdfxml.rb

@@ -2,10 +2,35 @@ module RDF::Raptor
   ##
   # RDF/XML support.
   #
+  # @example Requiring the `RDF::Raptor` module
+  #   require 'rdf/raptor'
+  #
+  # @example Parsing RDF statements from an RDF/XML file
+  #   RDF::Reader.open("input.rdf") do |reader|
+  #     reader.each_statement do |statement|
+  #       puts statement.inspect
+  #     end
+  #   end
+  #
+  # @example Serializing RDF statements into an RDF/XML file
+  #   RDF::Writer.open("output.rdf") do |writer|
+  #     graph.each_statement do |statement|
+  #       writer << statement
+  #     end
+  #   end
+  #
   # @see http://www.w3.org/TR/REC-rdf-syntax/
   module RDFXML
     ##
     # RDF/XML format specification.
+    #
+    # @example Obtaining an RDF/XML format class
+    #   RDF::Format.for(:rdfxml)       #=> RDF::Raptor::RDFXML::Format
+    #   RDF::Format.for("input.rdf")
+    #   RDF::Format.for(:file_name      => "input.rdf")
+    #   RDF::Format.for(:file_extension => "rdf")
+    #   RDF::Format.for(:content_type   => "application/rdf+xml")
+    #
     class Format < RDF::Raptor::Format
       content_type     'application/rdf+xml', :extension => :rdf
       content_encoding 'utf-8'
@@ -17,12 +42,42 @@ module RDF::Raptor
 
     ##
     # RDF/XML parser.
+    #
+    # @example Obtaining an RDF/XML reader class
+    #   RDF::Reader.for(:rdfxml)       #=> RDF::Raptor::RDFXML::Reader
+    #   RDF::Reader.for("input.rdf")
+    #   RDF::Reader.for(:file_name      => "input.rdf")
+    #   RDF::Reader.for(:file_extension => "rdf")
+    #   RDF::Reader.for(:content_type   => "application/rdf+xml")
+    #
+    # @example Parsing RDF statements from an RDF/XML file
+    #   RDF::Reader.open("input.rdf") do |reader|
+    #     reader.each_statement do |statement|
+    #       puts statement.inspect
+    #     end
+    #   end
+    #
     class Reader < RDF::Raptor::Reader
       format RDF::Raptor::RDFXML::Format
     end
 
     ##
     # RDF/XML serializer.
+    #
+    # @example Obtaining an RDF/XML writer class
+    #   RDF::Writer.for(:rdfxml)       #=> RDF::Raptor::RDFXML::Writer
+    #   RDF::Writer.for("output.rdf")
+    #   RDF::Writer.for(:file_name      => "output.rdf")
+    #   RDF::Writer.for(:file_extension => "rdf")
+    #   RDF::Writer.for(:content_type   => "application/rdf+xml")
+    #
+    # @example Serializing RDF statements into an RDF/XML file
+    #   RDF::Writer.open("output.rdf") do |writer|
+    #     graph.each_statement do |statement|
+    #       writer << statement
+    #     end
+    #   end
+    #
     class Writer < RDF::Raptor::Writer
       format RDF::Raptor::RDFXML::Format
     end

data/lib/rdf/raptor/reader.rb

@@ -3,7 +3,13 @@ module RDF::Raptor
   # Reader base class.
   class Reader < RDF::Reader
     ##
+    # @param  [IO, File, RDF::URI, String] input
+    # @param  [Hash{Symbol => Object}]     options
+    # @yield  [reader]
+    # @yieldparam [RDF::Reader] reader
     def initialize(input = $stdin, options = {}, &block)
+      raise RDF::ReaderError.new("`rapper` binary not found") unless RDF::Raptor.available?
+
       format = self.class.format.rapper_format
       case input
         when RDF::URI, %r(^(file|http|https|ftp)://)
@@ -21,6 +27,8 @@ module RDF::Raptor
       @reader = RDF::NTriples::Reader.new(@rapper, options, &block)
     end
 
+    protected
+
     ##
     # @return [Array]
     def read_triple

data/lib/rdf/raptor/turtle.rb

@@ -2,10 +2,35 @@ module RDF::Raptor
   ##
   # Turtle support.
   #
+  # @example Requiring the `RDF::Raptor` module
+  #   require 'rdf/raptor'
+  #
+  # @example Parsing RDF statements from a Turtle file
+  #   RDF::Reader.open("input.ttl") do |reader|
+  #     reader.each_statement do |statement|
+  #       puts statement.inspect
+  #     end
+  #   end
+  #
+  # @example Serializing RDF statements into a Turtle file
+  #   RDF::Writer.open("output.ttl") do |writer|
+  #     graph.each_statement do |statement|
+  #       writer << statement
+  #     end
+  #   end
+  #
   # @see http://www.w3.org/TeamSubmission/turtle/
   module Turtle
     ##
     # Turtle format specification.
+    #
+    # @example Obtaining a Turtle format class
+    #   RDF::Format.for(:turtle)       #=> RDF::Raptor::Turtle::Format
+    #   RDF::Format.for("input.ttl")
+    #   RDF::Format.for(:file_name      => "input.ttl")
+    #   RDF::Format.for(:file_extension => "ttl")
+    #   RDF::Format.for(:content_type   => "text/turtle")
+    #
     class Format < RDF::Raptor::Format
       content_type     'text/turtle', :extension => :ttl
       content_encoding 'utf-8'
@@ -17,12 +42,42 @@ module RDF::Raptor
 
     ##
     # Turtle parser.
+    #
+    # @example Obtaining a Turtle reader class
+    #   RDF::Reader.for(:turtle)       #=> RDF::Raptor::Turtle::Reader
+    #   RDF::Reader.for("input.ttl")
+    #   RDF::Reader.for(:file_name      => "input.ttl")
+    #   RDF::Reader.for(:file_extension => "ttl")
+    #   RDF::Reader.for(:content_type   => "text/turtle")
+    #
+    # @example Parsing RDF statements from a Turtle file
+    #   RDF::Reader.open("input.ttl") do |reader|
+    #     reader.each_statement do |statement|
+    #       puts statement.inspect
+    #     end
+    #   end
+    #
     class Reader < RDF::Raptor::Reader
       format RDF::Raptor::Turtle::Format
     end
 
     ##
     # Turtle serializer.
+    #
+    # @example Obtaining a Turtle writer class
+    #   RDF::Writer.for(:turtle)       #=> RDF::Raptor::Turtle::Writer
+    #   RDF::Writer.for("output.ttl")
+    #   RDF::Writer.for(:file_name      => "output.ttl")
+    #   RDF::Writer.for(:file_extension => "ttl")
+    #   RDF::Writer.for(:content_type   => "text/turtle")
+    #
+    # @example Serializing RDF statements into a Turtle file
+    #   RDF::Writer.open("output.ttl") do |writer|
+    #     graph.each_statement do |statement|
+    #       writer << statement
+    #     end
+    #   end
+    #
     class Writer < RDF::Raptor::Writer
       format RDF::Raptor::Turtle::Format
     end

data/lib/rdf/raptor/version.rb

@@ -1,8 +1,8 @@
 module RDF; module Raptor
   module VERSION
     MAJOR = 0
-    MINOR = 0
-    TINY  = 1
+    MINOR = 1
+    TINY  = 0
     EXTRA = nil
 
     STRING = [MAJOR, MINOR, TINY].join('.')

data/lib/rdf/raptor/writer.rb

@@ -2,6 +2,68 @@ module RDF::Raptor
   ##
   # Writer base class.
   class Writer < RDF::Writer
-    # TODO
+    ##
+    # @param  [IO, File]               output
+    # @param  [Hash{Symbol => Object}] options
+    # @yield  [writer]
+    # @yieldparam [RDF::Writer] writer
+    def initialize(output = $stdout, options = {}, &block)
+      raise RDF::WriterError.new("`rapper` binary not found") unless RDF::Raptor.available?
+
+      format = self.class.format.rapper_format
+      case output
+        when File, IO
+          @command = "rapper -q -i ntriples -o #{format} file:///dev/stdin"
+          @command << " #{options[:base_uri]}" if options.has_key?(:base_uri)
+          @rapper  = IO.popen(@command, 'rb+')
+        else
+          raise ArgumentError.new("unsupported output type: #{output.inspect}")
+      end
+      @writer = RDF::NTriples::Writer.new(@rapper, options)
+      super(output, options, &block)
+    end
+
+    protected
+
+    ##
+    # @return [void]
+    def write_prologue
+      super
+    end
+
+    ##
+    # @param  [RDF::Resource] subject
+    # @param  [RDF::URI]      predicate
+    # @param  [RDF::Value]    object
+    # @return [void]
+    def write_triple(subject, predicate, object)
+      @writer.write_triple(subject, predicate, object)
+    end
+
+    ##
+    # @return [void]
+    def write_epilogue
+      @rapper.close_write
+      begin
+        chunk_size = @options[:chunk_size] || 4096 # bytes
+        loop do
+          @output.write(@rapper.readpartial(chunk_size))
+        end
+      rescue EOFError => e
+        # we're all done
+      end
+    end
+
+    ##
+    # @todo Remove this once RDF.rb 0.1.4 is released.
+    # @private
+    def self.format(klass = nil)
+      if klass.nil?
+        Format.each do |format|
+          return format if format.writer == self
+        end
+        return nil # not found
+      end
+    end
   end
 end

data/lib/rdf/raptor.rb

@@ -4,9 +4,34 @@ module RDF
   ##
   # **`RDF::Raptor`** is a Raptor RDF Parser wrapper for RDF.rb.
   #
+  # * {RDF::Raptor::RDFXML} provides support for the standard
+  #   machine-readable RDF/XML format.
+  # * {RDF::Raptor::Turtle} provides support for the popular
+  #   human-readable Turtle format.
+  #
   # @example Requiring the `RDF::Raptor` module
   #   require 'rdf/raptor'
   #
+  # @example Checking whether Raptor is installed
+  #   RDF::Raptor.available?         #=> true
+  #
+  # @example Obtaining the Raptor version number
+  #   RDF::Raptor.version            #=> "1.4.21"
+  #
+  # @example Obtaining an RDF/XML format class
+  #   RDF::Format.for(:rdfxml)       #=> RDF::Raptor::RDFXML::Format
+  #   RDF::Format.for("input.rdf")
+  #   RDF::Format.for(:file_name      => "input.rdf")
+  #   RDF::Format.for(:file_extension => "rdf")
+  #   RDF::Format.for(:content_type   => "application/rdf+xml")
+  #
+  # @example Obtaining a Turtle format class
+  #   RDF::Format.for(:turtle)       #=> RDF::Raptor::Turtle::Format
+  #   RDF::Format.for("input.ttl")
+  #   RDF::Format.for(:file_name      => "input.ttl")
+  #   RDF::Format.for(:file_extension => "ttl")
+  #   RDF::Format.for(:content_type   => "text/turtle")
+  #
   # @see http://rdf.rubyforge.org/
   # @see http://librdf.org/raptor/
   #
@@ -18,5 +43,30 @@ module RDF
     require 'rdf/raptor/writer'
     require 'rdf/raptor/rdfxml'
     require 'rdf/raptor/turtle'
+
+    ##
+    # Returns `true` if the `rapper` binary is available.
+    #
+    # @example
+    #   RDF::Raptor.available?  #=> true
+    #
+    # @return [Boolean]
+    def self.available?
+      !!version
+    end
+
+    ##
+    # Returns the installed `rapper` version number, or `nil` if `rapper` is
+    # not available.
+    #
+    # @example
+    #   RDF::Raptor.version  #=> "1.4.21"
+    #
+    # @return [String]
+    def self.version
+      if `rapper --version 2>/dev/null` =~ /^(\d+)\.(\d+)\.(\d+)/
+        [$1, $2, $3].join('.')
+      end
+    end
   end # module Raptor
 end # module RDF

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 0
   - 1
-  version: 0.0.1
+  - 0
+  version: 0.1.0
 platform: ruby
 authors: 
 - Arto Bendiken
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-01 00:00:00 +02:00
+date: 2010-04-02 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency