rdf-raptor 0.4.0 → 0.4.1

data/README

@@ -1,5 +1,5 @@
-Raptor RDF Parser Wrapper for RDF.rb
-====================================
+Raptor RDF Parser Plugin for RDF.rb
+===================================
 
 This is an [RDF.rb][] plugin that adds support for parsing/serializing
 [RDF/XML][], [Turtle][] and [RDFa][] data using the [Raptor RDF Parser][Raptor]
@@ -11,8 +11,7 @@ library.
 Features
 --------
 
-* Requires the [Raptor][] library and utilities to be available.
-* Based on the [`rapper`][rapper] command-line utility bundled with Raptor.
+* Requires the [Raptor][] library and/or command-line utilities.
 * Parses and serializes RDF data from/into the RDF/XML or Turtle formats.
 * Extracts RDF statements from XHTML+RDFa documents.
 * Provides serialization format autodetection for RDF/XML, Turtle and RDFa.
@@ -103,16 +102,18 @@ Documentation
 <http://rdf.rubyforge.org/raptor/>
 
 * {RDF::Raptor}
-  * {RDF::Raptor::RDFXML}
+  * {RDF::Raptor::NTriples}
   * {RDF::Raptor::Turtle}
+  * {RDF::Raptor::RDFXML}
   * {RDF::Raptor::RDFa}
   * {RDF::Raptor::Graphviz}
 
 Dependencies
 ------------
 
-* [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.2.0)
-* [Raptor][] (>= 1.4.16), specifically the `rapper` binary
+* [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.3.0)
+* [FFI](http://rubygems.org/gems/ffi) (>= 1.0.0)
+* [Raptor][] (>= 1.4.16), the `libraptor` library or the `rapper` binary
 
 Installation
 ------------
@@ -124,8 +125,8 @@ To install the latest official release of the `RDF::Raptor` gem, do:
 
 To install the required [Raptor][] command-line tools themselves, look for a
 `raptor` or `raptor-utils` package in your platform's package management
-system. Here follow installation instructions for the Mac and the most
-common Linux and BSD distributions:
+system. For your convenience, here follow installation instructions for the
+Mac and the most common Linux and BSD distributions:
 
     % [sudo] port install raptor             # Mac OS X with MacPorts
     % [sudo] fink install raptor-bin         # Mac OS X with Fink
@@ -144,27 +145,32 @@ To get a local working copy of the development repository, do:
 
     % git clone git://github.com/bendiken/rdf-raptor.git
 
-Alternatively, you can download the latest development version as a tarball
-as follows:
+Alternatively, download the latest development version as a tarball as
+follows:
 
     % wget http://github.com/bendiken/rdf-raptor/tarball/master
 
-Author
-------
+Mailing List
+------------
+
+* <http://lists.w3.org/Archives/Public/public-rdf-ruby/>
+
+Authors
+-------
 
-* [Arto Bendiken](mailto:arto.bendiken@gmail.com) - <http://ar.to/>
-* [John Fieber](mailto:jrf@ursamaris.org) - <http://github.com/jfieber>
+* [Arto Bendiken](http://github.com/bendiken) - <http://ar.to/>
+* [John Fieber](http://github.com/jfieber) - <http://github.com/jfieber>
 
 Contributors
 ------------
 
-* [Ben Lavender](mailto:blavender@gmail.com) - <http://bhuga.net/>
+* [Ben Lavender](http://github.com/bhuga) - <http://bhuga.net/>
 
 License
 -------
 
-`RDF::Raptor` is free and unencumbered public domain software. For more
-information, see <http://unlicense.org/> or the accompanying UNLICENSE file.
+This is free and unencumbered public domain software. For more information,
+see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 
 [RDF.rb]:   http://rdf.rubyforge.org/
 [RDF/XML]:  http://www.w3.org/TR/REC-rdf-syntax/

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.4.1

data/etc/doap.ttl

@@ -9,7 +9,7 @@
   doap:name          "RDF::Raptor" ;
   doap:homepage      <http://rdf.rubyforge.org/raptor/> ;
   doap:license       <http://creativecommons.org/licenses/publicdomain/> ;
-  doap:shortdesc     "Raptor RDF Parser wrapper for RDF.rb."@en ;
+  doap:shortdesc     "Raptor RDF Parser plugin for RDF.rb."@en ;
   doap:description   "RDF.rb plugin for parsing/serializing RDF/XML, Turtle and RDFa data using the Raptor RDF Parser library."@en ;
   doap:created       "2010-03-23" ;
   doap:platform      "Ruby" ;

data/lib/rdf/raptor.rb

@@ -1,14 +1,15 @@
-require 'tempfile'
-require 'rdf'
+require 'rdf' # @see http://rubygems.org/gems/rdf
 
 module RDF
   ##
-  # **`RDF::Raptor`** is a Raptor RDF Parser wrapper for RDF.rb.
+  # **`RDF::Raptor`** is a Raptor RDF Parser plugin for RDF.rb.
   #
-  # * {RDF::Raptor::RDFXML} provides support for the standard
-  #   machine-readable RDF/XML format.
+  # * {RDF::Raptor::NTriples} provides support for the standard
+  #   machine-readable N-Triples format.
   # * {RDF::Raptor::Turtle} provides support for the popular
   #   human-readable Turtle format.
+  # * {RDF::Raptor::RDFXML} provides support for the standard
+  #   machine-readable RDF/XML format.
   # * {RDF::Raptor::RDFa} provides support for extracting
   #   RDF statements from XHTML+RDFa documents.
   # * {RDF::Raptor::Graphviz} provides support for serializing
@@ -26,12 +27,12 @@ module RDF
   # @example Obtaining the Raptor engine
   #   RDF::Raptor::ENGINE            #=> :ffi
   #
-  # @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 an N-Triples format class
+  #   RDF::Format.for(:ntriples)     #=> RDF::Raptor::NTriples::Format
+  #   RDF::Format.for("input.nt")
+  #   RDF::Format.for(:file_name      => "input.nt")
+  #   RDF::Format.for(:file_extension => "nt")
+  #   RDF::Format.for(:content_type   => "text/plain")
   #
   # @example Obtaining a Turtle format class
   #   RDF::Format.for(:turtle)       #=> RDF::Raptor::Turtle::Format
@@ -40,6 +41,13 @@ module RDF
   #   RDF::Format.for(:file_extension => "ttl")
   #   RDF::Format.for(:content_type   => "text/turtle")
   #
+  # @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 an RDFa format class
   #   RDF::Format.for(:rdfa)       #=> RDF::Raptor::RDFa::Format
   #   RDF::Format.for("input.html")
@@ -47,24 +55,27 @@ module RDF
   #   RDF::Format.for(:file_extension => "html")
   #   RDF::Format.for(:content_type   => "application/xhtml+xml")
   #
-  # {RDF::Raptor} includes an ffi implementation, which loads
-  # the libraptor library into the ruby process, and a cli
-  # implementation, which uses the rapper command line tool
-  # in a subprocess.  The ffi implementation is used unless
-  # libraptor library is not found, or the RDF_RAPTOR_ENGINE
-  # environment variable is set to 'cli'.
+  # {RDF::Raptor} includes an FFI implementation, which loads the
+  # `libraptor` library into the Ruby process, as well as a CLI
+  # implementation, which drives the `rapper` command-line tool in a
+  # sub-process.
+  #
+  # The FFI implementation is used by default unless the `libraptor` library
+  # cannot be found, or if the `RDF_RAPTOR_ENGINE` environment variable is
+  # explicitly set to `'cli'`.
   #
-  # If the libraptor library is in the standard library search
-  # path, and the rapper command is in the standard command
-  # search path, all should be well.  If either is in a
-  # non-standard location, set the RDF_RAPTOR_LIBPATH and/or
-  # RDF_RAPTOR_BINPATH appropriately before requiring rdf/raptor.
+  # If the `libraptor` library is in the standard library search path, and
+  # the `rapper` command is in the standard command search path, all should
+  # be well and work fine out of the box. However, if either is in a
+  # non-standard location, be sure to set the `RDF_RAPTOR_LIBPATH` and/or
+  # `RDF_RAPTOR_BINPATH` environment variables appropriately before
+  # requiring `rdf/raptor`.
   #
   # @see http://rdf.rubyforge.org/
   # @see http://librdf.org/raptor/
   # @see http://wiki.github.com/ffi/ffi/
   #
-  # @author [Arto Bendiken](http://ar.to/)
+  # @author [Arto Bendiken](http://github.com/bendiken)
   # @author [John Fieber](http://github.com/jfieber)
   module Raptor
     LIBRAPTOR = ENV['RDF_RAPTOR_LIBPATH'] || 'libraptor'  unless const_defined?(:LIBRAPTOR)
@@ -72,13 +83,13 @@ module RDF
 
     require 'rdf/raptor/version'
     begin
-      # Try ffi implementation
+      # Try FFI implementation
       raise LoadError if ENV['RDF_RAPTOR_ENGINE'] == 'cli' # override
       require 'rdf/raptor/ffi'
       include RDF::Raptor::FFI
       extend RDF::Raptor::FFI
     rescue LoadError => e
-      # cli fallback
+      # CLI fallback
       require 'rdf/raptor/cli'
       include RDF::Raptor::CLI
       extend RDF::Raptor::CLI
@@ -112,11 +123,12 @@ module RDF
           @rapper_format = format
         end
       end
-    end
+    end # Format
 
-    require 'rdf/raptor/rdfxml'
+    #require 'rdf/raptor/ntriples'
     require 'rdf/raptor/turtle'
+    require 'rdf/raptor/rdfxml'
     require 'rdf/raptor/rdfa'
     require 'rdf/raptor/graphviz'
-  end # module Raptor
-end # module RDF
+  end # Raptor
+end # RDF

data/lib/rdf/raptor/cli.rb

@@ -1,8 +1,9 @@
+require 'tempfile'
+
 module RDF::Raptor
   ##
   # A command-line interface to Raptor's `rapper` utility.
   module CLI
-
     ENGINE = :cli
 
     ##
@@ -18,18 +19,23 @@ module RDF::Raptor
         [$1, $2, $3].join('.')
       end
     end
+    module_function :version
 
     ##
-    # Reader implementation.
+    # CLI reader implementation.
     class Reader < RDF::Reader
       ##
+      # Initializes the CLI reader instance.
+      #
       # @param  [IO, File, RDF::URI, String] input
-      # @param  [Hash{Symbol => Object}]     options
-      # @option (options) [String, #to_s]    :base_uri ("file:///dev/stdin")
-      # @yield  [reader]
-      # @yieldparam [RDF::Reader] reader
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional options (see `RDF::Reader#initialize`)
+      # @option options [String, #to_s] :base_uri ("file:///dev/stdin")
+      # @yield  [reader] `self`
+      # @yieldparam  [RDF::Reader] reader
+      # @yieldreturn [void] ignored
       def initialize(input = $stdin, options = {}, &block)
-        raise RDF::ReaderError.new("`rapper` binary not found") unless RDF::Raptor.available?
+        raise RDF::ReaderError, "`rapper` binary not found" unless RDF::Raptor.available?
 
         format = self.class.format.rapper_format
         case input
@@ -37,16 +43,18 @@ module RDF::Raptor
             @command = "#{RAPPER} -q -i #{format} -o ntriples '#{input}'"
             @command << " '#{options[:base_uri]}'" if options.has_key?(:base_uri)
             @rapper  = IO.popen(@command, 'rb')
+
           when File, Tempfile
             @command = "#{RAPPER} -q -i #{format} -o ntriples '#{File.expand_path(input.path)}'"
             @command << " '#{options[:base_uri]}'" if options.has_key?(:base_uri)
             @rapper  = IO.popen(@command, 'rb')
+
           else # IO, String
             @command = "#{RAPPER} -q -i #{format} -o ntriples file:///dev/stdin"
             @command << " '#{options[:base_uri]}'" if options.has_key?(:base_uri)
             @rapper  = IO.popen(@command, 'rb+')
             pid = fork do
-              # process to feed rapper
+              # process to feed `rapper`
               begin
                 @rapper.close_read
                 if input.respond_to?(:read)
@@ -65,13 +73,23 @@ module RDF::Raptor
             Process.detach(pid)
             @rapper.close_write
         end
-        @reader = RDF::NTriples::Reader.new(@rapper, options, &block)
+
+        @options = options
+        @reader = RDF::NTriples::Reader.new(@rapper, @options).extend(Extensions)
+
+        if block_given?
+          case block.arity
+            when 0 then instance_eval(&block)
+            else block.call(self)
+          end
+        end
       end
 
-      protected
+    protected
 
       ##
-      # @return [Array]
+      # @return [Array(RDF::Resource, RDF::URI, RDF::Term)]
+      # @see    RDF::Reader#read_triple
       def read_triple
         raise EOFError if @rapper.closed?
         begin
@@ -83,18 +101,43 @@ module RDF::Raptor
         triple
       end
 
-    end
+      ##
+      # Extensions for `RDF::NTriples::Reader`.
+      module Extensions
+        NODEID = RDF::NTriples::Reader::NODEID
+        GENID  = /^genid\d+$/
+
+        ##
+        # Generates fresh random identifiers for Raptor's `_:genid[0-9]+`
+        # blank nodes, while preserving any user-specified blank node
+        # identifiers verbatim.
+        #
+        # @private
+        # @see RDF::NTriples::Reader#read_node
+        # @see https://github.com/bendiken/rdf-raptor/issues/#issue/9
+        def read_node
+          if node_id = match(NODEID)
+            @nodes ||= {}
+            @nodes[node_id] ||= RDF::Node.new(GENID === node_id ? nil : node_id)
+          end
+        end
+      end
+    end # Reader
 
     ##
-    # Writer implementation.
+    # CLI writer implementation.
     class Writer < RDF::Writer
       ##
+      # Initializes the CLI writer instance.
+      #
       # @param  [IO, File]               output
       # @param  [Hash{Symbol => Object}] options
-      # @yield  [writer]
-      # @yieldparam [RDF::Writer] writer
+      #   any additional options (see `RDF::Writer#initialize`)
+      # @yield  [writer] `self`
+      # @yieldparam  [RDF::Writer] writer
+      # @yieldreturn [void]
       def initialize(output = $stdout, options = {}, &block)
-        raise RDF::WriterError.new("`rapper` binary not found") unless RDF::Raptor.available?
+        raise RDF::WriterError, "`rapper` binary not found" unless RDF::Raptor.available?
 
         format = self.class.format.rapper_format
         case output
@@ -103,16 +146,17 @@ module RDF::Raptor
             @command << " '#{options[:base_uri]}'" if options.has_key?(:base_uri)
             @rapper  = IO.popen(@command, 'rb+')
           else
-            raise ArgumentError.new("unsupported output type: #{output.inspect}")
+            raise ArgumentError, "unsupported output type: #{output.inspect}"
         end
         @writer = RDF::NTriples::Writer.new(@rapper, options)
         super(output, options, &block)
       end
 
-      protected
+    protected
 
       ##
       # @return [void]
+      # @see    RDF::Writer#write_prologue
       def write_prologue
         super
       end
@@ -120,8 +164,9 @@ module RDF::Raptor
       ##
       # @param  [RDF::Resource] subject
       # @param  [RDF::URI]      predicate
-      # @param  [RDF::Value]    object
+      # @param  [RDF::Term]     object
       # @return [void]
+      # @see    RDF::Writer#write_triple
       def write_triple(subject, predicate, object)
         output_transit(false)
         @writer.write_triple(subject, predicate, object)
@@ -130,20 +175,23 @@ module RDF::Raptor
 
       ##
       # @return [void]
+      # @see    RDF::Writer#write_epilogue
       def write_epilogue
         @rapper.close_write unless @rapper.closed?
         output_transit(true)
       end
 
       ##
-      # Feed any available rapper output to the destination.
+      # Feeds any available `rapper` output to the destination.
+      #
+      # @param  [Boolean] may_block
       # @return [void]
-      def output_transit(block)
+      def output_transit(may_block)
         unless @rapper.closed?
           chunk_size = @options[:chunk_size] || 4096 # bytes
           begin
             loop do
-              @output.write(block ? @rapper.readpartial(chunk_size) : @rapper.read_nonblock(chunk_size))
+              @output.write(may_block ? @rapper.readpartial(chunk_size) : @rapper.read_nonblock(chunk_size))
             end
           rescue EOFError => e
             @rapper.close
@@ -152,7 +200,6 @@ module RDF::Raptor
           end
         end
       end
-
-    end
-  end
-end
+    end # Writer
+  end # CLI
+end # RDF::Raptor

data/lib/rdf/raptor/ffi.rb

@@ -1,4 +1,5 @@
-require 'ffi'
+require 'tempfile'
+require 'ffi' # @see http://rubygems.org/gems/ffi
 
 module RDF::Raptor
   ##
@@ -7,116 +8,150 @@ module RDF::Raptor
   # @see http://librdf.org/raptor/api/
   # @see http://librdf.org/raptor/libraptor.html
   module FFI
+    autoload :V1, 'rdf/raptor/ffi/v1'
 
     ENGINE = :ffi
 
     ##
-    # Returns the installed `rapper` version number, or `nil` if `rapper` is
-    # not available.
+    # Returns the installed `libraptor` version number, or `nil` if
+    # `libraptor` is not available.
     #
     # @example
     #   RDF::Raptor.version  #=> "1.4.21"
     #
-    # @return [String]
+    # @return [String] an "x.y.z" version string
     def version
-      [ V1_4.raptor_version_major,
-        V1_4.raptor_version_minor,
-        V1_4.raptor_version_release ].join('.')
+      [V1.raptor_version_major,
+       V1.raptor_version_minor,
+       V1.raptor_version_release].join('.').freeze
     end
+    module_function :version
 
     ##
-    # Reader implementation.
+    # FFI reader implementation.
     class Reader < RDF::Reader
       ##
+      # Initializes the FFI reader instance.
+      #
       # @param  [IO, File, RDF::URI, String] input
-      # @param  [Hash{Symbol => Object}]     options
-      # @option (options) [String, #to_s]    :base_uri ("file:///dev/stdin")
-      # @yield  [reader]
-      # @yieldparam [RDF::Reader] reader
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional options (see `RDF::Reader#initialize`)
+      # @option options [String, #to_s]  :base_uri ("file:///dev/stdin")
+      # @yield  [reader] `self`
+      # @yieldparam  [RDF::Reader] reader
+      # @yieldreturn [void] ignored
       def initialize(input = $stdin, options = {}, &block)
         @format = self.class.format.rapper_format
+        @parser = V1::Parser.new(@format)
+        @parser.error_handler   = ERROR_HANDLER
+        @parser.warning_handler = WARNING_HANDLER
         super
       end
 
       ERROR_HANDLER = Proc.new do |user_data, locator, message|
-        line = V1_4.raptor_locator_line(locator)
+        line = V1.raptor_locator_line(locator)
         raise RDF::ReaderError, line > -1 ? "Line #{line}: #{message}" : message
       end
 
       WARNING_HANDLER = Proc.new do |user_data, locator, message|
-        # line = V1_4.raptor_locator_line(locator)
+        # line = V1.raptor_locator_line(locator)
         # $stderr.puts line > -1 ? "Line #{line}: #{message}" : message
       end
 
+      ##
+      # The Raptor parser instance.
+      #
+      # @return [V1::Parser]
+      attr_reader :parser
 
       ##
       # @yield [statement]
-      # @yieldparam [RDF::Statement] statement
-      def each_statement(&block)
-        each_triple do |triple|
-          block.call(RDF::Statement.new(*triple))
+      # @yieldparam  [RDF::Statement] statement
+      # @yieldreturn [void] ignored
+      # @see   RDF::Reader#each_statement
+      def each_statement(options = {}, &block)
+        if block_given?
+          if options[:raw]
+            # this is up to an order of magnitude faster...
+            parse(@input) do |parser, statement|
+              block.call(V1::Statement.new(statement, self))
+            end
+          else
+            parse(@input) do |parser, statement|
+              block.call(V1::Statement.new(statement, self).to_rdf)
+            end
+          end
         end
+        enum_for(:each_statement, options)
       end
+      alias_method :each, :each_statement
 
       ##
       # @yield [triple]
-      # @yieldparam [Array(RDF::Resource, RDF::URI, RDF::Value)] triple
+      # @yieldparam  [Array(RDF::Resource, RDF::URI, RDF::Term)] triple
+      # @yieldreturn [void] ignored
+      # @see   RDF::Reader#each_triple
       def each_triple(&block)
-        statement_handler = Proc.new do |user_data, statement|
-          triple = V1_4::Statement.new(statement).to_triple
-          block.call(triple)
+        if block_given?
+          parse(@input) do |parser, statement|
+            block.call(V1::Statement.new(statement, self).to_triple)
+          end
         end
+        enum_for(:each_triple)
+      end
 
-        V1_4.with_parser(:name => @format) do |parser|
-          V1_4.raptor_set_error_handler(parser, nil, ERROR_HANDLER)
-          V1_4.raptor_set_warning_handler(parser, nil, WARNING_HANDLER)
-          V1_4.raptor_set_statement_handler(parser, nil, statement_handler)
-          case @input
-            when RDF::URI, %r(^(file|http|https|ftp)://)
-              begin
-                data_url = V1_4.raptor_new_uri(@input.to_s)
-                base_uri = @options[:base_uri].to_s.empty? ? nil : V1_4.raptor_new_uri(@options[:base_uri].to_s)
-                unless (result = V1_4.raptor_parse_uri(parser, data_url, base_uri)).zero?
-                  # TODO: error handling
-                end
-              ensure
-                V1_4.raptor_free_uri(base_uri) if base_uri
-                V1_4.raptor_free_uri(data_url) if data_url
-              end
-
-            when File, Tempfile
-              begin
-                data_url = V1_4.raptor_new_uri("file://#{File.expand_path(@input.path)}")
-                base_uri = @options[:base_uri].to_s.empty? ? nil : V1_4.raptor_new_uri(@options[:base_uri].to_s)
-                unless (result = V1_4.raptor_parse_file(parser, data_url, base_uri)).zero?
-                  # TODO: error handling
-                end
-              ensure
-                V1_4.raptor_free_uri(base_uri) if base_uri
-                V1_4.raptor_free_uri(data_url) if data_url
-              end
+      ##
+      # @private
+      # @param  [RDF::URI, File, Tempfile, IO, StringIO] input
+      #   the input stream
+      # @yield  [parser, statement]
+      #   each statement in the input stream
+      # @yieldparam  [FFI::Pointer] parser
+      # @yieldparam  [FFI::Pointer] statement
+      # @yieldreturn [void] ignored
+      # @return [void]
+      def parse(input, &block)
+        @parser.parse(input, @options, &block)
+      end
 
-            else # IO, String
-              base_uri = (@options[:base_uri] || 'file:///dev/stdin').to_s
-              unless (result = V1_4.raptor_start_parse(parser, base_uri)).zero?
-                # TODO: error handling
-              end
-              # TODO: read in chunks instead of everything in one go:
-              unless (result = V1_4.raptor_parse_chunk(parser, buffer = @input.read, buffer.size, 0)).zero?
-                # TODO: error handling
-              end
-              V1_4.raptor_parse_chunk(parser, nil, 0, 1) # EOF
-          end
-        end
+      GENID = /^genid\d+$/
 
+      ##
+      # @param  [String] uri_str
+      # @return [RDF::URI]
+      def create_uri(uri_str)
+        RDF::URI.intern(uri_str)
       end
 
-      alias_method :each, :each_statement
-    end
+      ##
+      # @param  [String] node_id
+      # @return [RDF::Node]
+      def create_node(node_id)
+        @nodes ||= {}
+        @nodes[node_id] ||= RDF::Node.new(GENID === node_id ? nil : node_id)
+      end
+    end # Reader
 
     ##
-    # Writer implementation.
+    # FFI writer implementation.
     class Writer < RDF::Writer
+      ##
+      # Initializes the FFI writer instance.
+      #
+      # @param  [IO, File] output
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional options (see `RDF::Writer#initialize`)
+      # @yield  [writer] `self`
+      # @yieldparam  [RDF::Writer] writer
+      # @yieldreturn [void] ignored
+      def initialize(output = $stdout, options = {}, &block)
+        @format = self.class.format.rapper_format
+        @serializer = V1::Serializer.new(@format)
+        @serializer.error_handler   = ERROR_HANDLER
+        @serializer.warning_handler = WARNING_HANDLER
+        @serializer.start_to(output, options)
+        super
+      end
 
       ERROR_HANDLER = Proc.new do |user_data, locator, message|
         raise RDF::WriterError, message
@@ -126,423 +161,37 @@ module RDF::Raptor
         # $stderr.puts "warning"
       end
 
-      def initialize(output = $stdout, options = {}, &block)
-        raise ArgumentError, "Block required" unless block_given?  # Can we work without this?
-        @format = self.class.format.rapper_format
-        begin
-          # make a serializer
-          @serializer = V1_4.raptor_new_serializer((@format || :rdfxml).to_s)
-          raise RDF::WriterError, "raptor_new_serializer failed" if @serializer.nil?
-          V1_4.raptor_serializer_set_error_handler(@serializer, nil, ERROR_HANDLER)
-          V1_4.raptor_serializer_set_warning_handler(@serializer, nil, WARNING_HANDLER)
-          base_uri = options[:base_uri].to_s.empty? ? nil : V1_4.raptor_new_uri(options[:base_uri].to_s)
-
-          # make an iostream
-          handler = V1_4::IOStreamHandler.new
-          handler.rubyio = output
-          raptor_iostream = V1_4.raptor_new_iostream_from_handler2(nil, handler)
-
-          # connect the two
-          unless V1_4.raptor_serialize_start_to_iostream(@serializer, base_uri, raptor_iostream).zero?
-            raise RDF::WriterError, "raptor_serialize_start_to_iostream failed"
-          end
-          super
-        ensure
-          V1_4.raptor_free_iostream(raptor_iostream) if raptor_iostream
-          V1_4.raptor_free_uri(base_uri) if base_uri
-          V1_4.raptor_free_serializer(@serializer) if @serializer
-        end
-      end
+      ##
+      # The Raptor serializer instance.
+      #
+      # @return [V1::Serializer]
+      attr_reader :serializer
 
       ##
       # @param  [RDF::Resource] subject
       # @param  [RDF::URI]      predicate
-      # @param  [RDF::Value]    object
+      # @param  [RDF::Term]     object
       # @return [void]
+      # @see    RDF::Writer#write_triple
       def write_triple(subject, predicate, object)
-        raptor_statement = V1_4::Statement.new
-        raptor_statement.subject = subject
-        raptor_statement.predicate = predicate
-        raptor_statement.object = object
-        begin
-          unless V1_4.raptor_serialize_statement(@serializer, raptor_statement.to_ptr).zero?
-            raise RDF::WriterError, "raptor_serialize_statement failed"
-          end
-        ensure
-          raptor_statement.release
-          raptor_statement = nil
-        end
+        @serializer.serialize_triple(subject, predicate, object)
       end
 
       ##
       # @return [void]
+      # @see    RDF::Writer#write_epilogue
       def write_epilogue
-        unless V1_4.raptor_serialize_end(@serializer).zero?
-          raise RDF::WriterError, "raptor_serialize_end failed"
-        end
+        @serializer.finish
         super
       end
-
-    end
-
+    end # Writer
 
     ##
-    # Helper methods for FFI modules.
-    module Base
-      def define_pointer(name)
-        self.class.send(:define_method, name) { :pointer }
-      end
-    end
-
-    ##
-    # A foreign-function interface (FFI) to `libraptor` 1.4.x.
-    #
-    # @see http://librdf.org/raptor/libraptor.html
-    module V1_4
-
-      ##
-      # @param  [Hash{Symbol => Object}] options
-      # @option (options) [String, #to_s] :name (:rdfxml)
-      # @yield  [parser]
-      # @yieldparam [FFI::Pointer] parser
-      # @return [void]
-      def self.with_parser(options = {}, &block)
-        begin
-          parser = raptor_new_parser((options[:name] || :rdfxml).to_s)
-          block.call(parser)
-        ensure
-          raptor_free_parser(parser) if parser
-        end
-      end
-
-
-      extend Base
+    # @private
+    module LibC
       extend ::FFI::Library
-      ffi_lib LIBRAPTOR
-
-      # TODO: Ideally this would be an enum, but the JRuby FFI (as of
-      # version 1.4.0) has problems with enums as part of structs:
-      #   `Unknown field type: #<FFI::Enum> (ArgumentError)`
-      RAPTOR_IDENTIFIER_TYPE_RESOURCE  = 1
-      RAPTOR_IDENTIFIER_TYPE_ANONYMOUS = 2
-      RAPTOR_IDENTIFIER_TYPE_LITERAL   = 5
-
-      # @see http://librdf.org/raptor/api/raptor-section-triples.html
-      class Statement < ::FFI::Struct
-        layout :subject, :pointer,
-               :subject_type, :int,
-               :predicate, :pointer,
-               :predicate_type, :int,
-               :object, :pointer,
-               :object_type, :int,
-               :object_literal_datatype, :pointer,
-               :object_literal_language, :pointer
-
-        def initialize(*args)
-          super
-          # Objects we need to keep a Ruby reference
-          # to so they don't get garbage collected out from under
-          # the C code we pass them to.
-          @mp = {}
-
-          # Raptor object references we we need to explicitly free
-          # when release is called
-          @raptor_uri_list = []
-        end
-
-        ##
-        # Release raptor memory associated with this struct.
-        # Use of the object after calling this will most likely
-        # cause a crash.  This is kind of ugly.
-        def release
-          if pointer.kind_of?(::FFI::MemoryPointer) && !pointer.null?
-            pointer.free
-          end
-          while uri = @raptor_uri_list.pop
-            V1_4.raptor_free_uri(uri) unless uri.nil? || uri.null?
-          end
-        end
-
-        ##
-        # @return [RDF::Resource]
-        def subject
-          @subject ||= case self[:subject_type]
-            when RAPTOR_IDENTIFIER_TYPE_RESOURCE
-              RDF::URI.intern(V1_4.raptor_uri_to_string(self[:subject]))
-            when RAPTOR_IDENTIFIER_TYPE_ANONYMOUS
-              RDF::Node.new(self[:subject].read_string)
-          end
-        end
-
-        ##
-        # Set the subject from an RDF::Resource
-        # @param  [RDF::Resource] value
-        def subject=(resource)
-          @subject = nil
-          case resource
-          when RDF::Node
-            self[:subject] = @mp[:subject] = ::FFI::MemoryPointer.from_string(resource.id.to_s)
-            self[:subject_type] = RAPTOR_IDENTIFIER_TYPE_ANONYMOUS
-          when RDF::URI
-            self[:subject] = @mp[:subject] = @raptor_uri_list.push(V1_4.raptor_new_uri(resource.to_s)).last
-            self[:subject_type] = RAPTOR_IDENTIFIER_TYPE_RESOURCE
-          else
-            raise ArgumentError, "subject must be of kind RDF::Node or RDF::URI"
-          end
-          @subject = resource
-        end
-
-        ##
-        # @return [String]
-        def subject_as_string
-          V1_4.raptor_statement_part_as_string(
-            self[:subject],
-            self[:subject_type],
-            nil, nil)
-        end
-
-        ##
-        # @return [RDF::URI]
-        def predicate
-          @predicate ||= case self[:predicate_type]
-            when RAPTOR_IDENTIFIER_TYPE_RESOURCE
-              RDF::URI.intern(V1_4.raptor_uri_to_string(self[:predicate]))
-          end
-        end
-
-        ##
-        # Set the predicate from an RDF::URI
-        # @param  [RDF::URI] value
-        def predicate=(uri)
-          @predicate = nil
-          raise ArgumentError, "predicate must be a kind of RDF::URI" unless uri.kind_of?(RDF::URI)
-          self[:predicate] = @raptor_uri_list.push(V1_4.raptor_new_uri(uri.to_s)).last
-          self[:predicate_type] = RAPTOR_IDENTIFIER_TYPE_RESOURCE
-          @predicate = uri
-        end
-
-        ##
-        # @return [String]
-        def predicate_as_string
-          V1_4.raptor_statement_part_as_string(
-            self[:predicate],
-            self[:predicate_type],
-            nil, nil)
-        end
-
-        ##
-        # @return [RDF::Value]
-        def object
-          @object ||= case self[:object_type]
-            when RAPTOR_IDENTIFIER_TYPE_RESOURCE
-              RDF::URI.intern(V1_4.raptor_uri_to_string(self[:object]))
-            when RAPTOR_IDENTIFIER_TYPE_ANONYMOUS
-              RDF::Node.new(self[:object].read_string)
-            when RAPTOR_IDENTIFIER_TYPE_LITERAL
-              case
-                when self[:object_literal_language] && !self[:object_literal_language].null?
-                  RDF::Literal.new(self[:object].read_string, :language => self[:object_literal_language].read_string)
-                when self[:object_literal_datatype] && !self[:object_literal_datatype].null?
-                  RDF::Literal.new(self[:object].read_string, :datatype => V1_4.raptor_uri_to_string(self[:object_literal_datatype]))
-                else
-                  RDF::Literal.new(self[:object].read_string)
-              end
-          end
-        end
-
-        ##
-        # Set the object from an RDF::Value.
-        # Value must be one of RDF::Resource or RDF::Literal.
-        # @param  [RDF::Value] value
-        def object=(value)
-          @object = nil
-          case value
-          when RDF::Node
-            self[:object] = @mp[:object] = ::FFI::MemoryPointer.from_string(value.id.to_s)
-            self[:object_type] = RAPTOR_IDENTIFIER_TYPE_ANONYMOUS
-          when RDF::URI
-            self[:object] = @mp[:object] = @raptor_uri_list.push(V1_4.raptor_new_uri(value.to_s)).last
-            self[:object_type] = RAPTOR_IDENTIFIER_TYPE_RESOURCE
-          when RDF::Literal
-            self[:object_type] = RAPTOR_IDENTIFIER_TYPE_LITERAL
-            self[:object] = @mp[:object] = ::FFI::MemoryPointer.from_string(value.value)
-            self[:object_literal_datatype] = if value.datatype
-              @raptor_uri_list.push(V1_4.raptor_new_uri(value.datatype.to_s)).last
-            else
-              nil
-            end
-            self[:object_literal_language] = @mp[:object_literal_language] = if value.language?
-              ::FFI::MemoryPointer.from_string(value.language.to_s)
-            else
-              nil
-            end
-          else
-            raise ArgumentError, "object must be of type RDF::Node, RDF::URI or RDF::Literal"
-          end
-          @object = value
-        end
-
-        ##
-        # @return [String]
-        def object_as_string
-          V1_4.raptor_statement_part_as_string(
-            self[:object],
-            self[:object_type],
-            self[:object_literal_datatype],
-            self[:object_literal_language])
-        end
-
-        ##
-        # @return [Array(RDF::Resource, RDF::URI, RDF::Value)]
-        def to_triple
-          [subject, predicate, object]
-        end
-
-        ##
-        # @return [Array(RDF::Resource, RDF::URI, RDF::Value, nil)]
-        def to_quad
-          [subject, predicate, object, nil]
-        end
-
-      end
-
-      # @see http://librdf.org/raptor/api/tutorial-initialising-finishing.html
-      attach_function :raptor_init, [], :void
-      attach_function :raptor_finish, [], :void
-
-      # @see http://librdf.org/raptor/api/raptor-section-locator.html
-      define_pointer  :raptor_locator
-      attach_function :raptor_locator_line, [raptor_locator], :int
-      attach_function :raptor_locator_column, [raptor_locator], :int
-      attach_function :raptor_locator_byte, [raptor_locator], :int
-
-      # @see http://librdf.org/raptor/api/raptor-section-general.html
-      attach_variable :raptor_version_major, :int
-      attach_variable :raptor_version_minor, :int
-      attach_variable :raptor_version_release, :int
-      attach_variable :raptor_version_decimal, :int
-      callback        :raptor_message_handler, [:pointer, raptor_locator, :string], :void
-
-      # @see http://librdf.org/raptor/api/raptor-section-uri.html
-      define_pointer  :raptor_uri
-      attach_function :raptor_new_uri, [:string], raptor_uri
-      attach_function :raptor_uri_as_string, [raptor_uri], :string
-      attach_function :raptor_uri_to_string, [raptor_uri], :string
-      attach_function :raptor_uri_print, [raptor_uri, :pointer], :void
-      attach_function :raptor_free_uri, [raptor_uri], :void
-
-      # @see http://librdf.org/raptor/api/raptor-section-triples.html
-      define_pointer  :raptor_identifier
-      define_pointer  :raptor_statement
-      attach_function :raptor_statement_compare, [raptor_statement, raptor_statement], :int
-      attach_function :raptor_print_statement, [raptor_statement, :pointer], :void
-      attach_function :raptor_print_statement_as_ntriples, [:pointer, :pointer], :void
-      attach_function :raptor_statement_part_as_string, [:pointer, :int, raptor_uri, :string], :string
-
-      # @see http://librdf.org/raptor/api/raptor-section-parser.html
-      callback :raptor_statement_handler, [:pointer, raptor_statement], :void
-      define_pointer  :raptor_parser
-      attach_function :raptor_new_parser, [:string], raptor_parser
-      attach_function :raptor_set_error_handler, [raptor_parser, :pointer, :raptor_message_handler], :void
-      attach_function :raptor_set_warning_handler, [raptor_parser, :pointer, :raptor_message_handler], :void
-      attach_function :raptor_set_statement_handler, [raptor_parser, :pointer, :raptor_statement_handler], :void
-      attach_function :raptor_parse_file, [raptor_parser, raptor_uri, raptor_uri], :int
-      attach_function :raptor_parse_file_stream, [raptor_parser, :pointer, :string, raptor_uri], :int
-      attach_function :raptor_parse_uri, [raptor_parser, raptor_uri, raptor_uri], :int
-      attach_function :raptor_start_parse, [raptor_parser, :string], :int
-      attach_function :raptor_parse_chunk, [raptor_parser, :string, :size_t, :int], :int
-      attach_function :raptor_get_mime_type, [raptor_parser], :string
-      attach_function :raptor_set_parser_strict, [raptor_parser, :int], :void
-      attach_function :raptor_get_need_base_uri, [raptor_parser], :int
-      attach_function :raptor_free_parser, [raptor_parser], :void
-
-      # @see http://librdf.org/raptor/api/raptor-section-iostream.html
-      define_pointer  :raptor_iostream
-      callback        :raptor_iostream_init_func, [:pointer], :int
-      callback        :raptor_iostream_finish_func, [:pointer], :void
-      callback        :raptor_iostream_write_byte_func, [:pointer, :int], :int
-      callback        :raptor_iostream_write_bytes_func, [:pointer, :pointer, :size_t, :size_t], :int
-      callback        :raptor_iostream_write_end_func, [:pointer], :void
-      callback        :raptor_iostream_read_bytes_func, [:pointer, :pointer, :size_t, :size_t], :int
-      callback        :raptor_iostream_read_eof_func, [:pointer], :int
-      attach_function :raptor_new_iostream_from_handler2, [:pointer, :pointer], raptor_iostream
-      attach_function :raptor_free_iostream, [raptor_iostream], :void
-
-      class IOStreamHandler < ::FFI::Struct
-        layout :version, :int,
-               :init, :raptor_iostream_init_func,
-               :finish, :raptor_iostream_finish_func,
-               :write_byte, :raptor_iostream_write_byte_func,
-               :write_bytes, :raptor_iostream_write_bytes_func,
-               :write_end, :raptor_iostream_write_end_func,
-               :read_bytes, :raptor_iostream_read_bytes_func,
-               :read_eof, :raptor_iostream_read_eof_func
-
-        attr_accessor :rubyio
-
-        def initialize(*args)
-          super
-          # Keep a ruby land reference to our procs so they don't
-          # get snatched by GC.
-          @procs = {}
-
-          self[:version] = 2
-
-          # @procs[:init] = self[:init] = Proc.new do |context|
-          #   $stderr.puts("#{self.class}: init")
-          # end
-          # @procs[:finish] = self[:finish] = Proc.new do |context|
-          #   $stderr.puts("#{self.class}: finish")
-          # end
-          @procs[:write_byte] = self[:write_byte] = Proc.new do |context, byte|
-            begin
-              @rubyio.putc(byte)
-            rescue
-              return 1
-            end
-            0
-          end
-          @procs[:write_bytes] = self[:write_bytes] = Proc.new do |context, data, size, nmemb|
-            begin
-              @rubyio.write(data.read_string(size * nmemb))
-            rescue
-              return 1
-            end
-            0
-          end
-          # @procs[:write_end] = self[:write_end] = Proc.new do |context|
-          #   $stderr.puts("#{self.class}: write_end")
-          # end
-          # @procs[:read_bytes] = self[:read_bytes] = Proc.new do |context, data, size, nmemb|
-          #   $stderr.puts("#{self.class}: read_bytes")
-          # end
-          # @procs[:read_eof] = self[:read_eof] = Proc.new do |context|
-          #   $stderr.puts("#{self.class}: read_eof")
-          # end
-        end
-      end
-
-      # @see http://librdf.org/raptor/api/raptor-section-xml-namespace.html
-      define_pointer  :raptor_namespace
-
-      # @see http://librdf.org/raptor/api/raptor-section-serializer.html
-      define_pointer  :raptor_serializer
-      attach_function :raptor_new_serializer, [:string], raptor_serializer
-      attach_function :raptor_free_serializer, [raptor_serializer], :void
-      attach_function :raptor_serialize_start_to_iostream, [raptor_serializer, raptor_uri, raptor_iostream], :int
-      attach_function :raptor_serialize_start_to_filename, [raptor_serializer, :string], :int
-      attach_function :raptor_serialize_statement, [raptor_serializer, raptor_statement], :int
-      attach_function :raptor_serialize_end, [raptor_serializer], :int
-      attach_function :raptor_serializer_set_error_handler, [raptor_serializer, :pointer, :raptor_message_handler], :void
-      attach_function :raptor_serializer_set_warning_handler, [raptor_serializer, :pointer, :raptor_message_handler], :void
-
-      # Initialize the world
-      # We do this exactly once and never release because we can't delegate
-      # any memory management to the ruby GC.
-      # Internally raptor_init/raptor_finish work with ref-counts.
-      raptor_init
-
-    end
-  end
-end
-
+      ffi_lib ::FFI::Library::LIBC
+      attach_function :strlen, [:pointer], :size_t
+    end # LibC
+  end # FFI
+end # RDF::Raptor