rdf-raptor 0.4.0 → 0.4.1

data/lib/rdf/raptor/ffi/v1/serializer.rb

@@ -0,0 +1,128 @@
+module RDF::Raptor::FFI::V1
+  ##
+  # This class provides the functionality of turning RDF triples into
+  # syntaxes - RDF serializing.
+  #
+  # @see http://librdf.org/raptor/api-1.4/raptor-section-serializer.html
+  class Serializer < ::FFI::ManagedStruct
+    include RDF::Raptor::FFI
+    layout :world, :pointer # the actual layout is private
+
+    ##
+    # @overload initialize(ptr)
+    #   @param  [FFI::Pointer] ptr
+    #
+    # @overload initialize(name)
+    #   @param  [Symbol, String] name
+    #
+    def initialize(ptr_or_name)
+      ptr = case ptr_or_name
+        when FFI::Pointer then ptr_or_name
+        when Symbol       then V1.raptor_new_serializer(ptr_or_name.to_s)
+        when String       then V1.raptor_new_serializer(ptr_or_name)
+        else nil
+      end
+      raise ArgumentError, "invalid argument: #{ptr_or_name.inspect}" if ptr.nil? || ptr.null?
+      super(ptr)
+    end
+
+    ##
+    # Releases `libraptor` memory associated with this structure.
+    #
+    # @param  [FFI::Pointer] ptr
+    # @return [void]
+    def self.release(ptr)
+      V1.raptor_free_serializer(ptr)
+    end
+
+    ##
+    # @param  [Proc] handler
+    # @return [void]
+    def error_handler=(handler)
+      V1.raptor_serializer_set_error_handler(self, self, handler)
+    end
+
+    ##
+    # @param  [Proc] handler
+    # @return [void]
+    def warning_handler=(handler)
+      V1.raptor_serializer_set_warning_handler(self, self, handler)
+    end
+
+    ##
+    # @param  [Object] output
+    #   where output should be written to
+    # @param  [Hash{Symbol => Object}] options
+    #   any additional options for serializing
+    # @option options [String, #to_s] :base_uri (nil)
+    #   the base URI to use when resolving relative URIs
+    # @return [void]
+    def start_to(output, options = {})
+      case output
+        when IO, StringIO
+          start_to_stream(output, options)
+        else
+          raise ArgumentError, "don't know how to serialize to #{output.inspect}"
+      end
+    end
+
+    ##
+    # @param  [IO, StringIO] stream
+    # @param  [Hash{Symbol => Object}] options
+    #   any additional options for serializing (see {#start_to})
+    # @return [void]
+    def start_to_stream(stream, options = {})
+      iostream = V1::IOStream.new(V1::IOStreamHandler.new(stream))
+      start_to_iostream(iostream, options)
+    end
+
+    ##
+    # @param  [V1::IOStream] iostream
+    # @param  [Hash{Symbol => Object}] options
+    #   any additional options for serializing (see {#start_to})
+    # @return [void]
+    def start_to_iostream(iostream, options = {})
+      @iostream = iostream # prevents premature GC
+      @base_uri = options[:base_uri].to_s.empty? ? nil : V1::URI.new(options[:base_uri].to_s)
+      if V1.raptor_serialize_start_to_iostream(self, @base_uri, @iostream).nonzero?
+        raise RDF::WriterError, "raptor_serialize_start_to_iostream() failed"
+      end
+    end
+
+    ##
+    # @return [void]
+    def finish
+      if V1.raptor_serialize_end(self).nonzero?
+        raise RDF::WriterError, "raptor_serialize_end() failed"
+      end
+      @iostream = @base_uri = nil # allows GC
+    end
+
+    ##
+    # @param  [RDF::Resource] subject
+    # @param  [RDF::URI]      predicate
+    # @param  [RDF::Term]     object
+    # @return [void]
+    def serialize_triple(subject, predicate, object)
+      raptor_statement = V1::Statement.new
+      raptor_statement.subject   = subject
+      raptor_statement.predicate = predicate
+      raptor_statement.object    = object
+      begin
+        serialize_raw_statement(raptor_statement)
+      ensure
+        raptor_statement.release
+        raptor_statement = nil
+      end
+    end
+
+    ##
+    # @param  [V1::Statement] statement
+    # @return [void]
+    def serialize_raw_statement(statement)
+      if V1.raptor_serialize_statement(self, statement).nonzero?
+        raise RDF::WriterError, "raptor_serialize_statement() failed"
+      end
+    end
+  end # Serializer
+end # RDF::Raptor::FFI::V1

data/lib/rdf/raptor/ffi/v1/statement.rb

@@ -0,0 +1,233 @@
+module RDF::Raptor::FFI::V1
+  ##
+  # @see http://librdf.org/raptor/api-1.4/raptor-section-triples.html
+  class Statement < ::FFI::Struct
+    include RDF::Raptor::FFI
+    layout :subject, :pointer,
+           :subject_type, :int,
+           :predicate, :pointer,
+           :predicate_type, :int,
+           :object, :pointer,
+           :object_type, :int,
+           :object_literal_datatype, :pointer,
+           :object_literal_language, :pointer
+
+    ##
+    # @param  [FFI::Pointer] ptr
+    # @param  [#create_node] factory
+    def initialize(ptr = nil, factory = nil)
+      super(ptr)
+      @factory = factory if factory
+    end
+
+    ##
+    # Releases `libraptor` memory associated with this structure.
+    #
+    # @param  [FFI::Pointer] ptr
+    # @return [void]
+    def self.release(ptr)
+      raptor_free_memory(ptr) unless ptr.null?
+    end
+
+    # @return [Object]
+    attr_accessor :id
+
+    # @return [RDF::Resource]
+    attr_accessor :context
+
+    ##
+    # @return [RDF::Resource]
+    def subject
+      @subject ||= case self[:subject_type]
+        when RAPTOR_IDENTIFIER_TYPE_ANONYMOUS
+          @factory.create_node(self[:subject].read_string)
+        when RAPTOR_IDENTIFIER_TYPE_RESOURCE
+          @factory.create_uri(V1.raptor_uri_as_string(self[:subject]))
+      end
+    end
+
+    ##
+    # Sets the subject term from an `RDF::Resource`.
+    #
+    # @param  [RDF::Resource] value
+    # @return [void]
+    def subject=(resource)
+      @subject = nil
+      case resource
+        when RDF::Node
+          self[:subject_type] = RAPTOR_IDENTIFIER_TYPE_ANONYMOUS
+          self[:subject] = V1.raptor_new_string(resource.id.to_s)
+        when RDF::URI
+          self[:subject_type] = RAPTOR_IDENTIFIER_TYPE_RESOURCE
+          self[:subject] = V1.raptor_new_uri(resource.to_s)
+        else
+          raise ArgumentError, "subject term must be an RDF::Node or RDF::URI"
+      end
+      @subject = resource
+    end
+
+    ##
+    # @return [String]
+    def subject_as_string
+      V1.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.raptor_uri_as_string(self[:predicate]))
+      end
+    end
+
+    ##
+    # Sets the predicate term from an `RDF::URI`.
+    #
+    # @param  [RDF::URI] value
+    # @return [void]
+    def predicate=(uri)
+      @predicate = nil
+      raise ArgumentError, "predicate term must be an RDF::URI" unless uri.is_a?(RDF::URI)
+      self[:predicate_type] = RAPTOR_IDENTIFIER_TYPE_RESOURCE
+      self[:predicate] = V1.raptor_new_uri(uri.to_s)
+      @predicate = uri
+    end
+
+    ##
+    # @return [String]
+    def predicate_as_string
+      V1.raptor_statement_part_as_string(
+        self[:predicate],
+        self[:predicate_type],
+        nil, nil)
+    end
+
+    ##
+    # @return [RDF::Term]
+    def object
+      @object ||= case self[:object_type]
+        when RAPTOR_IDENTIFIER_TYPE_ANONYMOUS
+          @factory.create_node(self[:object].read_string)
+        when RAPTOR_IDENTIFIER_TYPE_RESOURCE
+          @factory.create_uri(V1.raptor_uri_as_string(self[:object]))
+        when RAPTOR_IDENTIFIER_TYPE_LITERAL
+          str = self[:object].read_string.unpack('U*').pack('U*')
+          case
+            when !self[:object_literal_language].null?
+              RDF::Literal.new(str, :language => self[:object_literal_language].read_string)
+            when !self[:object_literal_datatype].null?
+              RDF::Literal.new(str, :datatype => V1.raptor_uri_as_string(self[:object_literal_datatype]))
+            else
+              RDF::Literal.new(str)
+          end
+      end
+    end
+
+    ##
+    # Sets the object term from an `RDF::Term`.
+    #
+    # The value must be one of `RDF::Resource` or `RDF::Literal`.
+    #
+    # @param  [RDF::Term] value
+    # @return [void]
+    def object=(value)
+      @object = nil
+      case value
+        when RDF::Node
+          self[:object_type] = RAPTOR_IDENTIFIER_TYPE_ANONYMOUS
+          self[:object] = V1.raptor_new_string(value.id.to_s)
+        when RDF::URI
+          self[:object_type] = RAPTOR_IDENTIFIER_TYPE_RESOURCE
+          self[:object] = V1.raptor_new_uri(value.to_s)
+        when RDF::Literal
+          self[:object_type] = RAPTOR_IDENTIFIER_TYPE_LITERAL
+          self[:object] = V1.raptor_new_string(value.value)
+          self[:object_literal_datatype] = V1.raptor_new_uri(value.datatype.to_s) if value.datatype
+          self[:object_literal_language] = V1.raptor_new_string(value.language.to_s) if value.language?
+        else
+          raise ArgumentError, "object term must be an RDF::Node, RDF::URI, or RDF::Literal"
+      end
+      @object = value
+    end
+
+    ##
+    # @return [String]
+    def object_as_string
+      V1.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::Term)]
+    # @see    RDF::Statement#to_triple
+    def to_triple
+      [subject, predicate, object]
+    end
+
+    ##
+    # @return [Array(RDF::Resource, RDF::URI, RDF::Term, nil)]
+    # @see    RDF::Statement#to_quad
+    def to_quad
+      [subject, predicate, object, context]
+    end
+
+    ##
+    # @return [RDF::Statement]
+    def to_rdf
+      RDF::Statement.new(subject, predicate, object, :context => context)
+    end
+
+    ##
+    # @return [void]
+    def reset!
+      @subject = @predicate = @object = @context = nil
+    end
+
+    ##
+    # Releases `libraptor` memory associated with this structure.
+    #
+    # @return [void]
+    def free
+      if self[:subject_type].nonzero? && !(self[:subject].null?)
+        self[:subject] = case self[:subject_type]
+          when RAPTOR_IDENTIFIER_TYPE_ANONYMOUS
+            V1.raptor_free_string(self[:subject])
+          when RAPTOR_IDENTIFIER_TYPE_RESOURCE
+            V1.raptor_free_uri(self[:subject])
+        end
+        self[:subject_type] = RAPTOR_IDENTIFIER_TYPE_UNKNOWN
+      end
+
+      if self[:predicate_type].nonzero? && !(self[:predicate].null?)
+        self[:predicate] = V1.raptor_free_uri(self[:predicate])
+        self[:predicate_type] = RAPTOR_IDENTIFIER_TYPE_UNKNOWN
+      end
+
+      if self[:object_type].nonzero? && !(self[:object].null?)
+        self[:object] = case self[:object_type]
+          when RAPTOR_IDENTIFIER_TYPE_ANONYMOUS
+            V1.raptor_free_string(self[:object])
+          when RAPTOR_IDENTIFIER_TYPE_RESOURCE
+            V1.raptor_free_uri(self[:object])
+          when RAPTOR_IDENTIFIER_TYPE_LITERAL
+            V1.raptor_free_string(self[:object])
+            unless self[:object_literal_datatype].null?
+              self[:object_literal_datatype] = V1.raptor_free_uri(self[:object_literal_datatype])
+            end
+            unless self[:object_literal_language].null?
+              self[:object_literal_language] = V1.raptor_free_string(self[:object_literal_language])
+            end
+        end
+        self[:object_type] = RAPTOR_IDENTIFIER_TYPE_UNKNOWN
+      end
+    end
+    alias_method :release, :free
+  end # Statement
+end # RDF::Raptor::FFI::V1

data/lib/rdf/raptor/ffi/v1/uri.rb

@@ -0,0 +1,111 @@
+module RDF::Raptor::FFI::V1
+  ##
+  # Raptor has a `raptor_uri` class which must be used for manipulating and
+  # passing URI references. The default internal implementation uses `char*`
+  # strings for URIs, manipulating them and constructing them.
+  #
+  # @see http://librdf.org/raptor/api-1.4/raptor-section-uri.html
+  class URI < ::FFI::ManagedStruct
+    include RDF::Raptor::FFI
+    include RDF::Resource
+    layout :string, [:char, 1] # a safe dummy layout, since it is \0-terminated
+
+    ##
+    # @overload initialize(ptr)
+    #   @param  [FFI::Pointer] ptr
+    #
+    # @overload initialize(name)
+    #   @param  [RDF::URI, String] name
+    #
+    def initialize(ptr_or_name)
+      ptr = case ptr_or_name
+        when FFI::Pointer then ptr_or_name
+        when RDF::URI     then V1.raptor_new_uri(ptr_or_name.to_s)
+        when String       then V1.raptor_new_uri(ptr_or_name)
+        else nil
+      end
+      raise ArgumentError, "invalid argument: #{ptr_or_name.inspect}" if ptr.nil? || ptr.null?
+      super(ptr)
+    end
+
+    ##
+    # Releases `libraptor` memory associated with this structure.
+    #
+    # @param  [FFI::Pointer] ptr
+    # @return [void]
+    def self.release(ptr)
+      V1.raptor_free_uri(ptr)
+    end
+
+    ##
+    # @return [Boolean] `true`
+    def uri?
+      true
+    end
+
+    ##
+    # @return [URI] a copy of `self`
+    def dup
+      copy = self.class.new(V1.raptor_uri_copy(self))
+      copy.taint if tainted?
+      copy
+    end
+
+    ##
+    # @return [URI] a copy of `self`
+    def clone
+      copy = self.class.new(V1.raptor_uri_copy(self))
+      copy.taint  if tainted?
+      copy.freeze if frozen?
+      copy
+    end
+
+    ##
+    # @return [Integer]
+    def length
+      LibC.strlen(self)
+    end
+    alias_method :size, :length
+
+    ##
+    # @return [Boolean] `true` or `false`
+    def ==(other)
+      return true if self.equal?(other)
+      case other
+        when self.class
+          !(V1.raptor_uri_equals(self, other).zero?)
+        when RDF::URI, String
+          to_str == other.to_str
+        else false
+      end
+    end
+    alias_method :===, :==
+
+    ##
+    # @return [Boolean] `true` or `false`
+    def eql?(other)
+      return true if self.equal?(other)
+      other.is_a?(self.class) && !(V1.raptor_uri_equals(self, other).zero?)
+    end
+
+    ##
+    # @return [Fixnum]
+    def hash
+      to_str.hash
+    end
+
+    ##
+    # @return [String] the URI string
+    def to_str
+      V1.raptor_uri_as_string(self)
+    end
+    alias_method :to_s, :to_str
+
+    ##
+    # @return [RDF::URI]
+    def to_rdf
+      RDF::URI.intern(to_str)
+    end
+    alias_method :to_uri, :to_rdf
+  end # URI
+end # RDF::Raptor::FFI::V1