rdf-raptor 0.4.2 → 1.0.0.beta1

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

@@ -0,0 +1,143 @@
+module RDF::Raptor::FFI::V2
+  ##
+  # @see http://librdf.org/raptor/api-1.4/raptor-section-triples.html
+  class Statement < ::FFI::Struct
+    include RDF::Raptor::FFI
+    layout  :world, :pointer,
+            :usage, :int,
+            :subject, :pointer,
+            :predicate, :pointer,
+            :object, :pointer,
+            :graph, :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.
+    #
+    # @return [void]
+    def release
+      V2.raptor_free_statement(ptr) unless ptr.null?
+    end
+
+    # @return [Object]
+    attr_accessor :id
+
+    # @return [RDF::Resource]
+    attr_accessor :context
+
+    ##
+    # @return [RDF::Resource]
+    def subject
+      @subject ||= V2::Term.new(self[:subject], @factory).value
+    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] = V2.raptor_new_term_from_blank(V2.world, resource.id.to_s)
+        when RDF::URI
+          self[:subject] = V2.raptor_new_term_from_uri_string(V2.world, resource.to_s)
+        else
+          raise ArgumentError, "subject term must be an RDF::Node or RDF::URI"
+      end
+      @subject = resource
+    end
+
+    ##
+    # @return [RDF::URI]
+    def predicate
+      @predicate ||= V2::Term.new(self[:predicate], @factory).value
+    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] = V2.raptor_new_term_from_uri_string(V2.world, uri.to_s)
+      @predicate = uri
+    end
+
+    ##
+    # @return [RDF::Term]
+    def object
+      @object ||= V2::Term.new(self[:object], @factory).value
+    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] = V2.raptor_new_term_from_blank(V2.world, value.id.to_s)
+        when RDF::URI
+          self[:object] = V2.raptor_new_term_from_uri_string(V2.world, value.to_s)
+        when RDF::Literal
+          self[:object] = V2.raptor_new_term_from_literal(V2.world, value.to_s,
+            value.datatype? ? V2.raptor_new_uri(value.datatype.to_s) : nil,
+            value.language? ? V2.raptor_new_string(value.language.to_s) : nil)
+        else
+          raise ArgumentError, "object term must be an RDF::Node, RDF::URI, or RDF::Literal"
+      end
+      @object = value
+    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
+      V2.raptor_free_statement(self)
+      @subject = @predicate = @object = nil # Allow GC to start
+    end
+    alias_method :release, :free
+  end # Statement
+end # RDF::Raptor::FFI::V2

data/lib/rdf/raptor/ffi/v2/term.rb

@@ -0,0 +1,95 @@
+module RDF::Raptor::FFI::V2
+  ##
+  # @see http://librdf.org/raptor/api-1.4/raptor-section-triples.html
+  class Term < ::FFI::Struct
+    include RDF::Raptor::FFI
+    
+    class LiteralValue < ::FFI::Struct
+      include RDF::Raptor::FFI
+      
+      layout  :string, :string,
+              :string_len, :int,
+              :datatype, :pointer,
+              :language, :string,
+              :language_len, :char
+      
+      def to_str
+        self[:string].unpack('U*').pack('U*')
+      end
+      
+      def language
+        unless self[:language].nil? or self[:language].empty?
+          self[:language]
+        end
+      end
+      
+      def datatype
+        if self[:datatype] && !self[:datatype].null?
+          RDF::URI.intern(V2.raptor_uri_to_string(self[:datatype]))
+        end
+      end
+      
+      def to_rdf
+        str = self.to_str
+        case
+          when language = self.language
+            RDF::Literal.new(str, :language => language)
+          when datatype = self.datatype
+            RDF::Literal.new(str, :datatype => datatype)
+          else
+            RDF::Literal.new(str)
+        end
+      end
+    end
+    
+    class BlankValue < ::FFI::Struct
+      layout :string, :string,
+              :string_len, :int
+      
+      def to_str
+        self[:string]
+      end
+    end
+
+    class Value < ::FFI::Union
+      include RDF::Raptor::FFI
+      
+      layout :uri, :pointer,
+             :literal, LiteralValue,
+             :blank, BlankValue
+    end
+
+    layout  :world, :pointer,
+            :usage, :int,
+            :type, :int,
+            :value, Value
+    ##
+    # @param  [FFI::Pointer] ptr
+    # @param  [#create_node] factory
+    def initialize(ptr = nil, factory = nil)
+      super(ptr)
+      @factory = factory if factory
+    end
+    
+    def value
+      case self[:type]
+        when RAPTOR_TERM_TYPE_BLANK
+          @factory.create_node(self[:value][:blank].to_str)
+        when RAPTOR_TERM_TYPE_URI
+          @factory.create_uri(V2.raptor_uri_as_string(self[:value][:uri]))
+        when RAPTOR_TERM_TYPE_LITERAL
+          self[:value][:literal].to_rdf
+      end
+    end
+
+    ##
+    # Releases `libraptor` memory associated with this structure.
+    #
+    # @param  [FFI::Pointer] ptr
+    # @return [void]
+    def release
+      V2.raptor_free_term(self) unless ptr.null?
+    end
+    
+  end # Term
+end # RDF::Raptor::FFI::V2

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

@@ -0,0 +1,111 @@
+module RDF::Raptor::FFI::V2
+  ##
+  # 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 V2.raptor_new_uri(V2.world, ptr_or_name.to_s)
+        when String       then V2.raptor_new_uri(V2.world, 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)
+      V2.raptor_free_uri(ptr)
+    end
+
+    ##
+    # @return [Boolean] `true`
+    def uri?
+      true
+    end
+
+    ##
+    # @return [URI] a copy of `self`
+    def dup
+      copy = self.class.new(V2.raptor_uri_copy(self))
+      copy.taint if tainted?
+      copy
+    end
+
+    ##
+    # @return [URI] a copy of `self`
+    def clone
+      copy = self.class.new(V2.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
+          !(V2.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) && !(V2.raptor_uri_equals(self, other).zero?)
+    end
+
+    ##
+    # @return [Fixnum]
+    def hash
+      to_str.hash
+    end
+
+    ##
+    # @return [String] the URI string
+    def to_str
+      V2.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::V2

data/lib/rdf/raptor/ffi/v2/world.rb

@@ -0,0 +1,20 @@
+module RDF::Raptor::FFI::V2
+  class World < ::FFI::AutoPointer
+    include RDF::Raptor::FFI
+
+    def initialize()
+      ptr = V2.raptor_new_world_internal(V2.raptor_version_decimal)
+      super(ptr, self.class.method(:release))
+    end
+
+    ##
+    # Releases `libraptor` memory associated with this structure.
+    #
+    # @param  [FFI::Pointer] ptr
+    # @return [void]
+    def self.release(ptr)
+      V2.raptor_free_world(ptr)
+    end
+
+  end # World
+end # RDF::Raptor::FFI::V2

data/lib/rdf/raptor/ffi/v2.rb

@@ -0,0 +1,156 @@
+module RDF::Raptor::FFI
+  ##
+  # A foreign-function interface (FFI) to `libraptor` 2.x.
+  #
+  # @see http://librdf.org/raptor/libraptor.html
+  module V2
+    autoload :IOStream,        'rdf/raptor/ffi/v2/iostream'
+    autoload :IOStreamHandler, 'rdf/raptor/ffi/v2/iostream_handler'
+    autoload :Parser,          'rdf/raptor/ffi/v2/parser'
+    autoload :Serializer,      'rdf/raptor/ffi/v2/serializer'
+    autoload :Statement,       'rdf/raptor/ffi/v2/statement'
+    autoload :URI,             'rdf/raptor/ffi/v2/uri'
+    autoload :Term,            'rdf/raptor/ffi/v2/term'
+    autoload :World,           'rdf/raptor/ffi/v2/world'
+
+    extend ::FFI::Library
+    ffi_lib RDF::Raptor::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_TERM_TYPE_UNKNOWN  = 0
+    RAPTOR_TERM_TYPE_URI      = 1
+    RAPTOR_TERM_TYPE_LITERAL  = 2
+    RAPTOR_TERM_TYPE_BLANK    = 4
+
+    # @see http://librdf.org/raptor/api/tutorial-initialising-finishing.html
+    typedef :pointer, :raptor_world
+    typedef :int, :raptor_version
+    attach_function :raptor_new_world_internal, [:raptor_version], :raptor_world
+    attach_function :raptor_free_world, [], :void
+    attach_function :raptor_alloc_memory, [:size_t], :pointer
+    attach_function :raptor_calloc_memory, [:size_t, :size_t], :pointer
+    attach_function :raptor_free_memory, [:pointer], :void
+
+    # @see http://librdf.org/raptor/api-1.4/raptor-section-locator.html
+    typedef :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/raptor2-section-general.html
+    attach_variable :raptor_version_string, :string
+    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-1.4/raptor-section-uri.html
+    typedef :pointer, :raptor_uri
+    attach_function :raptor_new_uri, [:raptor_world, :string], :raptor_uri
+    attach_function :raptor_uri_copy, [:raptor_uri], :raptor_uri
+    attach_function :raptor_uri_equals, [:raptor_uri, :raptor_uri], :int
+    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/raptor2-section-triples.html
+    typedef :int,     :raptor_identifier_type
+    typedef :pointer, :raptor_identifier
+    typedef :pointer, :raptor_statement
+    attach_function :raptor_statement_compare, [:raptor_statement, :raptor_statement], :int
+    attach_function :raptor_statement_print, [:raptor_statement, :pointer], :void
+    attach_function :raptor_statement_print_as_ntriples, [:pointer, :pointer], :void
+    #attach_function :raptor_statement_part_as_string, [:pointer, :raptor_identifier_type, :raptor_uri, :pointer], :string
+    attach_function :raptor_free_statement, [:raptor_statement], :void
+    typedef :pointer, :raptor_term
+    typedef :string, :literal
+    typedef :pointer, :datatype
+    typedef :string, :language
+    typedef :string, :blank
+    attach_function :raptor_new_term_from_uri, [:raptor_world, :raptor_uri], :raptor_term
+    attach_function :raptor_new_term_from_uri_string, [:raptor_world, :string], :raptor_term
+    attach_function :raptor_new_term_from_literal, [:raptor_world, :literal, :datatype, :language], :raptor_term
+    attach_function :raptor_new_term_from_blank, [:raptor_world, :blank], :raptor_term
+    attach_function :raptor_free_term, [:raptor_term], :void
+
+    # @see http://librdf.org/raptor/api/raptor2-section-parser.html
+    callback :raptor_statement_handler, [:pointer, :raptor_statement], :void
+    typedef :pointer, :raptor_parser
+    typedef :string, :mime_type
+    typedef :string, :buffer
+    attach_function :raptor_new_parser, [:raptor_world, :string], :raptor_parser
+    attach_function :raptor_world_guess_parser_name, [:raptor_world, :raptor_uri, :mime_type, :buffer, :size_t, :string], :string
+    #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_parser_set_statement_handler, [:raptor_parser, :pointer, :raptor_statement_handler], :void
+    attach_function :raptor_parser_parse_file, [:raptor_parser, :raptor_uri, :raptor_uri], :int
+    attach_function :raptor_parser_parse_file_stream, [:raptor_parser, :pointer, :string, :raptor_uri], :int
+    attach_function :raptor_parser_parse_uri, [:raptor_parser, :raptor_uri, :raptor_uri], :int
+    attach_function :raptor_parser_parse_start, [:raptor_parser, :raptor_uri], :int
+    attach_function :raptor_parser_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_parser_parse_abort, [], :void
+    attach_function :raptor_free_parser, [:raptor_parser], :void
+
+    # @see http://librdf.org/raptor/api/raptor2-section-iostream.html
+    typedef :pointer, :raptor_iostream
+    attach_function :raptor_new_iostream_from_handler, [:raptor_world, :pointer, :pointer], :raptor_iostream
+    attach_function :raptor_new_iostream_to_filename, [:raptor_world, :string], :raptor_iostream
+    attach_function :raptor_new_iostream_to_sink, [:raptor_world], :raptor_iostream
+    attach_function :raptor_free_iostream, [:raptor_iostream], :void
+    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
+
+    # @see http://librdf.org/raptor/api-1.4/raptor-section-xml-namespace.html
+    typedef :pointer, :raptor_namespace
+
+    # @see http://librdf.org/raptor/api/raptor2-section-serializer.html
+    typedef :pointer, :raptor_serializer
+    attach_function :raptor_new_serializer, [:raptor_world, :string], :raptor_serializer
+    attach_function :raptor_free_serializer, [:raptor_serializer], :void
+    attach_function :raptor_serializer_start_to_iostream, [:raptor_serializer, :raptor_uri, :raptor_iostream], :int
+    attach_function :raptor_serializer_start_to_filename, [:raptor_serializer, :string], :int
+    attach_function :raptor_serializer_serialize_statement, [:raptor_serializer, :raptor_statement], :int
+    attach_function :raptor_serializer_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 reference counts.
+    @world = nil
+    def self.world
+      @world ||= World.new
+    end
+
+    ##
+    # Allocates memory for the string `str` inside `libraptor`, copying the
+    # string into the newly-allocated buffer.
+    #
+    # The buffer should later be deallocated using `raptor_free_string`.
+    #
+    # @return [FFI::Pointer]
+    def raptor_new_string(str)
+      ptr = V2.raptor_alloc_memory(str.bytesize + 1)
+      ptr.put_string(0, str)
+      ptr
+    end
+    module_function :raptor_new_string
+
+    alias_method :raptor_free_string, :raptor_free_memory
+    module_function :raptor_free_string
+
+  end # v2
+end # RDF::Raptor::FFI

data/lib/rdf/raptor/ffi.rb

@@ -9,6 +9,7 @@ module RDF::Raptor
   # @see http://librdf.org/raptor/libraptor.html
   module FFI
     autoload :V1, 'rdf/raptor/ffi/v1'
+    autoload :V2, 'rdf/raptor/ffi/v2'
 
     ENGINE = :ffi
 
@@ -21,9 +22,7 @@ module RDF::Raptor
     #
     # @return [String] an "x.y.z" version string
     def version
-      [V1.raptor_version_major,
-       V1.raptor_version_minor,
-       V1.raptor_version_release].join('.').freeze
+      V2.raptor_version_string.freeze
     end
 
     ##
@@ -41,26 +40,26 @@ module RDF::Raptor
       # @yieldreturn [void] ignored
       def initialize(input = $stdin, options = {}, &block)
         @format = self.class.format.rapper_format
-        @parser = V1::Parser.new(@format)
+        @parser = V2::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.raptor_locator_line(locator)
+        line = V2.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.raptor_locator_line(locator)
+        # line = V2.raptor_locator_line(locator)
         # $stderr.puts line > -1 ? "Line #{line}: #{message}" : message
       end
 
       ##
       # The Raptor parser instance.
       #
-      # @return [V1::Parser]
+      # @return [V2::Parser]
       attr_reader :parser
 
       ##
@@ -73,11 +72,11 @@ module RDF::Raptor
           if options[:raw]
             # this is up to an order of magnitude faster...
             parse(@input) do |parser, statement|
-              block.call(V1::Statement.new(statement, self))
+              block.call(V2::Statement.new(statement, self))
             end
           else
             parse(@input) do |parser, statement|
-              block.call(V1::Statement.new(statement, self).to_rdf)
+              block.call(V2::Statement.new(statement, self).to_rdf)
             end
           end
         end
@@ -93,7 +92,7 @@ module RDF::Raptor
       def each_triple(&block)
         if block_given?
           parse(@input) do |parser, statement|
-            block.call(V1::Statement.new(statement, self).to_triple)
+            block.call(V2::Statement.new(statement, self).to_triple)
           end
         end
         enum_for(:each_triple)
@@ -145,9 +144,9 @@ module RDF::Raptor
       # @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 = V2::Serializer.new(@format)
+        #@serializer.error_handler   = ERROR_HANDLER
+        #@serializer.warning_handler = WARNING_HANDLER
         @serializer.start_to(output, options)
         super
       end
@@ -163,7 +162,7 @@ module RDF::Raptor
       ##
       # The Raptor serializer instance.
       #
-      # @return [V1::Serializer]
+      # @return [V2::Serializer]
       attr_reader :serializer
 
       ##

data/lib/rdf/raptor/format.rb

@@ -19,7 +19,7 @@ module RDF
       end
       
       def detect(sample)
-        parser_name = RDF::Raptor::FFI::V1.raptor_guess_parser_name(nil, nil, sample, sample.length, nil)
+        parser_name = RDF::Raptor::FFI::V2.raptor_world_guess_parser_name(RDF::Raptor::FFI::V2.world, nil, nil, sample, sample.length, nil)
         parser_name == rapper_format.to_s
       end
     end # Format

data/lib/rdf/raptor.rb

@@ -79,7 +79,7 @@ module RDF
   # @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)
+    LIBRAPTOR = ENV['RDF_RAPTOR_LIBPATH'] || 'libraptor2'  unless const_defined?(:LIBRAPTOR)
     RAPPER    = ENV['RDF_RAPTOR_BINPATH'] || 'rapper'     unless const_defined?(:RAPPER)
 
     require 'rdf/raptor/version'