rdf 0.1.10 → 0.2.0

data/lib/rdf/ntriples/writer.rb

@@ -27,6 +27,90 @@ module RDF::NTriples
   class Writer < RDF::Writer
     format RDF::NTriples::Format
 
+    # @see http://www.w3.org/TR/rdf-testcases/#ntrip_strings
+    ESCAPE_PLAIN = /\A[\x20-\x21\x23-\x5B\x5D-\x7E]*\z/m.freeze
+    ESCAPE_ASCII = /\A[\x00-\x7F]*\z/m.freeze
+
+    ##
+    # @param  [String] string
+    # @return [String]
+    # @see    http://www.w3.org/TR/rdf-testcases/#ntrip_strings
+    def self.escape(string)
+      case
+        when string =~ ESCAPE_PLAIN # a shortcut for the simple case
+          string
+        when string.respond_to?(:ascii_only?) && string.ascii_only?
+          StringIO.open do |buffer|
+            string.each_byte { |u| buffer << escape_ascii(u) }
+            buffer.string
+          end
+        when string.respond_to?(:each_codepoint)
+          StringIO.open do |buffer|
+            string.each_codepoint { |u| buffer << escape_unicode(u) }
+            buffer.string
+          end
+        else # works in Ruby 1.8.x, too
+          StringIO.open do |buffer|
+            string.scan(/./mu) { |c| buffer << escape_unicode(u = c.unpack('U*').first) }
+            buffer.string
+          end
+      end
+    end
+
+    ##
+    # @param  [Integer, #ord] u
+    # @return [String]
+    # @see    http://www.w3.org/TR/rdf-testcases/#ntrip_strings
+    def self.escape_unicode(u)
+      case (u = u.ord)
+        when (0x00..0x7F)        # ASCII 7-bit
+          escape_ascii(u)
+        when (0x80..0xFFFF)      # Unicode BMP
+          escape_utf16(u)
+        when (0x10000..0x10FFFF) # Unicode
+          escape_utf32(u)
+        else
+          raise ArgumentError.new("expected a Unicode codepoint in (0x00..0x10FFFF), but got 0x#{u.to_s(16)}")
+      end
+    end
+
+    ##
+    # @param  [Integer, #ord] u
+    # @return [String]
+    # @see    http://www.w3.org/TR/rdf-testcases/#ntrip_strings
+    def self.escape_ascii(u)
+      case (u = u.ord)
+        when (0x00..0x08) then escape_utf16(u)
+        when (0x09)       then "\\t"
+        when (0x0A)       then "\\n"
+        when (0x0B..0x0C) then escape_utf16(u)
+        when (0x0D)       then "\\r"
+        when (0x0E..0x1F) then escape_utf16(u)
+        when (0x22)       then "\\\""
+        when (0x5C)       then "\\\\"
+        when (0x7F)       then escape_utf16(u)
+        when (0x00..0x7F) then u.chr
+        else
+          raise ArgumentError.new("expected an ASCII character in (0x00..0x7F), but got 0x#{u.to_s(16)}")
+      end
+    end
+
+    ##
+    # @param  [Integer, #ord] u
+    # @return [String]
+    # @see    http://www.w3.org/TR/rdf-testcases/#ntrip_strings
+    def self.escape_utf16(u)
+      sprintf("\\u%04X", u.ord)
+    end
+
+    ##
+    # @param  [Integer, #ord] u
+    # @return [String]
+    # @see    http://www.w3.org/TR/rdf-testcases/#ntrip_strings
+    def self.escape_utf32(u)
+      sprintf("\\U%08X", u.ord)
+    end
+
     ##
     # Returns the serialized N-Triples representation of the given RDF
     # value.
@@ -121,5 +205,11 @@ module RDF::NTriples
           quoted(escaped(literal.to_s))
       end
     end
+
+    ##
+    # @private
+    def escaped(string)
+      self.class.escape(string)
+    end
   end
 end

data/lib/rdf/query.rb

@@ -43,13 +43,13 @@ module RDF
 
     include ::Enumerable
 
-    # @return [Hash{Symbol => Variable}]
+    # @return [Hash{Symbol => RDF::Query::Variable}]
     attr_reader :variables
 
-    # @return [Array<Pattern>]
+    # @return [Array<RDF::Query::Pattern>]
     attr_reader :patterns
 
-    # @return [Array<Hash{Symbol => Value}>] An unordered sequence of query solutions.
+    # @return [Array<Hash{Symbol => RDF::Value}>] An unordered sequence of query solutions.
     attr_accessor :solutions
 
     # @return [Hash]
@@ -81,7 +81,7 @@ module RDF
     # @return [Enumerator]
     def each_solution(&block)
       unless block_given?
-        Enumerator.new(self, :each_solution)
+        enum_for(:each_solution)
       else
         solutions.each do |solution|
           block.call(solution.is_a?(Solution) ? solution : Solution.new(solution))
@@ -138,7 +138,7 @@ module RDF
         raise ArgumentError.new("wrong number of arguments (0 for 1)")
       else
         # TODO: support for descending sort, e.g. order(:s => :asc, :p => :desc)
-        variables.map! { |variable| variable.to_sym }
+        variables.map!(&:to_sym)
         solutions.sort! do |a, b|
           a = variables.map { |variable| a[variable].to_s }
           b = variables.map { |variable| b[variable].to_s }
@@ -157,7 +157,7 @@ module RDF
     # @return [Query]
     def project(*variables)
       unless variables.empty?
-        variables.map! { |variable| variable.to_sym }
+        variables.map!(&:to_sym)
         solutions.each do |bindings|
           bindings.delete_if { |k, v| !variables.include?(k) } # FIXME
         end

data/lib/rdf/query/pattern.rb

@@ -20,19 +20,17 @@ class RDF::Query
     #   @param  [Hash{Symbol => Object}]     options
     #   @option options [Boolean]            :optional  (false)
     def initialize(subject = nil, predicate = nil, object = nil, options = {})
-      case subject
-        when Hash
-          options    = subject
-          subject    = options.delete(:subject)
-          predicate  = options.delete(:predicate)
-          object     = options.delete(:object)
-          initialize(subject, predicate, object, options)
-        else
-          @options   = options || {}
-          @subject   = subject.is_a?(Symbol)   ? Variable.new(subject)   : subject
-          @predicate = predicate.is_a?(Symbol) ? Variable.new(predicate) : predicate
-          @object    = object.is_a?(Symbol)    ? Variable.new(object)    : object
-      end
+      super
+    end
+
+    ##
+    # @private
+    def initialize!
+      @context   = Variable.new(@context)   if @context.is_a?(Symbol)
+      @subject   = Variable.new(@subject)   if @subject.is_a?(Symbol)
+      @predicate = Variable.new(@predicate) if @predicate.is_a?(Symbol)
+      @object    = Variable.new(@object)    if @object.is_a?(Symbol)
+      super
     end
 
     ##
@@ -108,7 +106,7 @@ class RDF::Query
     #
     # @return [Boolean]
     def bound?
-      !variables.empty? && variables.values.all? { |var| var.bound? }
+      !variables.empty? && variables.values.all?(&:bound?)
     end
 
     ##
@@ -124,7 +122,7 @@ class RDF::Query
     #
     # @return [Boolean]
     def unbound?
-      !variables.empty? && variables.values.all? { |var| var.unbound? }
+      !variables.empty? && variables.values.all?(&:unbound?)
     end
 
     ##

data/lib/rdf/query/solution.rb

@@ -22,7 +22,7 @@ class RDF::Query
   #
   class Solution
     # Undefine all superfluous instance methods:
-    undef_method *(instance_methods.map { |s| s.to_sym } - [:__id__, :__send__, :__class__, :__eval__, :object_id, :instance_eval, :inspect, :class, :is_a?])
+    undef_method(*(instance_methods.map(&:to_sym) - [:__id__, :__send__, :__class__, :__eval__, :object_id, :instance_eval, :inspect, :class, :is_a?]))
 
     include Enumerable
 

data/lib/rdf/query/variable.rb

@@ -38,7 +38,9 @@ class RDF::Query
   #   var = RDF::Query::Variable.new(:y, 123)
   #   var.to_s       #=> "?y=123"
   #
-  class Variable < RDF::Value
+  class Variable
+    include RDF::Value
+
     # @return [Symbol] The variable's name.
     attr_accessor :name
 

data/lib/rdf/reader.rb

@@ -35,6 +35,7 @@ module RDF
   # @see RDF::Writer
   class Reader
     extend  ::Enumerable
+    include RDF::Readable
     include ::Enumerable
 
     ##
@@ -148,7 +149,7 @@ module RDF
 
     ##
     # @yield  [triple]
-    # @yieldparam [Array(Value)]
+    # @yieldparam [Array(RDF::Value)]
     # @return [Enumerator]
     def each_triple(&block)
       begin

data/lib/rdf/repository.rb

@@ -41,10 +41,17 @@ module RDF
   #   repository.clear!
   #
   class Repository
+    include RDF::Countable
     include RDF::Enumerable
-    include RDF::Durable
-    include RDF::Mutable
     include RDF::Queryable
+    include RDF::Mutable
+    include RDF::Durable
+
+    ##
+    # Returns the options passed to this repository when it was constructed.
+    #
+    # @return [Hash{Symbol => Object}]
+    attr_reader :options
 
     ##
     # Returns the {URI} of this repository.
@@ -94,10 +101,7 @@ module RDF
       @title   = @options.delete(:title)
 
       # Provide a default in-memory implementation:
-      if self.class.equal?(RDF::Repository)
-        @data = []
-        send(:extend, Implementation)
-      end
+      send(:extend, Implementation) if self.class.equal?(RDF::Repository)
 
       if block_given?
         case block.arity
@@ -128,6 +132,13 @@ module RDF
     ##
     # @see RDF::Repository
     module Implementation
+      ##
+      # @private
+      def self.extend_object(obj)
+        obj.instance_variable_set(:@data, {})
+        super
+      end
+
       ##
       # Returns `true` if this repository supports `feature`.
       #
@@ -143,76 +154,115 @@ module RDF
       end
 
       ##
-      # Returns `false` to indicate that this repository is nondurable.
-      #
-      # @return [Boolean]
-      # @see    RDF::Durable#durable?
+      # @private
+      # @see RDF::Durable#durable?
       def durable?
         false
       end
 
       ##
-      # Returns `true` if this repository contains no RDF statements.
-      #
-      # @return [Boolean]
-      # @see    RDF::Enumerable#empty?
+      # @private
+      # @see RDF::Countable#empty?
       def empty?
         @data.empty?
       end
 
       ##
-      # Returns the number of RDF statements in this repository.
-      #
-      # @return [Integer]
-      # @see    RDF::Enumerable#count
+      # @private
+      # @see RDF::Countable#count
       def count
-        @data.size
+        count = 0
+        @data.each do |c, ss|
+          ss.each do |s, ps|
+            ps.each do |p, os|
+              count += os.size
+            end
+          end
+        end
+        count
       end
 
       ##
-      # Returns `true` if this repository contains the given RDF statement.
-      #
-      # @param  [Statement] statement
-      # @return [Boolean]
-      # @see    RDF::Enumerable#has_statement?
+      # @private
+      # @see RDF::Enumerable#has_statement?
       def has_statement?(statement)
-        @data.include?(statement)
+        s, p, o, c = statement.to_quad
+        @data.has_key?(c) &&
+          @data[c].has_key?(s) &&
+          @data[c][s].has_key?(p) &&
+          @data[c][s][p].include?(o)
       end
 
       ##
-      # Enumerates each RDF statement in this repository.
-      #
-      # @yield  [statement]
-      # @yieldparam [Statement] statement
-      # @return [Enumerator]
-      # @see    RDF::Enumerable#each_statement
-      def each(&block)
-        @data.each(&block)
+      # @private
+      # @see RDF::Enumerable#each_statement
+      def each_statement(&block)
+        if block_given?
+          # Note that to iterate in a more consistent fashion despite
+          # possible concurrent mutations to `@data`, we use `#dup` to make
+          # shallow copies of the nested hashes before beginning the
+          # iteration over their keys and values.
+          @data.dup.each do |c, ss|
+            ss.dup.each do |s, ps|
+              ps.dup.each do |p, os|
+                os.dup.each do |o|
+                  block.call(RDF::Statement.new(s, p, o, :context => c))
+                end
+              end
+            end
+          end
+        else
+          enum_statement
+        end
       end
 
+      alias_method :each, :each_statement
+
       ##
-      # Inserts the given RDF statement into the underlying storage.
-      #
-      # @param  [RDF::Statement] statement
-      # @return [void]
+      # @private
+      # @see RDF::Enumerable#has_context?
+      def has_context?(value)
+        @data.keys.compact.include?(value)
+      end
+
+      ##
+      # @private
+      # @see RDF::Enumerable#each_context
+      def each_context(&block)
+        block_given? ? @data.keys.compact.each(&block) : enum_context
+      end
+
+    protected
+
+      ##
+      # @private
+      # @see RDF::Mutable#insert
       def insert_statement(statement)
-        @data.push(statement.dup) unless @data.include?(statement)
+        unless has_statement?(statement)
+          s, p, o, c = statement.to_quad
+          @data[c] ||= {}
+          @data[c][s] ||= {}
+          @data[c][s][p] ||= []
+          @data[c][s][p] << o
+        end
       end
 
       ##
-      # Deletes the given RDF statement from the underlying storage.
-      #
-      # @param  [RDF::Statement] statement
-      # @return [void]
+      # @private
+      # @see RDF::Mutable#delete
       def delete_statement(statement)
-        @data.delete(statement)
+        if has_statement?(statement)
+          s, p, o, c = statement.to_quad
+          @data[c][s][p].delete(o)
+          @data[c][s].delete(p) if @data[c][s][p].empty?
+          @data[c].delete(s) if @data[c][s].empty?
+          @data.delete(c) if @data[c].empty?
+        end
       end
 
       ##
-      # Deletes all RDF statements from this repository.
-      #
-      # @return [void]
-      # @see    RDF::Mutable#clear
+      # @private
+      # @see RDF::Mutable#clear
       def clear_statements
         @data.clear
       end

data/lib/rdf/util.rb

@@ -0,0 +1,4 @@
+module RDF; module Util
+  autoload :Aliasing, 'rdf/util/aliasing'
+  autoload :Cache,    'rdf/util/cache'
+end; end

data/lib/rdf/util/aliasing.rb

@@ -0,0 +1,51 @@
+module RDF; module Util
+  module Aliasing
+    ##
+    # Helpers for late-bound instance method aliasing.
+    #
+    # Anything that extends this module will obtain an `alias_method` class
+    # method that creates late-bound instance method aliases instead of the
+    # default early-bound aliases created by Ruby's `Module#alias_method`.
+    #
+    # This is useful because RDF.rb mixins typically alias a number of
+    # overridable methods. For example, `RDF::Enumerable#count` has the
+    # aliases `#size` and `#length`. Normally if implementing classes were
+    # to override the default method, the aliased methods would still be
+    # bound to the mixin's original reference implementation rather than the
+    # new overridden method. Mixing in this module into the implementing
+    # class fixes this problem.
+    #
+    # @example Using late-bound aliasing in a module
+    #   module MyModule
+    #     extend RDF::Util::Aliasing::LateBound
+    #   end
+    #
+    # @example Using late-bound aliasing in a class
+    #   class MyClass
+    #     extend RDF::Util::Aliasing::LateBound
+    #   end
+    #
+    # @see   http://en.wikipedia.org/wiki/Name_binding
+    # @since 0.2.0
+    module LateBound
+      ##
+      # Makes `new_name` a late-bound alias of the method `old_name`.
+      #
+      # @example Aliasing the `#count` method to `#size` and `#length`
+      #   alias_method :size,   :count
+      #   alias_method :length, :count
+      #
+      # @param  [Symbol, #to_sym] new_name
+      # @param  [Symbol, #to_sym] old_name
+      # @return [void]
+      # @see    http://ruby-doc.org/core/classes/Module.html#M001653
+      def alias_method(new_name, old_name)
+        new_name, old_name = new_name.to_sym, old_name.to_sym
+        self.__send__(:define_method, new_name) do |*args, &block|
+          __send__(old_name, *args, &block)
+        end
+        return self
+      end
+    end # module LateBound
+  end # module Aliasing
+end; end # module RDF::Util