rdf 0.0.5 → 0.0.6

data/lib/rdf/ntriples/reader.rb

@@ -0,0 +1,87 @@
+module RDF module NTriples
+  ##
+  # N-Triples parser.
+  #
+  # @example Reading N-Triples data
+  #   RDF::NTriples::Reader.open("spec/data/test.nt") do |reader|
+  #     reader.each_statement do |statement|
+  #       puts statement.inspect
+  #     end
+  #   end
+  #
+  # @see http://www.w3.org/TR/rdf-testcases/#ntriples
+  class Reader < RDF::Reader
+    format RDF::NTriples::Format
+
+    ##
+    # @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] ||= RDF::Node.new(node_id)
+      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]*)/)
+          RDF::Literal.new(literal, :language => language)
+        elsif datatype = match(/^(\^\^)/)
+          RDF::Literal.new(literal, :datatype => read_uriref || fail_object)
+        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
+  end
+end end

data/lib/rdf/ntriples/writer.rb

@@ -0,0 +1,50 @@
+module RDF module NTriples
+  ##
+  # N-Triples serializer.
+  #
+  # @see <http://www.w3.org/TR/rdf-testcases/#ntriples>
+  class Writer < RDF::Writer
+    format RDF::NTriples::Format
+
+    ##
+    # @param  [String] text
+    # @return [void]
+    def write_comment(text)
+      puts "# #{text}"
+    end
+
+    ##
+    # @param  [Resource] subject
+    # @param  [URI]      predicate
+    # @param  [Value]    object
+    # @return [void]
+    def write_triple(subject, predicate, object)
+      s = format_uri(subject)
+      p = format_uri(predicate)
+      o = object.kind_of?(RDF::URI) ? format_uri(object) : format_literal(object)
+      puts "%s %s %s ." % [s, p, o]
+    end
+
+    ##
+    # @param  [node] Resource
+    # @return [void]
+    def format_uri(node)
+      "<%s>" % uri_for(node)
+    end
+
+    ##
+    # @param  [String, Literal] literal
+    # @return [void]
+    def format_literal(literal)
+      case literal
+        when RDF::Literal
+          text = quoted(escaped(literal.value))
+          text << "@#{literal.language}" if literal.language
+          text << "^^<#{uri_for(literal.datatype)}>" if literal.datatype
+          text
+        else
+          quoted(escaped(literal.to_s))
+      end
+    end
+  end
+end end

data/lib/rdf/query.rb

@@ -0,0 +1,212 @@
+module RDF
+  ##
+  # An RDF basic graph pattern query.
+  #
+  # @example Filtering solutions using a hash
+  #   query.filter(:author  => RDF::URI.new("http://ar.to/#self"))
+  #   query.filter(:author  => "Arto Bendiken")
+  #   query.filter(:author  => [RDF::URI.new("http://ar.to/#self"), "Arto Bendiken"])
+  #   query.filter(:updated => RDF::Literal.new(Date.today))
+  #
+  # @example Filtering solutions using a block
+  #   query.filter { |solution| solution.author.literal? }
+  #   query.filter { |solution| solution.title =~ /^SPARQL/ }
+  #   query.filter { |solution| solution.price < 30.5 }
+  #   query.filter { |solution| solution.bound?(:date) }
+  #   query.filter { |solution| solution.age.datatype == RDF::XSD.integer }
+  #   query.filter { |solution| solution.name.language == :es }
+  #
+  # @example Reordering solutions based on a variable
+  #   query.order_by(:updated)
+  #   query.order_by(:updated, :created)
+  #
+  # @example Selecting particular variables only
+  #   query.select(:title)
+  #   query.select(:title, :description)
+  #
+  # @example Eliminating duplicate solutions
+  #   query.distinct!
+  #
+  # @example Limiting the number of solutions
+  #   query.offset(25).limit(10)
+  #
+  # @example Counting the number of solutions
+  #   query.count
+  #
+  # @example Iterating over all found solutions
+  #   query.each_solution { |solution| puts solution.inspect }
+  #
+  class Query
+    autoload :Pattern,  'rdf/query/pattern'
+    autoload :Solution, 'rdf/query/solution'
+    autoload :Variable, 'rdf/query/variable'
+
+    include Enumerable
+
+    # @return [Hash{Symbol => Variable}]
+    attr_reader :variables
+
+    # @return [Array<Pattern>]
+    attr_reader :patterns
+
+    # @return [Array<Hash{Symbol => Value}>] An unordered sequence of query solutions.
+    attr_accessor :solutions
+
+    ##
+    # @param  [Hash{Symbol => Object}] options
+    # @yield  [query]
+    # @yieldparam [Query]
+    def initialize(options = {}, &block)
+      @variables = options.delete(:variables) || {}
+      @patterns  = options.delete(:patterns)  || []
+      @solutions = options.delete(:solutions) || []
+      @options   = options
+
+      if block_given?
+        case block.arity
+          when 1 then block.call(self)
+          else instance_eval(&block)
+        end
+      end
+    end
+
+    ##
+    # Enumerates over each query solution.
+    #
+    # @yield  [solution]
+    # @yieldparam [Solution]
+    # @return [Enumerable]
+    def each_solution(&block)
+      solutions.each do |bindings|
+        block.call(Solution.new(bindings))
+      end
+    end
+
+    alias_method :each, :each_solution
+
+    ##
+    # Returns the number of query solutions.
+    #
+    # @return [Integer]
+    def size
+      solutions.size
+    end
+
+    alias_method :count, :size
+
+    ##
+    # Filters the solution sequence by the given criteria.
+    #
+    # @param  [Hash{Symbol => Object}] criteria
+    # @yield  [solution]
+    # @yieldparam  [Solution] solution
+    # @yieldreturn [Boolean]
+    # @return [Query]
+    def filter(criteria = {}, &block)
+      if block_given?
+        solutions.reject! do |bindings|
+          !block.call(Solution.new(bindings))
+        end
+      else
+        solutions.reject! do |bindings|
+          results = criteria.map do |name, value|
+            bindings[name] == value
+          end
+          !results.all?
+        end
+      end
+      self
+    end
+
+    alias_method :filter!, :filter
+
+    ##
+    # Reorders the solution sequence based on `variables`.
+    #
+    # @param  [Enumerable<Symbol>] variables
+    # @return [Query]
+    def order(*variables)
+      if variables.empty?
+        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 }
+        solutions.sort! do |a, b|
+          a = variables.map { |variable| a[variable].to_s }
+          b = variables.map { |variable| b[variable].to_s }
+          a <=> b
+        end
+      end
+      self
+    end
+
+    alias_method :order_by, :order
+
+    ##
+    # Restricts the the solution sequence to the given `variables` only.
+    #
+    # @param  [Enumerable<Symbol>] variables
+    # @return [Query]
+    def project(*variables)
+      unless variables.empty?
+        variables.map! { |variable| variable.to_sym }
+        solutions.each do |bindings|
+          bindings.delete_if { |k, v| !variables.include?(k) }
+        end
+      end
+      self
+    end
+
+    alias_method :select, :project
+
+    ##
+    # Ensures solutions in the solution sequence are unique.
+    #
+    # @return [Query]
+    def distinct
+      solutions.uniq!
+      self
+    end
+
+    alias_method :distinct!, :distinct
+    alias_method :reduced,   :distinct
+    alias_method :reduced!,  :distinct
+
+    ##
+    # Limits the solution sequence to bindings starting from the `start`
+    # offset in the overall solution sequence.
+    #
+    # @param  [Integer] start
+    # @return [Query]
+    def offset(start)
+      slice(start, solutions.size - start)
+    end
+
+    ##
+    # Limits the number of solutions to `length`.
+    #
+    # @param  [Integer] length
+    # @return [Query]
+    def limit(length)
+      slice(0, length)
+    end
+
+    ##
+    # Limits the solution sequence to `length` bindings starting from the
+    # `start` offset in the overall solution sequence.
+    #
+    # @param  [Integer] start
+    # @param  [Integer] length
+    # @return [Query]
+    def slice(start, length)
+      if start < solutions.size
+        solutions.slice!(start, length)
+      else
+        solutions = []
+      end
+      self
+    end
+
+    alias_method :slice!, :slice
+  end
+end

data/lib/rdf/query/pattern.rb

@@ -0,0 +1,152 @@
+module RDF class Query
+  ##
+  # An RDF query pattern.
+  class Pattern < Statement
+    # @return [Hash{Symbol => Object}]
+    attr_reader :options
+
+    ##
+    # @overload initialize(options = {})
+    #   @param  [Hash{Symbol => Object}]     options
+    #   @option options [Variable, Resource] :subject   (nil)
+    #   @option options [Variable, URI]      :predicate (nil)
+    #   @option options [Variable, Value]    :object    (nil)
+    #   @option options [Boolean]            :optional  (false)
+    #
+    # @overload initialize(subject, predicate, object, options = {})
+    #   @param  [Variable, Resource]         subject
+    #   @param  [Variable, URI]              predicate
+    #   @param  [Variable, Value]            object
+    #   @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
+    end
+
+    ##
+    # @param  [Graph, Repository] graph
+    # @return [Enumerator]
+    def execute(graph, &block)
+      graph.query(self) # FIXME
+    end
+
+    ##
+    # Returns `true` if this pattern contains variables.
+    #
+    # @return [Boolean]
+    def variables?
+      subject.is_a?(Variable) ||
+        predicate.is_a?(Variable) ||
+        object.is_a?(Variable)
+    end
+
+    ##
+    # Returns the number of variables in this pattern.
+    #
+    # @return [Integer] (0..3)
+    def variable_count
+      variables.size
+    end
+
+    alias_method :cardinality, :variable_count
+    alias_method :arity,       :variable_count
+
+    ##
+    # Returns all variables in this pattern.
+    #
+    # @return [Hash{Symbol => Variable}]
+    def variables
+      variables = {}
+      variables.merge!(subject.variables)   if subject.is_a?(Variable)
+      variables.merge!(predicate.variables) if predicate.is_a?(Variable)
+      variables.merge!(object.variables)    if object.is_a?(Variable)
+      variables
+    end
+
+    ##
+    # Returns `true` if this pattern contains bindings.
+    #
+    # @return [Boolean]
+    def bindings?
+      !bindings.empty?
+    end
+
+    ##
+    # Returns the number of bindings in this pattern.
+    #
+    # @return [Integer] (0..3)
+    def binding_count
+      bindings.size
+    end
+
+    ##
+    # Returns all bindings in this pattern.
+    #
+    # @return [Hash{Symbol => Value}]
+    def bindings
+      bindings = {}
+      bindings.merge!(subject.bindings)   if subject.is_a?(Variable)
+      bindings.merge!(predicate.bindings) if predicate.is_a?(Variable)
+      bindings.merge!(object.bindings)    if object.is_a?(Variable)
+      bindings
+    end
+
+    ##
+    # Returns `true` if all variables in this pattern are bound.
+    #
+    # @return [Boolean]
+    def bound?
+      !variables.empty? && variables.values.all?(&:bound?)
+    end
+
+    ##
+    # Returns all bound variables in this pattern.
+    #
+    # @return [Hash{Symbol => Variable}]
+    def bound_variables
+      variables.reject { |name, variable| variable.unbound? }
+    end
+
+    ##
+    # Returns `true` if all variables in this pattern are unbound.
+    #
+    # @return [Boolean]
+    def unbound?
+      !variables.empty? && variables.values.all?(&:unbound?)
+    end
+
+    ##
+    # Returns all unbound variables in this pattern.
+    #
+    # @return [Hash{Symbol => Variable}]
+    def unbound_variables
+      variables.reject { |name, variable| variable.bound? }
+    end
+
+    ##
+    # Returns the string representation of this pattern.
+    #
+    # @return [String]
+    def to_s
+      require 'stringio' unless defined?(StringIO)
+      StringIO.open do |buffer| # FIXME in RDF::Statement
+        buffer << (subject.is_a?(Variable)   ? subject.to_s :   "<#{subject}>") << ' '
+        buffer << (predicate.is_a?(Variable) ? predicate.to_s : "<#{predicate}>") << ' '
+        buffer << (object.is_a?(Variable)    ? object.to_s :    "<#{object}>") << ' .'
+        buffer.string
+      end
+    end
+  end
+end end