iq_rdf 0.0.14

data/lib/iq_rdf/collection.rb

@@ -0,0 +1,53 @@
+#   Copyright 2011 Till Schulte-Coerne (innoQ Deutschland GmbH)
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+module IqRdf
+  class Collection
+
+    attr_reader :elements
+
+    def initialize(collection)
+      @elements = []
+      collection.each do |element|
+        element = Literal.new(element) unless element.is_a?(IqRdf::Uri)
+        @elements << element
+      end
+    end
+
+    def to_s(lang = nil)
+      "(#{@elements.map{|e| e.to_s(lang)}.join(" ")})"
+    end
+
+    def build_xml(xml, elements = nil, &block)
+      elements ||= @elements.dup
+      block.call({},
+        lambda {
+          xml.rdf :List do
+            elements.shift.build_xml(xml) do |*args|
+              xml.rdf(:first, *args)
+            end
+            if elements.size > 0
+              build_xml(xml, elements) do |opts, block|
+                xml.rdf :rest, &block
+              end
+            else
+              xml.rdf :rest, "rdf:resource" => Rdf.nil.full_uri
+            end
+          end
+        }
+      )
+    end
+
+  end
+end

data/lib/iq_rdf/document.rb

@@ -0,0 +1,93 @@
+#   Copyright 2011 Till Schulte-Coerne (innoQ Deutschland GmbH)
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+module IqRdf
+  class Document
+
+    def initialize(default_namespace_uri_prefix = nil, *args)
+      options = args.last.is_a?(::Hash) ? args.pop : {}
+      raise ArgumentError, "If given, parameter :lang has to be a Symbol" unless options[:lang].nil? || options[:lang].is_a?(Symbol)
+
+      self.namespaces(:default => default_namespace_uri_prefix) if default_namespace_uri_prefix
+      self.namespaces(:rdf => "http://www.w3.org/1999/02/22-rdf-syntax-ns#")
+
+      @document_language = options[:lang]
+
+      @nodes = []
+    end
+
+    def namespaces(namespaces)
+      raise ArgumentError, "Parameter 'namespaces' has to be a hash" unless namespaces.is_a?(Hash)
+
+      namespaces.each do |name, uri_prefix|
+        uri_prefix = ::URI.parse(uri_prefix)
+        raise ArgumentError, "Parameter 'namespaces' must be im the form {Symbol => URIString, ...}" unless name.is_a? Symbol
+
+        register_namespace(name, uri_prefix)
+      end
+      self
+    end
+
+    def <<(node)
+      return if node.nil?
+      raise ArgumentError, "Node must be an IqRdf::Uri and a Subject!" unless node.is_a?(IqRdf::Uri) and node.is_subject?
+      @nodes << node
+    end
+
+    def to_turtle
+      s = ""
+      @namespaces.values.each do |namespace|
+        s << "@prefix #{namespace.turtle_token}: <#{namespace.uri_prefix}>.\n"
+      end
+      s << "\n"
+      @nodes.each do |node|
+        pref = "#{node.to_s(@document_language)}"
+        if node.rdf_type
+          s << "#{pref} a #{node.rdf_type}"
+          pref = ";\n" + "".ljust(node.to_s(@document_language).length)
+        end
+        node.nodes.each do |predicate|
+          s << "#{pref} #{predicate.to_s} #{predicate.nodes.map{|o| o.to_s(predicate.lang || node.lang || @document_language)}.join(", ")}"
+          pref = ";\n" + "".ljust(node.to_s(@document_language).length)
+        end
+        s << ".\n"
+      end
+      s
+    end
+
+    def to_xml
+      xml = Builder::XmlMarkup.new(:indent => 2)
+      xml.instruct!
+      opts = {}
+      @namespaces.values.each{ |namespace|
+        opts[namespace.token == :default ? "xmlns" : "xmlns:#{namespace.token.to_s}"] = namespace.uri_prefix
+      }
+      opts["xml:lang"] = @document_language if @document_language
+
+      xml.rdf(:RDF, opts) do
+        @nodes.each do |node|
+          node.build_xml(xml)
+        end
+      end
+      xml.target!
+    end
+
+    private
+
+    def register_namespace(name, uri_prefix)
+      (@namespaces ||= {})[name] = IqRdf::Namespace.create(name, uri_prefix)
+    end
+
+  end
+end

data/lib/iq_rdf/literal.rb

@@ -0,0 +1,59 @@
+#   Copyright 2011 Till Schulte-Coerne (innoQ Deutschland GmbH)
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+module IqRdf
+  class Literal
+
+    def initialize(obj, lang = nil)
+      @obj = obj
+      @lang = lang
+    end
+
+    def to_s(lang = nil)
+      lang = @lang || lang # Use the Literals lang when given
+      if @obj.is_a?(URI)
+        "<#{@obj.to_s}>"
+      elsif @obj === true
+        "true"
+      elsif @obj === false
+        "false"
+      elsif @obj.is_a?(Numeric)
+        @obj.to_s
+      else
+        quote = @obj.to_s.include?("\n") ? '"""' : '"'
+        "#{quote}#{@obj.to_s.gsub("\\", "\\\\\\\\").gsub(/"/, "\\\"")}#{quote}#{(lang && lang != :none) ? "@#{lang}" : ""}"
+      end
+    end
+
+    def build_xml(xml, &block)
+      if @obj.is_a?(URI)
+        block.call("rdf:resource" => @obj.to_s)
+      else
+        opts = {}
+        { Integer => "http://www.w3.org/2001/XMLSchema#integer",
+          Float => "http://www.w3.org/2001/XMLSchema#decimal",
+          TrueClass => "http://www.w3.org/2001/XMLSchema#boolean",
+          FalseClass => "http://www.w3.org/2001/XMLSchema#boolean",
+        }.each do |klass, s|
+          opts["rdf:datatype"] = s if @obj.is_a?(klass)
+        end
+        opts["xml:lang"] = @lang if @lang
+        block.call(@obj.to_s, opts)
+      end
+    end
+
+    alias_method :full_uri, :to_s
+
+  end
+end

data/lib/iq_rdf/namespace.rb

@@ -0,0 +1,71 @@
+#   Copyright 2011 Till Schulte-Coerne (innoQ Deutschland GmbH)
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+module IqRdf
+  class Namespace
+
+    # Methods used in child classes
+
+    def self.token
+      self.instance_variable_get(:@token)
+    end
+
+    def self.uri_prefix
+      self.instance_variable_get(:@uri_prefix)
+    end
+
+    def self.turtle_token
+      self.token != :default ? self.token.to_s : ""
+    end
+
+    def self.build_uri(postfix, type = nil, &block)
+      uri = IqRdf::Uri.new(self, postfix, type)
+      if block
+        yield(uri)
+      end
+      uri
+    end
+
+    # Namespace only methods
+    
+    def self.create(token, uri_prefix)
+      klass_name = self.class_name(token)
+      klass = IqRdf.const_defined?(klass_name) ? IqRdf.const_get(klass_name) : IqRdf.const_set(klass_name, Class.new(self))
+      klass.instance_variable_set(:@token, token)
+      klass.instance_variable_set(:@uri_prefix, uri_prefix)
+      klass
+    end
+
+    def self.find_namespace_class(token)
+      klass_name = self.class_name(token)
+      IqRdf.const_get(klass_name) if IqRdf.const_defined?(klass_name)
+    end
+
+    def self.dummy_empty_namespace
+      @dummy_empty_namespace ||= Class.new(self)
+    end
+
+    protected
+
+    def self.method_missing(method_name, *args, &block)
+      type = args.shift if args[0].is_a?(IqRdf::Uri)
+      self.build_uri(method_name, type, &block)
+    end
+
+    def self.class_name(name)
+      name.to_s.gsub(/(^|_)(.)/) { $2.upcase }
+    end
+  
+  end
+end

data/lib/iq_rdf/node.rb

@@ -0,0 +1,57 @@
+#   Copyright 2011 Till Schulte-Coerne (innoQ Deutschland GmbH)
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+module IqRdf
+  class Node
+    attr_reader :nodes
+    attr_reader :lang
+
+    def initialize(lang = nil)
+      @nodes = []
+      @lang = lang
+    end
+
+    # You can add Nodes (Uris, Blank Nodes, Predicates), Literals and Collections
+    # So a Node has the following structure:
+    #  <node> <uri> or <node> <literal> (tuple)
+    #  <node> <predicate> == <node> (<predicate_node> <predicate.nodes>) (triples)
+    def <<(node)
+      raise ArgumentError, "#{node.inspect} is no IqRdf::Node or a IqRdf::Literal or a IqRdf::Collection" unless node.is_a?(IqRdf::Node) || node.is_a?(IqRdf::Literal) || node.is_a?(IqRdf::Collection)
+      @nodes << node
+    end
+
+    def method_missing(method_name, *args, &block)
+      if (namespace_class = Namespace.find_namespace_class(method_name))
+        return IqRdf::PredicateNamespace.new(self, namespace_class) # some_node.>namespace<...
+      else
+        return IqRdf::PredicateNamespace.new(self, IqRdf::Default).build_predicate(method_name, *args, &block) # some_node.>predicate<()
+      end
+    end
+
+    def is_subject?()
+      false
+    end
+
+    def build_full_uri_predicate(uri, *args, &block)
+      raise ArgumentError, "uri musst be an ::URI" unless uri.is_a?(::URI)
+
+      IqRdf::PredicateNamespace.new(self, Namespace.dummy_empty_namespace).build_predicate(uri, *args, &block)
+    end
+
+    def xml_lang
+      @lang && (@lang == :none ? "" : @lang)
+    end
+
+  end
+end

data/lib/iq_rdf/plain_turtle_literal.rb

@@ -0,0 +1,30 @@
+#   Copyright 2011 Till Schulte-Coerne (innoQ Deutschland GmbH)
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+module IqRdf
+  # This is a dummy class for some needs where
+  class PlainTurtleLiteral < Literal
+
+    def initialize(obj)
+      @obj = obj
+    end
+
+    def to_s(lang = nil)
+      @obj.to_s
+    end
+
+    alias_method :full_uri, :to_s
+
+  end
+end

data/lib/iq_rdf/predicate.rb

@@ -0,0 +1,43 @@
+#   Copyright 2011 Till Schulte-Coerne (innoQ Deutschland GmbH)
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+module IqRdf
+  class Predicate < Uri
+
+    attr_reader :subject
+
+    def initialize(namespace, uri_postfix, subject, lang = nil)
+      super(namespace, uri_postfix, nil, lang)
+      @subject = subject
+    end
+
+    def build_xml(xml)
+      raise "XML Output won't work with full URIs as predicates yet" unless namespace.token # There is a dummy_empty_namespace without token => postfix is a full uri!
+      nodes.each do |node|
+        node.build_xml(xml) do |*args|
+          block = args.pop if args.last.is_a?(Proc)
+          params = namespace.token == :default ? [self.uri_postfix.to_s] : [namespace.token.to_s, self.uri_postfix.to_sym]
+          params += args
+          params << {"xml:lang" => xml_lang} if xml_lang
+          if block
+            xml.tag!(*params, &block)
+          else
+            xml.tag!(*params)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/iq_rdf/predicate_namespace.rb

@@ -0,0 +1,63 @@
+#   Copyright 2011 Till Schulte-Coerne (innoQ Deutschland GmbH)
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+module IqRdf
+  class PredicateNamespace
+
+    def initialize(subject, namespace)
+      @subject = subject
+      @predicate_namespace = namespace
+    end
+
+    def build_predicate(postfix, *args, &block)
+      options = args.last.is_a?(::Hash) ? args.pop : {}
+      objects = args
+      predicate = IqRdf::Predicate.new(@predicate_namespace, postfix, @subject, options[:lang])
+      if (block)
+        raise ArgumentError, "A predicate may either have agruments or a block, ot both." if objects.size > 0
+        blank_node = IqRdf::BlankNode.new
+        yield blank_node
+        predicate << blank_node
+      else
+        return nil if options[:suppress_if_empty] === true && objects.size == 0
+        raise ArgumentError, "At least one object is required in predicate call" if objects.size == 0
+        objects.each do |o|
+          if o.is_a?(Array)
+            return nil if options[:suppress_if_empty] === true && o.size == 0
+            o = IqRdf::Collection.new(o)
+          elsif o.is_a?(IqRdf::Node)
+            raise ArgumentError, "Objects may not have nested triples in this Implementation of RDF" if o.is_subject?
+          elsif o.is_a?(Literal)
+            # We're already done
+          elsif o.is_a?(Symbol)
+            o = IqRdf::Default.build_uri(o)
+          else
+            return nil if options[:suppress_if_empty] === true && (o.nil? || o === "")
+            o = Literal.new(o)
+          end
+          predicate << o
+        end
+      end
+      @subject << predicate
+      @subject
+    end
+
+    protected
+
+    def method_missing(method_name, *args)
+      build_predicate(method_name, *args)
+    end
+
+  end
+end