rdf 0.0.5 → 0.0.6

data/lib/rdf/query/solution.rb

@@ -0,0 +1,139 @@
+module RDF class Query
+  ##
+  # An RDF query solution.
+  #
+  # @example Iterating over every binding in the solution
+  #   solution.each_binding  { |name, value| puts value.inspect }
+  #   solution.each_variable { |variable| puts variable.value.inspect }
+  #
+  # @example Iterating over every value in the solution
+  #   solution.each_value    { |value| puts value.inspect }
+  #
+  # @example Checking whether a variable is bound or unbound
+  #   solution.bound?(:title)
+  #   solution.unbound?(:mbox)
+  #
+  # @example Retrieving the value of a bound variable
+  #   solution[:mbox]
+  #   solution.mbox
+  #
+  # @example Retrieving all bindings in the solution as a `Hash`
+  #   solution.to_hash       #=> {:mbox => "jrhacker@example.org", ...}
+  #
+  class Solution
+    undef_method *(instance_methods - %w(__id__ __send__ __class__ __eval__ instance_eval inspect class object_id))
+
+    include Enumerable
+
+    ##
+    # @param  [Hash{Symbol => Value}] bindings
+    def initialize(bindings = {})
+      @bindings = bindings
+    end
+
+    ##
+    # Enumerates over every variable binding in this solution.
+    #
+    # @yield  [name, value]
+    # @yieldparam [Symbol, Value]
+    # @return [Enumerator]
+    def each_binding(&block)
+      @bindings.each(&block)
+    end
+
+    alias_method :each, :each_binding
+
+    ##
+    # Enumerates over every variable name in this solution.
+    #
+    # @yield  [name]
+    # @yieldparam [Symbol]
+    # @return [Enumerator]
+    def each_name(&block)
+      @bindings.each_key(&block)
+    end
+
+    alias_method :each_key, :each_name
+
+    ##
+    # Enumerates over every variable value in this solution.
+    #
+    # @yield  [value]
+    # @yieldparam [Value]
+    # @return [Enumerator]
+    def each_value(&block)
+      @bindings.each_value(&block)
+    end
+
+    ##
+    # Enumerates over every variable in this solution.
+    #
+    # @yield  [variable]
+    # @yieldparam [Variable]
+    # @return [Enumerator]
+    def each_variable(&block)
+      @bindings.each do |name, value|
+        block.call(Variable.new(name, value))
+      end
+    end
+
+    ##
+    # Returns `true` if the variable `name` is bound in this solution.
+    #
+    # @param  [Symbol] name
+    # @return [Boolean]
+    def bound?(name)
+      !unbound?(name)
+    end
+
+    ##
+    # Returns `true` if the variable `name` is unbound in this solution.
+    #
+    # @param  [Symbol] name
+    # @return [Boolean]
+    def unbound?(name)
+      @bindings[name.to_sym].nil?
+    end
+
+    ##
+    # Returns the value of the variable `name`.
+    #
+    # @param  [Symbol] name
+    # @return [Value]
+    def [](name)
+      @bindings[name.to_sym]
+    end
+
+    ##
+    # @return [Array<Array(Symbol, Value)>}
+    def to_a
+      @bindings.to_a
+    end
+
+    ##
+    # @return [Hash{Symbol => Value}}
+    def to_hash
+      @bindings.dup
+    end
+
+    ##
+    # @return [String]
+    def inspect
+      sprintf("#<%s:%#0x(%s)>", self.class.name, object_id, @bindings.inspect)
+    end
+
+    protected
+
+      ##
+      # @param  [Symbol] name
+      # @return [Value]
+      def method_missing(name, *args, &block)
+        if args.empty? && @bindings.has_key?(name.to_sym)
+          @bindings[name.to_sym]
+        else
+          super
+        end
+      end
+
+  end
+end end

data/lib/rdf/query/variable.rb

@@ -0,0 +1,145 @@
+module RDF class Query
+  ##
+  # An RDF query variable.
+  #
+  # @example Creating an unbound variable
+  #   var = RDF::Query::Variable.new(:x)
+  #   var.unbound?   #=> true
+  #   var.value      #=> nil
+  #
+  # @example Unbound variables match any value
+  #   var === 42     #=> true
+  #
+  # @example Creating a bound variable
+  #   var = RDF::Query::Variable.new(:y, 123)
+  #   var.bound?     #=> true
+  #   var.value      #=> 123
+  #
+  # @example Bound variables match only their actual value
+  #   var === 42     #=> false
+  #   var === 123    #=> true
+  #
+  # @example Getting the variable name
+  #   var.named?     #=> true
+  #   var.name       #=> :y
+  #   var.to_sym     #=> :y
+  #
+  # @example Rebinding a variable returns the previous value
+  #   var.bind!(456) #=> 123
+  #   var.value      #=> 456
+  #
+  # @example Unbinding a previously bound variable
+  #   var.unbind!
+  #   var.unbound?   #=> true
+  #
+  # @example Getting the string representation of a variable
+  #   var = RDF::Query::Variable.new(:x)
+  #   var.to_s       #=> "?x"
+  #   var = RDF::Query::Variable.new(:y, 123)
+  #   var.to_s       #=> "?y=123"
+  #
+  class Variable < Value
+    # @return [Symbol] The variable's name.
+    attr_accessor :name
+
+    alias_method :to_sym, :name
+
+    # @return [Value] The variable's value.
+    attr_accessor :value
+
+    ##
+    # @param  [Symbol] name
+    # @param  [Value]  value
+    def initialize(name, value = nil)
+      @name, @value = name.to_sym, value
+    end
+
+    ##
+    # Returns `true` if this variable has a name.
+    #
+    # @return [Boolean]
+    def named?
+      true
+    end
+
+    ##
+    # Returns `true` if this variable is bound.
+    #
+    # @return [Boolean]
+    def bound?
+      !unbound?
+    end
+
+    ##
+    # Returns `true` if this variable is unbound.
+    #
+    # @return [Boolean]
+    def unbound?
+      value.nil?
+    end
+
+    ##
+    # Rebinds this variable to the given `value`.
+    #
+    # @param  [Value] value
+    # @return [Value] The previous value, if any.
+    def bind(value)
+      old_value = self.value
+      self.value = value
+      old_value
+    end
+
+    alias_method :bind!, :bind
+
+    ##
+    # Unbinds this variable, discarding any currently bound value.
+    #
+    # @return [Value] The previous value, if any.
+    def unbind
+      old_value = self.value
+      self.value = nil
+      old_value
+    end
+
+    alias_method :unbind!, :unbind
+
+    ##
+    # Returns this variable as `Hash`.
+    #
+    # @return [Hash{Symbol => Variable}]
+    def variables
+      { name => self }
+    end
+
+    alias_method :to_hash, :variables
+
+    ##
+    # Returns this variable's bindings (if any) as a `Hash`.
+    #
+    # @return [Hash{Symbol => Value}]
+    def bindings
+      unbound? ? {} : { name => value }
+    end
+
+    ##
+    # Compares this variable with the given value.
+    #
+    # @param  [Value] other
+    # @return [Boolean]
+    def ===(other)
+      if unbound?
+        true # match anything when unbound
+      else
+        value === other
+      end
+    end
+
+    ##
+    # Returns a string representation of this variable.
+    #
+    # @return [String]
+    def to_s
+      unbound? ? "?#{name}" : "?#{name}=#{value}"
+    end
+  end
+end end

data/lib/rdf/reader.rb

@@ -4,15 +4,10 @@ module RDF
   #
   # @abstract
   class Reader
-    autoload :NTriples, 'rdf/reader/ntriples'
+    autoload :NTriples, 'rdf/reader/ntriples' # @deprecated
 
     include Enumerable
 
-    @@subclasses       = []
-    @@file_extensions  = {}
-    @@content_types    = {}
-    @@content_encoding = {}
-
     ##
     # Enumerates known RDF reader classes.
     #
@@ -22,24 +17,13 @@ module RDF
       !block_given? ? @@subclasses : @@subclasses.each { |klass| yield klass }
     end
 
-    ##
-    # @return [Hash{String => Symbol}]
-    def self.content_types
-      @@content_types
-    end
-
-    ##
-    # @return [Hash{Symbol => String}]
-    def self.file_extensions
-      @@file_extensions
-    end
-
     ##
     # @param  [Symbol] format
     # @return [Class]
     def self.for(format)
       klass = case format.to_s.downcase.to_sym
-        when :ntriples then RDF::Reader::NTriples
+        when :ntriples then RDF::NTriples::Reader
+        else nil # FIXME
       end
     end
 
@@ -127,23 +111,15 @@ module RDF
 
     private
 
+      @@subclasses = [] # @private
+
       def self.inherited(child) #:nodoc:
         @@subclasses << child
         super
       end
 
-      def self.content_type(type, options = {})
-        @@content_types[type] ||= []
-        @@content_types[type] << self
-
-        if options[:extension]
-          extensions = [options[:extension]].flatten.map { |ext| ext.to_sym }
-          extensions.each { |ext| @@file_extensions[ext] = type }
-        end
-      end
-
-      def self.content_encoding(encoding)
-        @@content_encoding[self] = encoding.to_sym
+      def self.format(klass)
+        # TODO
       end
 
       def lineno

data/lib/rdf/reader/ntriples.rb

@@ -1,86 +1,5 @@
-module RDF class Reader
-  ##
-  # An N-Triples parser.
-  #
-  # @see http://www.w3.org/TR/rdf-testcases/#ntriples
-  class NTriples < Reader
-    content_type 'text/plain', :extension => :nt
-    content_encoding 'ascii'
-
-    protected
-
-      ##
-      # @return [Array, nil]
-      # @see http://www.w3.org/TR/rdf-testcases/#ntrip_grammar
-      def read_triple
-        loop do
-          readline.strip! # EOFError thrown on end of input
-
-          unless blank? || read_comment
-            subject   = read_uriref || read_bnode || fail_subject
-            predicate = read_uriref || fail_predicate
-            object    = read_uriref || read_bnode || read_literal || fail_object
-            return [subject, predicate, object]
-          end
-        end
-      end
-
-      ##
-      # @return [Boolean]
-      # @see http://www.w3.org/TR/rdf-testcases/#ntrip_grammar (comment)
-      def read_comment
-        match(/^#\s*(.*)$/)
-      end
-
-      ##
-      # @return [URI, nil]
-      # @see http://www.w3.org/TR/rdf-testcases/#ntrip_grammar (uriref)
-      def read_uriref
-        if uri = match(/^<([^>]+)>/)
-          RDF::URI.parse(uri)
-        end
-      end
-
-      ##
-      # @return [Node, nil]
-      # @see http://www.w3.org/TR/rdf-testcases/#ntrip_grammar (nodeID)
-      def read_bnode
-        if node_id = match(/^_:([A-Za-z][A-Za-z0-9]*)/)
-          @nodes[node_id] ||= Object.new # TODO: RDF::Node.new
-        end
-      end
-
-      ##
-      # @return [String, Literal, nil]
-      # @see http://www.w3.org/TR/rdf-testcases/#ntrip_grammar (literal)
-      def read_literal
-        if literal = match(/^"((?:\\"|[^"])*)"/)
-          literal = unescaped(literal)
-
-          if language = match(/^@([a-z]+[\-a-z0-9]*)/)
-            # TODO: RDF::Literal.new(literal, :language => language)
-            literal
-          elsif datatype = match(/^(\^\^)/)
-            # TODO: RDF::Literal.new(literal, :type => read_uriref || fail_object)
-            literal
-          else
-            literal # plain string literal
-          end
-        end
-      end
-
-      ##
-      # @param  [String] string
-      # @return [String]
-      # @see http://www.w3.org/TR/rdf-testcases/#ntrip_strings
-      def unescaped(string)
-        ["\t", "\n", "\r", "\"", "\\"].each do |escape|
-          string.gsub!(escape.inspect[1...-1], escape)
-        end
-        string.gsub!(/\\u([0-9A-Fa-f]{4,4})/u) { [$1.hex].pack('U*') }
-        string.gsub!(/\\U([0-9A-Fa-f]{8,8})/u) { [$1.hex].pack('U*') }
-        string
-      end
-
+module RDF
+  class Reader
+    NTriples = RDF::NTriples::Reader # @deprecated
   end
-end end
+end

data/lib/rdf/repository.rb

@@ -150,13 +150,15 @@ module RDF
     ##
     # Queries the repository for RDF statements matching the given pattern.
     #
-    # @param  [Statement, Array(Value)] pattern
+    # @param  [Query, Statement, Array(Value)] pattern
     # @yield  [statement]
     # @yieldparam [Statement]
     # @return [Array<Statement>, nil]
     def query(pattern, &block)
       raise TypeError.new("repository is not readable") unless readable?
       case pattern
+        when Query
+          pattern.execute(self, &block)
         when Array
           query(Statement.new(*pattern), &block)
         when Statement