rdf-xml 0.0.3

data/UNLICENSE

@@ -0,0 +1,25 @@
+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, contact Alex Serebryakov [serebryakov@gmail.com]
+or visit <http://unlicense.org/>

data/VERSION

@@ -0,0 +1 @@
+0.0.3

data/lib/rdf-xml.rb

@@ -0,0 +1,34 @@
+module RDF
+  ##
+  # **`RDF::XML`** is an XML plugin for RDF.rb.
+  #
+  # @example Requiring the `RDF::XML` module
+  #   require 'rdf-xml'
+  #
+  # @example Parsing RDF statements from an XML file
+  #   RDF::XML::Reader.open("etc/doap.xml") do |reader|
+  #     reader.each_statement do |statement|
+  #       puts statement.inspect
+  #     end
+  #   end
+  #
+  # @example Serializing RDF statements into an XML file
+  #   RDF::XML::Writer.open("etc/test.xml") do |writer|
+  #     reader.each_statement do |statement|
+  #       writer << statement
+  #     end
+  #   end
+  #
+  # @see http://rdf.rubyforge.org/
+  #
+  # @author [Alex Serebryakov](http://42cities.com/)
+  module XML
+    require 'rdf'
+    require 'xml/format'
+    require 'nokogiri'
+    
+    autoload :Reader,  'xml/reader'
+    autoload :Writer,  'xml/writer'
+    autoload :VERSION, 'xml/version'
+  end # module XML
+end # module RDF

data/lib/xml/format.rb

@@ -0,0 +1,20 @@
+module RDF::XML
+  ##
+  # XML format specification.
+  #
+  # @example Obtaining an XML format class
+  #   RDF::Format.for(:xml)         #=> RDF::XML::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/rdf+xml")
+  #
+  class Format < RDF::Format
+    content_type     'application/rdf+xml', :extension => :xml
+    content_encoding 'utf-8'
+
+    reader { RDF::XML::Reader }
+    writer { RDF::XML::Writer }
+
+  end # class Format
+end # module RDF::XML

data/lib/xml/reader.rb

@@ -0,0 +1,205 @@
+module RDF
+  module XML
+    class Reader < RDF::Reader
+
+      format RDF::XML::Format
+
+      ##
+      # [-]
+      ##
+      def initialize(input = $stdin, options = {}, &block)
+        @input = input.respond_to?(:read) ? input.read : input
+        @xml = ::Nokogiri::XML(@input)
+        yield self if block_given?
+      end
+
+      ##
+      # [-]
+      ##
+      def each_triple(&block)
+        return unless block_given?
+        if @xml.root.nil?
+          raise RuntimeError, 'Malformed XML document'
+        end
+        @xml.root.subnodes.each do |node|
+          parse_descriptions(node, &block)
+        end
+      end
+
+      ##
+      # [-]
+      ##
+      def each_statement(&block)
+        return unless block_given?
+        each_triple do |*triple|
+          yield RDF::Statement.new(*triple)
+        end
+      end
+
+      private
+
+      ##
+      # [-]
+      ##
+      def parse_descriptions(element, parent = nil, predicate = nil, &block)
+        
+        # Parsing all inline properties
+        properties = Hash[parse_inline_properties(element)]
+        # Checking if this is a blank node
+        uri = properties.key?(:uri) ? properties.delete(:uri) : RDF::Node.uuid
+
+        # If parent is present, yield the relationship
+        unless parent.nil?
+          block.call([parent, predicate, uri])
+        end
+
+        # Yield each nested property
+        properties.each do |name, value|
+          block.call([uri, name, value])
+        end
+        
+        # Yield RDF type, if tag name is not RDF.description
+        if element.ns_name != RDF.Description
+          block.call([uri, RDF.type, element.ns_name])
+        end
+        
+        parse_all_nested_properties(element, uri, &block)
+      end
+
+      ##
+      # [-]
+      ##
+      def parse_all_nested_properties(element, parent, &block)
+        element.subnodes.each do |node|
+          parse_nested_property(node, parent, &block)
+        end
+      end
+      
+      ##
+      # [-]
+      ##
+      def property_has_node_id?(element)
+        att = element.attribute_with_ns('nodeID', RDF.to_uri.to_s)
+        att.nil? ? nil : RDF::Node.new(att.value)
+      end
+      
+      ##
+      # [-]
+      ##
+      def property_has_resource?(element)
+        att = element.attribute_with_ns('resource', RDF.to_uri.to_s)
+        att.nil? ? nil : RDF::URI.new(element.base || uri).join(att.value)
+      end
+      
+  		# Checks if rdf:parseType is set to 'Resource'
+  		# <ex:editor rdf:parseType="Resource">
+	    #   <ex:fullName>Dave Beckett</ex:fullName>
+	    #   <ex:homePage rdf:resource="http://purl.org/net/dajobe/"/>
+	    # </ex:editor>
+      def property_is_resource_parse_type?(element, parent, &block)
+        att = element.attribute_with_ns('parseType', RDF.to_uri.to_s)
+        object = att.nil? ? nil : (att.value == 'Resource' ? RDF::Node.uuid : nil)
+        return nil if object.nil?
+        parse_all_nested_properties(element, object, &block)
+        block.call([parent, element.ns_name, object])
+        true
+      end
+      
+      ##
+      # [-]
+      ##
+      def property_is_resource?(element, parent, &block)
+        object = (property_has_node_id?(element) or property_has_resource?(element))
+        return nil if object.nil?
+        block.call([parent, element.ns_name, object])
+        true
+      end
+      
+  		# Checks if rdf:parseType is set to 'Literal'
+  		# <ex:editor rdf:parseType="Literal">
+	    #   <html><head><title>Hello, world!</title></head></html>
+	    # </ex:editor>
+      def property_is_literal_parse_type?(element, parent, &block)
+        att = element.attribute_with_ns('parseType', RDF.to_uri.to_s)
+        object = att.nil? ? nil : (att.value == 'Literal' ? true : nil)
+        return nil if object.nil?
+        block.call([parent, element.ns_name, element.to_s])
+        true
+      end
+      
+      ##
+      # [-]
+      ##
+      def property_has_subnodes?(element, parent, &block)
+        return nil if element.subnodes.empty?
+        element.subnodes.each do |child|
+          parse_descriptions(child, parent, element.ns_name, &block)
+        end
+      end
+      
+      ##
+      # [-]
+      ##
+      def parse_nested_property(element, parent, &block)
+        return if property_is_resource?(element, parent, &block)
+        return if property_is_resource_parse_type?(element, parent, &block)
+        return if property_is_literal_parse_type?(element, parent, &block)
+        return if property_has_subnodes?(element, parent, &block)
+
+    		# Checks if property has xml:lang
+        att = element.attribute_with_ns('lang', 'http://www.w3.org/XML/1998/namespacelang')
+        language = (att.nil? ? nil : att.value)
+        
+    		# Checks if property has rdf:datatype
+        att = element.attribute_with_ns('datatype', RDF.to_uri.to_s)
+        datatype = (att.nil? ? nil : att.value)
+        
+        object = RDF::Literal.new(element.content, {
+          :datatype => datatype,
+          :language => language })
+
+        block.call([parent, element.ns_name, object])
+
+      end
+
+      ##
+      # [-]
+      ##
+      def parse_inline_properties(element)
+        element.attributes.values.map do |att|
+          case att.ns_name
+            when RDF.about    then [:uri, RDF::URI.new(element.base || uri).join(att.value)]
+            when RDF.ID       then [:uri, RDF::URI.new(element.base || att.value).join(att.value)]
+            when RDF.nodeID   then [:uri, RDF::Node.new(att.value)]
+            else [att.ns_name, att.value]
+          end
+        end
+      end
+      
+    end # Reader
+  end # XML
+end # RDF
+
+
+module Nokogiri
+  module Common
+    def ns_name
+      RDF::URI.new((namespace.nil? ? '' : namespace.href) + name)
+    end
+  end
+  module XML
+    class Attr
+      include Nokogiri::Common
+    end
+    class Element
+      include Nokogiri::Common
+      def base
+        att = document.root.attributes['base']
+        att.nil? ? '' : att.value
+      end
+      def subnodes
+        children.reject { |child| child.text? }
+      end
+    end
+  end
+end

data/lib/xml/version.rb

@@ -0,0 +1,25 @@
+module RDF
+  module XML
+    module VERSION
+      MAJOR = 0
+      MINOR = 0
+      TINY  = 3
+      EXTRA = nil
+
+      STRING = [MAJOR, MINOR, TINY].join('.')
+      STRING << "-#{EXTRA}" if EXTRA
+
+      ##
+      # @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/xml/writer.rb

@@ -0,0 +1,181 @@
+module RDF
+  module XML
+    class Writer < RDF::Writer
+
+      format RDF::XML::Format
+
+      ##
+      # [-]
+      ##
+      def initialize(output = $stdout, options = {}, &block)
+        @output, @options = output, options
+        @nodes = {}
+        @base = nil
+        @namespaces = { :rdf => RDF.to_uri.to_s }
+        
+        if block_given?
+          yield self
+          write_prologue unless @options[:declaration] == false
+          write_document
+          write_epilogue unless @options[:declaration] == false
+        end
+      end
+      
+      ##
+      # [-]
+      ##
+      def write_prologue
+        
+        ns = @namespaces.map do |short, uri|
+          ' xmlns:%s="%s"' % [short, uri]
+        end.join('')
+        
+        unless @base.nil?
+          bs = ' xml:base="%s"' % @base
+        end
+        
+        puts ("<?xml version='1.0' encoding='utf-8'?><rdf:RDF %s %s>" % [ns, bs], false)
+      end
+      
+      def write_epilogue
+        puts "</rdf:RDF>"
+      end
+
+      ##
+      # [-]
+      ##
+      def write_document
+        @nodes.each do |id, atts|
+          puts format_description(id, atts)
+        end
+      end
+
+      ##
+      # [-]
+      ##
+      def write_triple(subject, predicate, object)
+        s = subject.to_s
+        p = predicate.to_s
+        @nodes[s]    ||= {}
+        @nodes[s][p] ||= []
+        @nodes[s][p] << object
+      end
+      
+      ##
+      # [-]
+      ##
+      def namespace!(uri, short)
+        @namespaces[short.to_s.to_sym] = uri.to_s
+      end
+      
+      ##
+      # [-]
+      ##
+      def base!(uri)
+        @base = uri.to_s
+      end
+      
+      private
+
+      
+      ##
+      # [-]
+      ##
+      def format_description(id, atts)
+        tag       = format_tag_name(atts)
+        contents  = format_attributes(atts)
+        about     = ' rdf:about="%s"' % id
+        "<%s%s>%s</%s>" % [tag, about, contents, tag]
+      end
+      
+      ##
+      # [-]
+      ##
+      def format_tag_name(atts)
+        if atts.key?(RDF.type.to_s)
+          atts.delete(RDF.type.to_s).first
+        else
+          "rdf:Description"
+        end
+      end
+      
+      ##
+      # [-]
+      ##
+      def format_attributes(atts)
+        atts.map do |predicate, values|
+          values.map do |value|
+            format_attribute(predicate, value)
+          end.join('')
+        end.join('')
+      end
+      
+      ##
+      # [-]
+      ##
+      def format_attribute(predicate, value)
+        if value.kind_of? RDF::Resource
+          format_resource_att(predicate, value)
+        elsif value.kind_of? Literal
+          format_literal_att(predicate, value)
+        end
+      end
+      
+      ##
+      # [-]
+      ##
+      def format_resource_att(predicate, value)
+        '<%s rdf:resource="%s" />' % [predicate, value.to_s]
+      end
+
+      ##
+      # [-]
+      ##
+      def format_literal_att(predicate, value)
+        extra = ""
+        if value.has_datatype?
+          extra += ' rdf:datatype="%s"' % value.datatype.to_s
+        end
+        if value.has_language?
+          extra += ' xml:lang="%s"' % value.language.to_s
+        end
+        if value.kind_of? RDF::Literal
+          value = value.object
+        end
+        '<%s%s>%s</%s>' % [predicate, extra, value, predicate]
+      end
+      
+      ##
+      # [-]
+      ##
+      def adjust_ns(string)
+        @namespaces.each do |short, uri|
+          string = string.gsub(uri, "%s:" % short)
+        end
+        string
+      end
+      
+      ##
+      # [-]
+      ##
+      def adjust_base(string)
+        unless @base.nil?
+          string = string.gsub(@base, '')
+        end
+        string
+      end
+      
+      ##
+      # [-]
+      ##
+      def puts(string, adjust = true)
+        if adjust
+          string = adjust_ns(string)
+          string = adjust_base(string)
+        end
+        @output.puts(string)
+      end
+      
+    end # Writer
+  end # XML
+end # RDF

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: rdf-xml
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- Alex Serebryakov
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-26 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rdf
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 1
+        version: 0.1.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 4
+        - 1
+        version: 1.4.1
+  type: :runtime
+  version_requirements: *id003
+description: An RDF.rb plugin for XML files.
+email: serebryakov@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- UNLICENSE
+- VERSION
+- lib/rdf-xml.rb
+- lib/xml/format.rb
+- lib/xml/reader.rb
+- lib/xml/version.rb
+- lib/xml/writer.rb
+has_rdoc: true
+homepage: http://github.com/42cities/rdf-xml/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rdf-xml
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: An RDF.rb plugin for XML files.
+test_files: []
+