rdf-trix 0.2.0

data/AUTHORS

@@ -0,0 +1 @@
+* Arto Bendiken <arto.bendiken@gmail.com>

data/README

@@ -0,0 +1,59 @@
+TriX Support for RDF.rb
+=======================
+
+This is an [RDF.rb][] plugin that adds support for parsing/serializing
+[TriX][], an XML-based RDF serialization format developed by HP Labs and
+Nokia.
+
+* <http://github.com/bendiken/rdf-trix>
+* <http://blog.datagraph.org/2010/04/parsing-rdf-with-ruby>
+
+Documentation
+-------------
+
+* {RDF::TriX}
+  * {RDF::TriX::Format}
+  * {RDF::TriX::Reader}
+  * {RDF::TriX::Writer}
+
+Dependencies
+------------
+
+* [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.2.0)
+* [REXML](http://ruby-doc.org/stdlib/libdoc/rexml/rdoc/) (>= 3.1.7),
+  [LibXML-Ruby](http://rubygems.org/gems/libxml-ruby) (>= 1.1.4), or
+  [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.4.2)
+
+Installation
+------------
+
+The recommended installation method is via [RubyGems](http://rubygems.org/).
+To install the latest official release of the `RDF::TriX` gem, do:
+
+    % [sudo] gem install rdf-trix
+
+Download
+--------
+
+To get a local working copy of the development repository, do:
+
+    % git clone git://github.com/bendiken/rdf-trix.git
+
+Alternatively, you can download the latest development version as a tarball
+as follows:
+
+    % wget http://github.com/bendiken/rdf-trix/tarball/master
+
+Author
+------
+
+* [Arto Bendiken](mailto:arto.bendiken@gmail.com) - <http://ar.to/>
+
+License
+-------
+
+`RDF::TriX` is free and unencumbered public domain software. For more
+information, see <http://unlicense.org/> or the accompanying UNLICENSE file.
+
+[RDF.rb]:   http://rdf.rubyforge.org/
+[TriX]:     http://www.w3.org/2004/03/trix/

data/UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/etc/doap.xml

@@ -0,0 +1,115 @@
+<?xml version="1.0" encoding="utf-8"?>
+<TriX xmlns="http://www.w3.org/2004/03/trix/trix-1/">
+  <graph>
+    <triple>
+      <uri>http://ar.to/#self</uri>
+      <uri>http://www.w3.org/1999/02/22-rdf-syntax-ns#type</uri>
+      <uri>http://xmlns.com/foaf/0.1/Person</uri>
+    </triple>
+    <triple>
+      <uri>http://ar.to/#self</uri>
+      <uri>http://www.w3.org/2000/01/rdf-schema#isDefinedBy</uri>
+      <uri>http://datagraph.org/bendiken/foaf</uri>
+    </triple>
+    <triple>
+      <uri>http://ar.to/#self</uri>
+      <uri>http://xmlns.com/foaf/0.1/made</uri>
+      <uri>http://rubygems.org/gems/rdf-trix</uri>
+    </triple>
+    <triple>
+      <uri>http://ar.to/#self</uri>
+      <uri>http://xmlns.com/foaf/0.1/mbox</uri>
+      <uri>mailto:arto.bendiken@gmail.com</uri>
+    </triple>
+    <triple>
+      <uri>http://ar.to/#self</uri>
+      <uri>http://xmlns.com/foaf/0.1/name</uri>
+      <plainLiteral>Arto Bendiken</plainLiteral>
+    </triple>
+    <triple>
+      <uri>http://rubygems.org/gems/rdf-trix</uri>
+      <uri>http://purl.org/dc/terms/creator</uri>
+      <uri>http://ar.to/#self</uri>
+    </triple>
+    <triple>
+      <uri>http://rubygems.org/gems/rdf-trix</uri>
+      <uri>http://usefulinc.com/ns/doap#blog</uri>
+      <uri>http://ar.to/</uri>
+    </triple>
+    <triple>
+      <uri>http://rubygems.org/gems/rdf-trix</uri>
+      <uri>http://usefulinc.com/ns/doap#blog</uri>
+      <uri>http://blog.datagraph.org/</uri>
+    </triple>
+    <triple>
+      <uri>http://rubygems.org/gems/rdf-trix</uri>
+      <uri>http://usefulinc.com/ns/doap#bug-database</uri>
+      <uri>http://github.com/bendiken/rdf-trix/issues</uri>
+    </triple>
+    <triple>
+      <uri>http://rubygems.org/gems/rdf-trix</uri>
+      <uri>http://usefulinc.com/ns/doap#created</uri>
+      <plainLiteral>2010-02-02</plainLiteral>
+    </triple>
+    <triple>
+      <uri>http://rubygems.org/gems/rdf-trix</uri>
+      <uri>http://usefulinc.com/ns/doap#description</uri>
+      <plainLiteral xml:lang="en">RDF.rb plugin for parsing/serializing TriX data.</plainLiteral>
+    </triple>
+    <triple>
+      <uri>http://rubygems.org/gems/rdf-trix</uri>
+      <uri>http://usefulinc.com/ns/doap#developer</uri>
+      <uri>http://ar.to/#self</uri>
+    </triple>
+    <triple>
+      <uri>http://rubygems.org/gems/rdf-trix</uri>
+      <uri>http://usefulinc.com/ns/doap#documenter</uri>
+      <uri>http://ar.to/#self</uri>
+    </triple>
+    <triple>
+      <uri>http://rubygems.org/gems/rdf-trix</uri>
+      <uri>http://usefulinc.com/ns/doap#download-page</uri>
+      <uri>http://rubyforge.org/projects/rdf/</uri>
+    </triple>
+    <triple>
+      <uri>http://rubygems.org/gems/rdf-trix</uri>
+      <uri>http://usefulinc.com/ns/doap#homepage</uri>
+      <uri>http://rdf.rubyforge.org/trix/</uri>
+    </triple>
+    <triple>
+      <uri>http://rubygems.org/gems/rdf-trix</uri>
+      <uri>http://usefulinc.com/ns/doap#license</uri>
+      <uri>http://creativecommons.org/licenses/publicdomain/</uri>
+    </triple>
+    <triple>
+      <uri>http://rubygems.org/gems/rdf-trix</uri>
+      <uri>http://usefulinc.com/ns/doap#maintainer</uri>
+      <uri>http://ar.to/#self</uri>
+    </triple>
+    <triple>
+      <uri>http://rubygems.org/gems/rdf-trix</uri>
+      <uri>http://usefulinc.com/ns/doap#name</uri>
+      <plainLiteral>RDF::TriX</plainLiteral>
+    </triple>
+    <triple>
+      <uri>http://rubygems.org/gems/rdf-trix</uri>
+      <uri>http://usefulinc.com/ns/doap#platform</uri>
+      <plainLiteral>Ruby</plainLiteral>
+    </triple>
+    <triple>
+      <uri>http://rubygems.org/gems/rdf-trix</uri>
+      <uri>http://usefulinc.com/ns/doap#shortdesc</uri>
+      <plainLiteral xml:lang="en">TriX support for RDF.rb.</plainLiteral>
+    </triple>
+    <triple>
+      <uri>http://rubygems.org/gems/rdf-trix</uri>
+      <uri>http://www.w3.org/1999/02/22-rdf-syntax-ns#type</uri>
+      <uri>http://usefulinc.com/ns/doap#Project</uri>
+    </triple>
+    <triple>
+      <uri>http://rubygems.org/gems/rdf-trix</uri>
+      <uri>http://xmlns.com/foaf/0.1/maker</uri>
+      <uri>http://ar.to/#self</uri>
+    </triple>
+  </graph>
+</TriX>

data/lib/rdf/trix.rb

@@ -0,0 +1,36 @@
+require 'rdf'
+
+module RDF
+  ##
+  # **`RDF::TriX`** is a TriX plugin for RDF.rb.
+  #
+  # @example Requiring the `RDF::TriX` module
+  #   require 'rdf/trix'
+  #
+  # @example Parsing RDF statements from a TriX file
+  #   RDF::TriX::Reader.open("etc/doap.xml") do |reader|
+  #     reader.each_statement do |statement|
+  #       puts statement.inspect
+  #     end
+  #   end
+  #
+  # @example Serializing RDF statements into a TriX file
+  #   RDF::TriX::Writer.open("etc/test.xml") do |writer|
+  #     reader.each_statement do |statement|
+  #       writer << statement
+  #     end
+  #   end
+  #
+  # @see http://rdf.rubyforge.org/
+  # @see http://www.w3.org/2004/03/trix/
+  # @see http://www.hpl.hp.com/techreports/2004/HPL-2004-56.pdf
+  # @see http://swdev.nokia.com/trix/trix.html
+  #
+  # @author [Arto Bendiken](http://ar.to/)
+  module TriX
+    require 'rdf/trix/format'
+    autoload :Reader,  'rdf/trix/reader'
+    autoload :Writer,  'rdf/trix/writer'
+    autoload :VERSION, 'rdf/trix/version'
+  end # module TriX
+end # module RDF

data/lib/rdf/trix/format.rb

@@ -0,0 +1,22 @@
+module RDF::TriX
+  ##
+  # TriX format specification.
+  #
+  # @example Obtaining a TriX format class
+  #   RDF::Format.for(:trix)         #=> RDF::TriX::Format
+  #   RDF::Format.for("etc/doap.xml")
+  #   RDF::Format.for(:file_name      => "etc/doap.xml")
+  #   RDF::Format.for(:file_extension => "xml")
+  #   RDF::Format.for(:content_type   => "application/trix")
+  #
+  # @see http://www.w3.org/2004/03/trix/
+  class Format < RDF::Format
+    content_type     'application/trix', :extension => :xml
+    content_encoding 'utf-8'
+
+    reader { RDF::TriX::Reader }
+    writer { RDF::TriX::Writer }
+
+    XMLNS = 'http://www.w3.org/2004/03/trix/trix-1/'
+  end # class Format
+end # module RDF::TriX

data/lib/rdf/trix/reader.rb

@@ -0,0 +1,151 @@
+module RDF::TriX
+  ##
+  # TriX parser.
+  #
+  # This class supports [REXML][], [LibXML][] and [Nokogiri][] for XML
+  # processing, and will automatically select the most performant
+  # implementation (Nokogiri or LibXML) that is available. If need be, you
+  # can explicitly override the used implementation by passing in a
+  # `:library` option to `Reader.new` or `Reader.open`.
+  #
+  # [REXML]:    http://www.germane-software.com/software/rexml/
+  # [LibXML]:   http://libxml.rubyforge.org/rdoc/
+  # [Nokogiri]: http://nokogiri.org/
+  #
+  # @example Obtaining a TriX reader class
+  #   RDF::Reader.for(:trix)         #=> RDF::TriX::Reader
+  #   RDF::Reader.for("etc/doap.xml")
+  #   RDF::Reader.for(:file_name      => "etc/doap.xml")
+  #   RDF::Reader.for(:file_extension => "xml")
+  #   RDF::Reader.for(:content_type   => "application/trix")
+  #
+  # @example Instantiating a Nokogiri-based reader
+  #   RDF::TriX::Reader.new(input, :library => :nokogiri)
+  #
+  # @example Instantiating a LibXML-based reader
+  #   RDF::TriX::Reader.new(input, :library => :libxml)
+  #
+  # @example Instantiating a REXML-based reader
+  #   RDF::TriX::Reader.new(input, :library => :rexml)
+  #
+  # @example Parsing RDF statements from a TriX file
+  #   RDF::TriX::Reader.open("etc/doap.xml") do |reader|
+  #     reader.each_statement do |statement|
+  #       puts statement.inspect
+  #     end
+  #   end
+  #
+  # @example Parsing RDF statements from a TriX string
+  #   data = StringIO.new(File.read("etc/doap.xml"))
+  #   RDF::TriX::Reader.new(data) do |reader|
+  #     reader.each_statement do |statement|
+  #       puts statement.inspect
+  #     end
+  #   end
+  #
+  # @see http://www.w3.org/2004/03/trix/
+  class Reader < RDF::Reader
+    format RDF::TriX::Format
+
+    ##
+    # Returns the XML implementation module for this reader instance.
+    #
+    # @return [Module]
+    attr_reader :implementation
+
+    ##
+    # Initializes the TriX reader instance.
+    #
+    # @param  [IO, File, String]       input
+    # @param  [Hash{Symbol => Object}] options
+    # @option options [Symbol]         :library (:nokogiri, :libxml, or :rexml)
+    # @yield  [reader]
+    # @yieldparam [Reader] reader
+    def initialize(input = $stdin, options = {}, &block)
+      super do
+        @library = case options[:library]
+          when nil
+            # Use Nokogiri or LibXML when available, and REXML otherwise:
+            begin
+              require 'nokogiri'
+              :nokogiri
+            rescue LoadError => e
+              begin
+                require 'libxml'
+                :libxml
+              rescue LoadError => e
+                :rexml
+              end
+            end
+          when :nokogiri, :libxml, :rexml
+            options[:library]
+          else
+            raise ArgumentError.new("expected :rexml, :libxml or :nokogiri, but got #{options[:library].inspect}")
+        end
+
+        require "rdf/trix/reader/#{@library}"
+        @implementation = case @library
+          when :nokogiri then Nokogiri
+          when :libxml   then LibXML
+          when :rexml    then REXML
+        end
+        self.extend(@implementation)
+
+        initialize_xml(options)
+        block.call(self) if block_given?
+      end
+    end
+
+    ##
+    # @private
+    # @see RDF::Reader#each_triple
+    def each_triple(&block)
+      unless block_given?
+        enum_for(:each_triple)
+      else
+        each_statement do |statement|
+          block.call(*statement.to_triple)
+        end
+      end
+    end
+
+    ##
+    # @private
+    # @see RDF::Reader#each_quad
+    def each_quad(&block)
+      unless block_given?
+        enum_for(:each_quad)
+      else
+        each_statement do |statement|
+          block.call(*statement.to_quad)
+        end
+      end
+    end
+
+    ##
+    # Returns the RDF value of the given TriX element.
+    #
+    # @param  [String]                 name
+    # @param  [Hash{String => Object}] attributes
+    # @param  [String] content
+    # @return [RDF::Value]
+    def parse_element(name, attributes, content)
+      case name.to_sym
+        when :id
+          RDF::Node.new(content.strip)
+        when :uri
+          RDF::URI.new(content.strip)
+        when :typedLiteral
+          RDF::Literal.new(content, :datatype => attributes['datatype'])
+        when :plainLiteral
+          if lang = attributes['xml:lang'] || attributes['lang']
+            RDF::Literal.new(content, :language => lang)
+          else
+            RDF::Literal.new(content)
+          end
+        else
+          # TODO: raise error
+      end
+    end
+  end # class Reader
+end # module RDF::TriX

data/lib/rdf/trix/reader/libxml.rb

@@ -0,0 +1,82 @@
+module RDF::TriX
+  class Reader < RDF::Reader
+    ##
+    # LibXML-Ruby implementation of the TriX reader.
+    #
+    # @see http://libxml.rubyforge.org/rdoc/
+    module LibXML
+      OPTIONS = {'trix' => Format::XMLNS}.freeze
+
+      ##
+      # Returns the name of the underlying XML library.
+      #
+      # @return [Symbol]
+      def self.library
+        :libxml
+      end
+
+      ##
+      # Initializes the underlying XML library.
+      #
+      # @param  [Hash{Symbol => Object}] options
+      # @return [void]
+      def initialize_xml(options = {})
+        require 'libxml' unless defined?(::LibXML)
+        @xml = case @input
+          when File   then ::LibXML::XML::Document.file(@input.path)
+          when IO     then ::LibXML::XML::Document.io(@input)
+          else ::LibXML::XML::Document.string(@input.to_s)
+        end
+      end
+
+      ##
+      # @private
+      # @see RDF::Reader#each_graph
+      def each_graph(&block)
+        unless block_given?
+          enum_for(:each_graph)
+        else
+          @xml.find('//trix:graph', OPTIONS).each do |graph_element|
+            graph = RDF::Graph.new(read_context(graph_element))
+            read_statements(graph_element) { |statement| graph << statement }
+            block.call(graph)
+          end
+        end
+      end
+
+      ##
+      # @private
+      # @see RDF::Reader#each_statement
+      def each_statement(&block)
+        unless block_given?
+          enum_for(:each_statement)
+        else
+          @xml.find('//trix:graph', OPTIONS).each do |graph_element|
+            read_statements(graph_element, &block)
+          end
+        end
+      end
+
+    protected
+
+      ##
+      # @private
+      def read_context(graph_element)
+        name = graph_element.children.select { |node| node.element? && node.name.to_s == 'uri' }.first.content.strip rescue nil
+        name ? RDF::URI.intern(name) : nil
+      end
+
+      ##
+      # @private
+      def read_statements(graph_element, &block)
+        context = read_context(graph_element)
+        graph_element.find('./trix:triple', OPTIONS).each do |triple_element|
+          triple = triple_element.children.select { |node| node.element? }[0..2]
+          triple = triple.map { |element| parse_element(element.name, element.attributes, element.content) }
+          triple << {:context => context} if context
+          block.call(RDF::Statement.new(*triple))
+        end
+      end
+    end # module LibXML
+  end # class Reader
+end # module RDF::TriX

data/lib/rdf/trix/reader/nokogiri.rb

@@ -0,0 +1,78 @@
+module RDF::TriX
+  class Reader < RDF::Reader
+    ##
+    # Nokogiri implementation of the TriX reader.
+    #
+    # @see http://nokogiri.org/
+    module Nokogiri
+      OPTIONS = {'trix' => Format::XMLNS}.freeze
+
+      ##
+      # Returns the name of the underlying XML library.
+      #
+      # @return [Symbol]
+      def self.library
+        :nokogiri
+      end
+
+      ##
+      # Initializes the underlying XML library.
+      #
+      # @param  [Hash{Symbol => Object}] options
+      # @return [void]
+      def initialize_xml(options = {})
+        require 'nokogiri' unless defined?(::Nokogiri)
+        @xml = ::Nokogiri::XML(@input)
+      end
+
+      ##
+      # @private
+      # @see RDF::Reader#each_graph
+      def each_graph(&block)
+        unless block_given?
+          enum_for(:each_graph)
+        else
+          @xml.xpath('//trix:graph', OPTIONS).each do |graph_element|
+            graph = RDF::Graph.new(read_context(graph_element))
+            read_statements(graph_element) { |statement| graph << statement }
+            block.call(graph)
+          end
+        end
+      end
+
+      ##
+      # @private
+      # @see RDF::Reader#each_statement
+      def each_statement(&block)
+        unless block_given?
+          enum_for(:each_statement)
+        else
+          @xml.xpath('//trix:graph', OPTIONS).each do |graph_element|
+            read_statements(graph_element, &block)
+          end
+        end
+      end
+
+    protected
+
+      ##
+      # @private
+      def read_context(graph_element)
+        name = graph_element.children.select { |node| node.element? && node.name.to_s == 'uri' }.first.content.strip rescue nil
+        name ? RDF::URI.intern(name) : nil
+      end
+
+      ##
+      # @private
+      def read_statements(graph_element, &block)
+        context = read_context(graph_element)
+        graph_element.xpath('./trix:triple', OPTIONS).each do |triple_element|
+          triple = triple_element.children.select { |node| node.element? }[0..2]
+          triple = triple.map { |element| parse_element(element.name, element, element.content) }
+          triple << {:context => context} if context
+          block.call(RDF::Statement.new(*triple))
+        end
+      end
+    end # module Nokogiri
+  end # class Reader
+end # module RDF::TriX

data/lib/rdf/trix/reader/rexml.rb

@@ -0,0 +1,78 @@
+module RDF::TriX
+  class Reader < RDF::Reader
+    ##
+    # REXML implementation of the TriX reader.
+    #
+    # @see http://www.germane-software.com/software/rexml/
+    module REXML
+      OPTIONS = {}.freeze
+
+      ##
+      # Returns the name of the underlying XML library.
+      #
+      # @return [Symbol]
+      def self.library
+        :rexml
+      end
+
+      ##
+      # Initializes the underlying XML library.
+      #
+      # @param  [Hash{Symbol => Object}] options
+      # @return [void]
+      def initialize_xml(options = {})
+        require 'rexml/document' unless defined?(::REXML)
+        @xml = ::REXML::Document.new(@input, :compress_whitespace => %w{uri})
+      end
+
+      ##
+      # @private
+      # @see RDF::Reader#each_graph
+      def each_graph(&block)
+        unless block_given?
+          enum_for(:each_graph)
+        else
+          @xml.elements.each('TriX/graph') do |graph_element|
+            graph = RDF::Graph.new(read_context(graph_element))
+            read_statements(graph_element) { |statement| graph << statement }
+            block.call(graph)
+          end
+        end
+      end
+
+      ##
+      # @private
+      # @see RDF::Reader#each_statement
+      def each_statement(&block)
+        unless block_given?
+          enum_for(:each_statement)
+        else
+          @xml.elements.each('TriX/graph') do |graph_element|
+            read_statements(graph_element, &block)
+          end
+        end
+      end
+
+    protected
+
+      ##
+      # @private
+      def read_context(graph_element)
+        name = graph_element.elements.select { |element| element.name.to_s == 'uri' }.first.text.strip rescue nil
+        name ? RDF::URI.intern(name) : nil
+      end
+
+      ##
+      # @private
+      def read_statements(graph_element, &block)
+        context = read_context(graph_element)
+        graph_element.elements.each('triple') do |triple_element|
+          triple = triple_element.elements.to_a[0..2]
+          triple = triple.map { |element| parse_element(element.name, element.attributes, element.text) }
+          triple << {:context => context} if context
+          block.call(RDF::Statement.new(*triple))
+        end
+      end
+    end # module REXML
+  end # class Reader
+end # module RDF::TriX

data/lib/rdf/trix/version.rb

@@ -0,0 +1,22 @@
+module RDF module TriX
+  module VERSION
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 0
+    EXTRA = nil
+
+    STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')
+
+    ##
+    # @return [String]
+    def self.to_s()   STRING end
+
+    ##
+    # @return [String]
+    def self.to_str() STRING end
+
+    ##
+    # @return [Array(Integer, Integer, Integer)]
+    def self.to_a() [MAJOR, MINOR, TINY] end
+  end
+end end

data/lib/rdf/trix/writer.rb

@@ -0,0 +1,236 @@
+module RDF::TriX
+  ##
+  # TriX serializer.
+  #
+  # This class supports both [REXML][] and [Nokogiri][] for XML processing,
+  # and will automatically select the most performant implementation
+  # (Nokogiri) when it is available. If need be, you can explicitly
+  # override the used implementation by passing in a `:library` option to
+  # `Writer.new` or `Writer.open`.
+  #
+  # [REXML]:    http://www.germane-software.com/software/rexml/
+  # [LibXML]:   http://libxml.rubyforge.org/rdoc/
+  # [Nokogiri]: http://nokogiri.org/
+  #
+  # @example Obtaining a TriX writer class
+  #   RDF::Writer.for(:trix)         #=> RDF::TriX::Writer
+  #   RDF::Writer.for("etc/test.xml")
+  #   RDF::Writer.for(:file_name      => "etc/test.xml")
+  #   RDF::Writer.for(:file_extension => "xml")
+  #   RDF::Writer.for(:content_type   => "application/trix")
+  #
+  # @example Instantiating a Nokogiri-based writer
+  #   RDF::TriX::Writer.new(output, :library => :nokogiri)
+  #
+  # @example Instantiating a REXML-based writer
+  #   RDF::TriX::Writer.new(output, :library => :rexml)
+  #
+  # @example Serializing RDF statements into a TriX file
+  #   RDF::TriX::Writer.open("etc/test.xml") do |writer|
+  #     graph.each_statement do |statement|
+  #       writer << statement
+  #     end
+  #   end
+  #
+  # @example Serializing RDF statements into a TriX string
+  #   RDF::TriX::Writer.buffer do |writer|
+  #     graph.each_statement do |statement|
+  #       writer << statement
+  #     end
+  #   end
+  #
+  # @see http://www.w3.org/2004/03/trix/
+  class Writer < RDF::Writer
+    format RDF::TriX::Format
+
+    ##
+    # Returns the XML implementation module for this writer instance.
+    #
+    # @return [Module]
+    attr_reader :implementation
+
+    ##
+    # Returns the current named graph context, if any.
+    #
+    # @return [RDF::Resource]
+    attr_reader :context
+
+    ##
+    # Initializes the TriX writer instance.
+    #
+    # @param  [IO, File]               output
+    # @param  [Hash{Symbol => Object}] options
+    # @option options [Symbol]         :library  (:nokogiri or :rexml)
+    # @option options [String, #to_s]  :encoding ('utf-8')
+    # @option options [Integer]        :indent   (2)
+    # @yield  [writer]
+    # @yieldparam [Writer] writer
+    def initialize(output = $stdout, options = {}, &block)
+      @context = nil
+      @nesting = 0
+
+      @library = case options[:library]
+        when nil
+          # Use Nokogiri or LibXML when available, and REXML otherwise:
+          begin
+            require 'nokogiri'
+            :nokogiri
+          rescue LoadError => e
+            begin
+              require 'libxml'
+              :rexml # FIXME: no LibXML support implemented yet
+            rescue LoadError => e
+              :rexml
+            end
+          end
+        when :libxml then :rexml # FIXME
+        when :nokogiri, :libxml, :rexml
+          options[:library]
+        else
+          raise ArgumentError.new("expected :rexml, :libxml or :nokogiri, but got #{options[:library].inspect}")
+      end
+
+      require "rdf/trix/writer/#{@library}"
+      @implementation = case @library
+        when :nokogiri then Nokogiri
+        when :libxml   then LibXML # TODO
+        when :rexml    then REXML
+      end
+      self.extend(@implementation)
+
+      @encoding = (options[:encoding] || 'utf-8').to_s
+      initialize_xml(options)
+      super
+    end
+
+    ##
+    # Defines a named graph context.
+    #
+    # @param  [RDF::Resource] name
+    # @yield  [writer]
+    # @yieldparam [RDF::TriX::Writer] writer
+    # @return [void]
+    def graph(name = nil, &block)
+      @nesting += 1
+      @graph = create_graph(@context = name)
+      if block_given?
+        case block.arity
+          when 1 then block.call(self)
+          else instance_eval(&block)
+        end
+      end
+      @graph = nil
+      @nesting -= 1
+    end
+
+    ##
+    # Returns `true` if we are currently in a `writer.graph { ... }` block.
+    #
+    # @return [Boolean]
+    def nested?
+      @nesting > 0
+    end
+
+    protected :nested?
+
+    ##
+    # Generates an XML comment.
+    #
+    # @param  [String, #to_s] text
+    # @return [void]
+    # @see    RDF::Writer#write_comment
+    def write_comment(text)
+      (@graph || @trix) << create_comment(text)
+    end
+
+    ##
+    # @private
+    # @see    RDF::Writer#write_graph
+    # @since  0.2.0
+    def write_graph(graph)
+      @graph = create_graph(@context = graph.context)
+      graph.each_triple { |*triple| write_triple(*triple) }
+    end
+
+    ##
+    # Generates the TriX representation of an RDF statement.
+    #
+    # @param  [RDF::Statement] statement
+    # @return [void]
+    def write_statement(statement)
+      unless nested? || statement.context.to_s == @context.to_s
+        @graph = create_graph(@context = statement.context)
+      end
+      write_triple(*statement.to_triple)
+    end
+
+    ##
+    # Generates the TriX representation of a triple.
+    #
+    # @param  [RDF::Resource] subject
+    # @param  [RDF::URI]      predicate
+    # @param  [RDF::Value]    object
+    # @return [void]
+    def write_triple(subject, predicate, object)
+      @graph = create_graph unless @graph
+      @graph << format_triple(subject, predicate, object)
+    end
+
+    ##
+    # Returns the TriX representation of a triple.
+    #
+    # @param  [RDF::Resource]          subject
+    # @param  [RDF::URI]               predicate
+    # @param  [RDF::Value]             object
+    # @param  [Hash{Symbol => Object}] options
+    # @return [Element]
+    def format_triple(subject, predicate, object, options = {})
+      create_element(:triple) do |triple|
+        triple << format_value(subject, options)
+        triple << format_value(predicate, options)
+        triple << format_value(object, options)
+      end
+    end
+
+    ##
+    # Returns the TriX representation of a blank node.
+    #
+    # @param  [RDF::Node]              value
+    # @param  [Hash{Symbol => Object}] options
+    # @return [Element]
+    def format_node(value, options = {})
+      create_element(:id, value.id.to_s)
+    end
+
+    ##
+    # Returns the TriX representation of a URI reference.
+    #
+    # @param  [RDF::URI]               value
+    # @param  [Hash{Symbol => Object}] options
+    # @return [Element]
+    def format_uri(value, options = {})
+      create_element(:uri, value.to_s)
+    end
+
+    ##
+    # Returns the TriX representation of a literal.
+    #
+    # @param  [RDF::Literal, String, #to_s] value
+    # @param  [Hash{Symbol => Object}]      options
+    # @return [Element]
+    def format_literal(value, options = {})
+      value = RDF::Literal.new(value) unless value.is_a?(RDF::Literal) # FIXME: remove after RDF.rb 0.2.1
+      case
+        when value.has_datatype?
+          create_element(:typedLiteral, value.value.to_s, 'datatype' => value.datatype.to_s)
+        when value.has_language?
+          create_element(:plainLiteral, value.value.to_s, 'xml:lang' => value.language.to_s)
+        else
+          create_element(:plainLiteral, value.value.to_s)
+      end
+    end
+
+    alias_method :insert_graph,     :write_graph     # FIXME: remove after RDF.rb 0.2.1
+    alias_method :insert_statement, :write_statement # FIXME: remove after RDF.rb 0.2.1
+  end # class Writer
+end # module RDF::TriX

data/lib/rdf/trix/writer/nokogiri.rb

@@ -0,0 +1,93 @@
+module RDF::TriX
+  class Writer < RDF::Writer
+    ##
+    # Nokogiri implementation of the TriX writer.
+    #
+    # @see http://nokogiri.org/
+    module Nokogiri
+      ##
+      # Returns the name of the underlying XML library.
+      #
+      # @return [Symbol]
+      def self.library
+        :nokogiri
+      end
+
+      ##
+      # Initializes the underlying XML library.
+      #
+      # @param  [Hash{Symbol => Object}] options
+      # @return [void]
+      def initialize_xml(options = {})
+        require 'nokogiri' unless defined?(::Nokogiri)
+        @xml = ::Nokogiri::XML::Document.new
+        @xml.encoding = @encoding
+      end
+
+      ##
+      # Generates the TriX root element.
+      #
+      # @return [void]
+      def write_prologue
+        @xml << (@trix = create_element(:TriX, nil, :xmlns => Format::XMLNS))
+      end
+
+      ##
+      # Outputs the TriX document.
+      #
+      # @return [void]
+      def write_epilogue
+        puts @xml.to_xml
+        @xml = @trix = nil
+      end
+
+      ##
+      # Creates an XML graph element with the given `name`.
+      #
+      # @param  [RDF::Resource] name
+      # @yield  [element]
+      # @yieldparam [Nokogiri::XML::Element] element
+      # @return [Nokogiri::XML::Element]
+      def create_graph(name = nil, &block)
+        @trix << (graph = create_element(:graph))
+        case name
+          when nil then nil
+          when RDF::Node then graph << create_element(:id, name.to_s) # non-standard
+          else graph << create_element(:uri, name.to_s)
+        end
+        block.call(graph) if block_given?
+        graph
+      end
+
+      ##
+      # Creates an XML comment element with the given `text`.
+      #
+      # @param  [String, #to_s] text
+      # @return [Nokogiri::XML::Comment]
+      def create_comment(text)
+        ::Nokogiri::XML::Comment.new(@xml, text.to_s)
+      end
+
+      ##
+      # Creates an XML element of the given `name`, with optional given
+      # `content` and `attributes`.
+      #
+      # @param  [Symbol, String, #to_s]  name
+      # @param  [String, #to_s]          content
+      # @param  [Hash{Symbol => Object}] attributes
+      # @yield  [element]
+      # @yieldparam [Nokogiri::XML::Element] element
+      # @return [Nokogiri::XML::Element]
+      def create_element(name, content = nil, attributes = {}, &block)
+        element = @xml.create_element(name.to_s)
+        if xmlns = attributes.delete(:xmlns)
+          element.default_namespace = xmlns
+        end
+        attributes.each { |k, v| element[k.to_s] = v }
+        element.content = content.to_s unless content.nil?
+        block.call(element) if block_given?
+        element
+      end
+    end # module Nokogiri
+  end # class Writer
+end # module RDF::TriX

data/lib/rdf/trix/writer/rexml.rb

@@ -0,0 +1,93 @@
+module RDF::TriX
+  class Writer < RDF::Writer
+    ##
+    # REXML implementation of the TriX writer.
+    #
+    # @see http://www.germane-software.com/software/rexml/
+    module REXML
+      ##
+      # Returns the name of the underlying XML library.
+      #
+      # @return [Symbol]
+      def self.library
+        :rexml
+      end
+
+      ##
+      # Initializes the underlying XML library.
+      #
+      # @param  [Hash{Symbol => Object}] options
+      # @return [void]
+      def initialize_xml(options = {})
+        require 'rexml/document' unless defined?(::REXML)
+        @xml = ::REXML::Document.new(nil, :attribute_quote => :quote)
+        @xml << ::REXML::XMLDecl.new(::REXML::XMLDecl::DEFAULT_VERSION, @encoding)
+      end
+
+      ##
+      # Generates the TriX root element.
+      #
+      # @return [void]
+      def write_prologue
+        @trix = @xml.add_element('TriX', 'xmlns' => Format::XMLNS)
+      end
+
+      ##
+      # Outputs the TriX document.
+      #
+      # @return [void]
+      def write_epilogue
+        formatter = ::REXML::Formatters::Pretty.new((@options[:indent] || 2).to_i, false)
+        formatter.compact = true
+        formatter.write(@xml, @output)
+        puts # add a line break after the last line
+        @xml = @trix = nil
+      end
+
+      ##
+      # Creates an XML graph element with the given `name`.
+      #
+      # @param  [RDF::Resource] name
+      # @yield  [element]
+      # @yieldparam [REXML::Element] element
+      # @return [REXML::Element]
+      def create_graph(name = nil, &block)
+        graph = @trix.add_element('graph')
+        case name
+          when nil then nil
+          when RDF::Node then graph.add_element('id').text = name.to_s # non-standard
+          else graph.add_element('uri').text = name.to_s
+        end
+        block.call(graph) if block_given?
+        graph
+      end
+
+      ##
+      # Creates an XML comment element with the given `text`.
+      #
+      # @param  [String, #to_s] text
+      # @return [REXML::Comment]
+      def create_comment(text)
+        ::REXML::Comment.new(text.to_s)
+      end
+
+      ##
+      # Creates an XML element of the given `name`, with optional given
+      # `content` and `attributes`.
+      #
+      # @param  [Symbol, String, #to_s]  name
+      # @param  [String, #to_s]          content
+      # @param  [Hash{Symbol => Object}] attributes
+      # @yield  [element]
+      # @yieldparam [REXML::Element] element
+      # @return [REXML::Element]
+      def create_element(name, content = nil, attributes = {}, &block)
+        element = ::REXML::Element.new(name.to_s, nil, @xml.context)
+        attributes.each { |k, v| element.add_attribute(k.to_s, v) }
+        element.text = content.to_s unless content.nil?
+        block.call(element) if block_given?
+        element
+      end
+    end # module REXML
+  end # class Writer
+end # module RDF::TriX

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification 
+name: rdf-trix
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Arto Bendiken
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-22 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rdf
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 0
+        version: 0.2.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rexml
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 1
+        - 7
+        version: 3.1.7
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: libxml-ruby
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 1
+        - 4
+        version: 1.1.4
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 4
+        - 2
+        version: 1.4.2
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 5
+        - 6
+        version: 0.5.6
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: rdf-spec
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 0
+        version: 0.2.0
+  type: :development
+  version_requirements: *id007
+description: RDF.rb plugin for parsing/serializing TriX data.
+email: public-rdf-ruby@w3.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- AUTHORS
+- README
+- UNLICENSE
+- VERSION
+- etc/doap.xml
+- lib/rdf/trix/format.rb
+- lib/rdf/trix/reader/libxml.rb
+- lib/rdf/trix/reader/nokogiri.rb
+- lib/rdf/trix/reader/rexml.rb
+- lib/rdf/trix/reader.rb
+- lib/rdf/trix/version.rb
+- lib/rdf/trix/writer/nokogiri.rb
+- lib/rdf/trix/writer/rexml.rb
+- lib/rdf/trix/writer.rb
+- lib/rdf/trix.rb
+has_rdoc: false
+homepage: http://rdf.rubyforge.org/trix/
+licenses: 
+- Public Domain
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 8
+      - 1
+      version: 1.8.1
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: 
+- REXML (>= 3.1.7), LibXML-Ruby (>= 1.1.4) or Nokogiri (>= 1.4.2)
+rubyforge_project: rdf
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: TriX support for RDF.rb.
+test_files: []
+