rdf 3.1.5 → 3.1.10

data/lib/rdf/model/literal/time.rb

@@ -42,7 +42,7 @@ module RDF; class Literal
     # @see    http://www.w3.org/TR/xmlschema11-2/#time
     def canonicalize!
       if self.valid?
-        @string = if has_timezone?
+        @string = if timezone?
           @object.new_offset.new_offset.strftime(FORMAT[0..-4] + 'Z').sub('.000', '')
         else
           @object.strftime(FORMAT[0..-4]).sub('.000', '')
@@ -57,7 +57,7 @@ module RDF; class Literal
     # @return [RDF::Literal]
     # @see http://www.w3.org/TR/sparql11-query/#func-tz
     def tz
-      zone =  has_timezone? ? object.zone : ""
+      zone =  timezone? ? object.zone : ""
       zone = "Z" if zone == "+00:00"
       RDF::Literal(zone)
     end
@@ -79,11 +79,13 @@ module RDF; class Literal
     #
     # @return [Boolean]
     # @since 1.1.6
-    def has_timezone?
+    def timezone?
       md = self.to_s.match(GRAMMAR)
       md && !!md[2]
     end
-    alias_method :has_tz?, :has_timezone?
+    alias_method :tz?, :timezone?
+    alias_method :has_tz?, :timezone?
+    alias_method :has_timezone?, :timezone?
 
     ##
     # Returns the value as a string.
@@ -101,7 +103,7 @@ module RDF; class Literal
     # @since 1.1.6
     def humanize(lang = :en)
       t = object.strftime("%r")
-      if has_timezone?
+      if timezone?
         t += if self.tz == 'Z'
           " UTC"
         else

data/lib/rdf/model/node.rb

@@ -13,18 +13,14 @@ module RDF
     include RDF::Resource
 
     ##
-    # Defines the maximum number of interned Node references that can be held
-    # cached in memory at any one time.
+    # Cache size may be set through {RDF.config} using `node_cache_size`.
     #
     # @note caching interned nodes means that two different invocations using the same symbol will result in the same node, which may not be appropriate depending on the graph from which it is used. RDF requires that bnodes with the same label are, in fact, different bnodes, unless they are used within the same document.
-    CACHE_SIZE = -1 # unlimited by default
-
-    ##
     # @return [RDF::Util::Cache]
     # @private
     def self.cache
       require 'rdf/util/cache' unless defined?(::RDF::Util::Cache)
-      @cache ||= RDF::Util::Cache.new(CACHE_SIZE)
+      @cache ||= RDF::Util::Cache.new(RDF.config.node_cache_size)
     end
 
     ##

data/lib/rdf/model/statement.rb

@@ -96,7 +96,7 @@ module RDF
         @predicate = predicate
         @object    = object
       end
-      @id          = @options.delete(:id) if @options.has_key?(:id)
+      @id          = @options.delete(:id) if @options.key?(:id)
       @graph_name  = @options.delete(:graph_name)
       initialize!
     end
@@ -149,10 +149,10 @@ module RDF
     #
     # @return [Boolean]
     def variable?
-      !(has_subject?    && subject.constant? &&
-        has_predicate?  && predicate.constant? &&
-        has_object?     && object.constant? &&
-        (has_graph?     ? graph_name.constant? : true))
+      !(subject?    && subject.constant? &&
+        predicate?  && predicate.constant? &&
+        object?     && object.constant? &&
+        (graph?     ? graph_name.constant? : true))
     end
 
     ##
@@ -172,10 +172,10 @@ module RDF
     ##
     # @return [Boolean]
     def valid?
-      has_subject?    && subject.resource? && subject.valid? &&
-      has_predicate?  && predicate.uri? && predicate.valid? &&
-      has_object?     && object.term? && object.valid? &&
-      (has_graph?      ? (graph_name.resource? && graph_name.valid?) : true)
+      subject?    && subject.resource? && subject.valid? &&
+      predicate?  && predicate.uri? && predicate.valid? &&
+      object?     && object.term? && object.valid? &&
+      (graph?      ? (graph_name.resource? && graph_name.valid?) : true)
     end
 
     ##
@@ -216,31 +216,37 @@ module RDF
 
     ##
     # @return [Boolean]
-    def has_graph?
+    def graph?
       !!graph_name
     end
-    alias_method :has_name?, :has_graph?
+    alias_method :name?, :graph?
+    alias_method :has_graph?, :graph?
+    alias_method :has_name?, :graph?
 
     ##
     # @return [Boolean]
-    def has_subject?
+    def subject?
       !!subject
     end
+    alias_method :has_subject?, :subject?
 
     ##
     # @return [Boolean]
-    def has_predicate?
+    def predicate?
       !!predicate
     end
+    alias_method :has_predicate?, :predicate?
 
     ##
     # @return [Boolean]
-    def has_object?
+    def object?
       !!object
     end
+    alias_method :has_object?, :object?
 
     ##
-    # Returns `true` if any resource of this statement is a blank node.
+    # Returns `true` if any resource of this statement is a blank node
+    # or has an embedded statement including a blank node.
     #
     # @return [Boolean]
     # @since 2.0
@@ -312,10 +318,10 @@ module RDF
     # @see RDF::Literal#eql?
     # @see RDF::Query::Variable#eql?
     def ===(other)
-      return false if has_object?    && !object.eql?(other.object)
-      return false if has_predicate? && !predicate.eql?(other.predicate)
-      return false if has_subject?   && !subject.eql?(other.subject)
-      return false if has_graph?     && !graph_name.eql?(other.graph_name)
+      return false if object?    && !object.eql?(other.object)
+      return false if predicate? && !predicate.eql?(other.predicate)
+      return false if subject?   && !subject.eql?(other.subject)
+      return false if graph?     && !graph_name.eql?(other.graph_name)
       return true
     end
 
@@ -359,6 +365,13 @@ module RDF
     end
     alias_method :to_a, :to_triple
 
+    ##
+    # Returns an array of all the non-nil non-statement terms.
+    # @return [Array(RDF::Term)]
+    def terms
+      to_quad.map {|t| t.respond_to?(:terms) ? t.terms : t}.flatten.compact
+    end
+
     ##
     # Canonicalizes each unfrozen term in the statement
     #
@@ -366,10 +379,10 @@ module RDF
     # @since  1.0.8
     # @raise [ArgumentError] if any element cannot be canonicalized.
     def canonicalize!
-      self.subject.canonicalize!    if has_subject? && !self.subject.frozen?
-      self.predicate.canonicalize!  if has_predicate? && !self.predicate.frozen?
-      self.object.canonicalize!     if has_object? && !self.object.frozen?
-      self.graph_name.canonicalize! if has_graph? && !self.graph_name.frozen?
+      self.subject.canonicalize!    if subject? && !self.subject.frozen?
+      self.predicate.canonicalize!  if predicate? && !self.predicate.frozen?
+      self.object.canonicalize!     if object? && !self.object.frozen?
+      self.graph_name.canonicalize! if graph? && !self.graph_name.frozen?
       self.validate!
       @hash = nil
       self

data/lib/rdf/model/term.rb

@@ -72,6 +72,14 @@ module RDF
       self
     end
 
+    ##
+    # Returns an array including just itself.
+    #
+    # @return [Array<RDF::Value>]
+    def terms
+      [self]
+    end
+
     ##
     # Returns the base representation of this term.
     #

data/lib/rdf/model/uri.rb

@@ -27,11 +27,6 @@ module RDF
   class URI
     include RDF::Resource
 
-    ##
-    # Defines the maximum number of interned URI references that can be held
-    # cached in memory at any one time.
-    CACHE_SIZE = -1 # unlimited by default
-    
     # IRI components
     UCSCHAR = Regexp.compile(<<-EOS.gsub(/\s+/, ''))
       [\\u00A0-\\uD7FF]|[\\uF900-\\uFDCF]|[\\uFDF0-\\uFFEF]|
@@ -117,11 +112,13 @@ module RDF
     ).freeze
 
     ##
+    # Cache size may be set through {RDF.config} using `uri_cache_size`.
+    #
     # @return [RDF::Util::Cache]
     # @private
     def self.cache
       require 'rdf/util/cache' unless defined?(::RDF::Util::Cache)
-      @cache ||= RDF::Util::Cache.new(CACHE_SIZE)
+      @cache ||= RDF::Util::Cache.new(RDF.config.uri_cache_size)
     end
 
     ##
@@ -229,13 +226,13 @@ module RDF
         @value.dup.force_encoding(Encoding::UTF_8) if @value.encoding != Encoding::UTF_8
         @value.freeze
       else
-        %w(
+        %i(
           scheme
           user password userinfo
           host port authority
           path query fragment
-        ).map(&:to_sym).each do |meth|
-          if options.has_key?(meth)
+        ).each do |meth|
+          if options.key?(meth)
             self.send("#{meth}=".to_sym, options[meth])
           else
             self.send(meth)
@@ -311,12 +308,22 @@ module RDF
     # @param [#to_s] base_uri
     # @return [RDF::URI]
     def relativize(base_uri)
-      if base_uri.to_s.end_with?("/", "#") &&
+      if self.to_s.start_with?(base_uri.to_s) && %w(# ?).include?(self.to_s[base_uri.to_s.length, 1]) ||
+         base_uri.to_s.end_with?("/", "#") &&
          self.to_s.start_with?(base_uri.to_s)
-        RDF::URI(self.to_s[base_uri.to_s.length..-1])
+        return RDF::URI(self.to_s[base_uri.to_s.length..-1])
       else
-        self
+        # Create a list of parents, for which this IRI may be relative.
+        u = RDF::URI(base_uri)
+        iri_set = u.to_s.end_with?('/') ? [u.to_s] : []
+        iri_set << u.to_s while (u = u.parent)
+        iri_set.each_with_index do |bb, index|
+          next unless self.to_s.start_with?(bb)
+          rel = "../" * index + self.to_s[bb.length..-1]
+          return rel.empty? ? "./" : rel
+        end
       end
+      self
     end
 
     ##
@@ -409,7 +416,7 @@ module RDF
     # @see http://tools.ietf.org/html/rfc3986#section-5.2.2
     # @see http://tools.ietf.org/html/rfc3986#section-5.2.3
     def join(*uris)
-      joined_parts = object.dup.delete_if {|k, v| [:user, :password, :host, :port].include?(k)}
+      joined_parts = object.dup.delete_if {|k, v| %i(user password host port).include?(k)}
 
       uris.each do |uri|
         uri = RDF::URI.new(uri) unless uri.is_a?(RDF::URI)
@@ -573,7 +580,7 @@ module RDF
       else
         RDF::URI.new(
           **object.merge(path: '/').
-          keep_if {|k, v| [:scheme, :authority, :path].include?(k)})
+          keep_if {|k, v| %i(scheme authority path).include?(k)})
       end
     end
 
@@ -581,13 +588,14 @@ module RDF
     # Returns `true` if this URI is hierarchical and it's path component isn't equal to `/`.
     #
     # @example
-    #   RDF::URI('http://example.org/').has_parent?             #=> false
-    #   RDF::URI('http://example.org/path/').has_parent?        #=> true
+    #   RDF::URI('http://example.org/').parent?             #=> false
+    #   RDF::URI('http://example.org/path/').parent?        #=> true
     #
     # @return [Boolean] `true` or `false`
-    def has_parent?
+    def parent?
       !root?
     end
+    alias_method :has_parent?, :parent?
 
     ##
     # Returns a copy of this URI with the path component ascended to the
@@ -1115,7 +1123,7 @@ module RDF
     # @param [String, #to_s] value
     # @return [RDF::URI] self
     def authority=(value)
-      object.delete_if {|k, v| [:user, :password, :host, :port, :userinfo].include?(k)}
+      object.delete_if {|k, v| %i(user password host port userinfo).include?(k)}
       object[:authority] = (value.to_s.dup.force_encoding(Encoding::UTF_8) if value)
       user; password; userinfo; host; port
       @value = nil
@@ -1145,7 +1153,7 @@ module RDF
     # @param [String, #to_s] value
     # @return [RDF::URI] self
     def userinfo=(value)
-      object.delete_if {|k, v| [:user, :password, :authority].include?(k)}
+      object.delete_if {|k, v| %i(user password authority).include?(k)}
       object[:userinfo] = (value.to_s.dup.force_encoding(Encoding::UTF_8) if value)
       user; password; authority
       @value = nil

data/lib/rdf/nquads.rb

@@ -69,9 +69,9 @@ module RDF
 
           begin
             unless blank? || read_comment
-              subject   = read_uriref || read_node || read_rdfstar || fail_subject
+              subject   = read_uriref || read_node || read_embTriple || fail_subject
               predicate = read_uriref(intern: true) || fail_predicate
-              object    = read_uriref || read_node || read_literal || read_rdfstar || fail_object
+              object    = read_uriref || read_node || read_literal || read_embTriple || fail_object
               graph_name    = read_uriref || read_node
               if validate? && !read_eos
                 log_error("Expected end of statement (found: #{current_line.inspect})", lineno: lineno, exception: RDF::ReaderError)

data/lib/rdf/ntriples/reader.rb

@@ -213,7 +213,7 @@ module RDF::NTriples
       begin
         read_statement
       rescue RDF::ReaderError
-        value = read_uriref || read_node || read_literal || read_rdfstar
+        value = read_uriref || read_node || read_literal || read_embTriple
         log_recover
         value
       end
@@ -229,9 +229,9 @@ module RDF::NTriples
 
         begin
           unless blank? || read_comment
-            subject   = read_uriref || read_node || read_rdfstar || fail_subject
+            subject   = read_uriref || read_node || read_embTriple || fail_subject
             predicate = read_uriref(intern: true) || fail_predicate
-            object    = read_uriref || read_node || read_literal || read_rdfstar || fail_object
+            object    = read_uriref || read_node || read_literal || read_embTriple || fail_object
 
             if validate? && !read_eos
               log_error("Expected end of statement (found: #{current_line.inspect})", lineno: lineno, exception: RDF::ReaderError)
@@ -247,11 +247,11 @@ module RDF::NTriples
 
     ##
     # @return [RDF::Statement]
-    def read_rdfstar
+    def read_embTriple
       if @options[:rdfstar] && match(ST_START)
-        subject   = read_uriref || read_node || read_rdfstar || fail_subject
+        subject   = read_uriref || read_node || read_embTriple || fail_subject
         predicate = read_uriref(intern: true) || fail_predicate
-        object    = read_uriref || read_node || read_literal || read_rdfstar || fail_object
+        object    = read_uriref || read_node || read_literal || read_embTriple || fail_object
         if !match(ST_END)
           log_error("Expected end of statement (found: #{current_line.inspect})", lineno: lineno, exception: RDF::ReaderError)
         end

data/lib/rdf/ntriples/writer.rb

@@ -227,7 +227,7 @@ module RDF::NTriples
     # @param  [RDF::Statement] statement
     # @param  [Hash{Symbol => Object}] options ({})
     # @return [String]
-    def format_rdfstar(statement, **options)
+    def format_embTriple(statement, **options)
       "<<%s %s %s>>" % statement.to_a.map { |value| format_term(value, **options) }
     end
     ##
@@ -309,8 +309,8 @@ module RDF::NTriples
         when RDF::Literal
           # Note, escaping here is more robust than in Term
           text = quoted(escaped(literal.value))
-          text << "@#{literal.language}" if literal.has_language?
-          text << "^^<#{uri_for(literal.datatype)}>" if literal.has_datatype?
+          text << "@#{literal.language}" if literal.language?
+          text << "^^<#{uri_for(literal.datatype)}>" if literal.datatype?
           text
         else
           quoted(escaped(literal.to_s))

data/lib/rdf/query.rb

@@ -247,15 +247,22 @@ module RDF
     # Optimizes this query by reordering its constituent triple patterns
     # according to their cost estimates.
     #
+    # Optional patterns have greater cost than non-optional patterns so they will always come after non-optional patterns
+    #
     # @param  [Hash{Symbol => Object}] options
     #   any additional options for optimization
     # @return [self]
     # @see    RDF::Query::Pattern#cost
     # @since  0.3.0
     def optimize!(**options)
-      @patterns.sort! do |a, b|
+      optional, required = @patterns.uniq.partition(&:optional?)
+      required.sort! do |a, b|
+        (a.cost || 0) <=> (b.cost || 0)
+      end
+      optional.sort! do |a, b|
         (a.cost || 0) <=> (b.cost || 0)
       end
+      @patterns = required + optional
       self
     end
 

data/lib/rdf/query/pattern.rb

@@ -85,13 +85,13 @@ module RDF; class Query
     #
     # @return [Boolean] `true` or `false`
     # @since  0.3.0
-    def has_variables?
+    def variables?
       subject    && subject.variable? ||
       predicate  && predicate.variable? ||
       object     && object.variable? ||
       graph_name && graph_name.variable?
     end
-    alias_method :variables?, :has_variables?
+    alias_method :has_variables?, :variables?
 
     ##
     # Returns `true` if this is an optional pattern.
@@ -111,10 +111,10 @@ module RDF; class Query
     #
     # @return [Boolean] `true` or `false`
     def valid?
-      (has_subject?   ? (subject.resource? || subject.variable?) && subject.valid? : true) && 
-      (has_predicate? ? (predicate.uri? || predicate.variable?) && predicate.valid? : true) &&
-      (has_object?    ? (object.term? || object.variable?) && object.valid? : true) &&
-      (has_graph?     ? (graph_name.resource? || graph_name.variable?) && graph_name.valid? : true)
+      (subject?   ? (subject.resource? || subject.variable?) && subject.valid? : true) && 
+      (predicate? ? (predicate.uri? || predicate.variable?) && predicate.valid? : true) &&
+      (object?    ? (object.term? || object.variable?) && object.valid? : true) &&
+      (graph?     ? (graph_name.resource? || graph_name.variable?) && graph_name.valid? : true)
     rescue NoMethodError
       false
     end
@@ -181,16 +181,10 @@ module RDF; class Query
 
       # No, some terms actually refer to the same variable...
       else
-        # Figure out which terms refer to the same variable:
-        terms = variables.each_key.find do |name|
-          terms = variable_terms(name)
-          break terms if terms.size > 1
-        end
+        # Considering embedding, figure out if variables that may appear more than once resolve to the same value.
+        vars = variables.keys
         queryable.query(query).select do |statement|
-          # Only yield those matching statements where the variable
-          # constraint is also satisfied:
-          # FIXME: `Array#uniq` uses `#eql?` and `#hash`, not `#==`
-          if terms.map { |term| statement.send(term) }.uniq.size.equal?(1)
+          if vars.all? {|var| self.var_values(var, statement).uniq.size == 1}
             yield statement if block_given?
             true
           end
@@ -220,8 +214,8 @@ module RDF; class Query
         solution[predicate.to_sym]  = statement.predicate  if predicate.is_a?(Variable)
         solution[object.to_sym]     = statement.object     if object.is_a?(Variable)
         solution[graph_name.to_sym] = statement.graph_name if graph_name.is_a?(Variable)
-        solution.merge!(subject.solution(statement.subject)) if subject.is_a?(Pattern)
-        solution.merge!(object.solution(statement.object)) if object.is_a?(Pattern)
+        solution.merge!(subject.solution(statement.subject)) if subject.respond_to?(:solution)
+        solution.merge!(object.solution(statement.object)) if object.respond_to?(:solution)
       end
     end
 
@@ -234,8 +228,11 @@ module RDF; class Query
     # @param  [Symbol, #to_sym] name
     #   an optional variable name
     # @return [Array<Symbol>]
+    # @deprecated use {#var_values} instead
     # @since  0.3.0
     def variable_terms(name = nil)
+      warn "[DEPRECATION] RDF::Query::Pattern#variable_terms is deprecated and will be removed in a future version.\n" +
+           "Called from #{Gem.location_of_caller.join(':')}"
       terms = []
       terms << :subject    if subject.is_a?(Variable)    && (!name || name.eql?(subject.name))
       terms << :predicate  if predicate.is_a?(Variable)  && (!name || name.eql?(predicate.name))
@@ -244,6 +241,20 @@ module RDF; class Query
       terms
     end
 
+    ##
+    # Returns all values the statement in the same pattern position
+    #
+    # @param [Symbol] var
+    # @param [RDF::Statement] statement
+    # @return [Array<RDF::Term>]
+    def var_values(var, statement)
+      %i(subject predicate object graph_name).map do |position|
+        po = self.send(position)
+        so = statement.send(position)
+        po.var_values(var, so) if po.respond_to?(:var_values)
+      end.flatten.compact
+    end
+
     ##
     # Returns the number of variables in this pattern.
     #
@@ -254,7 +265,7 @@ module RDF; class Query
     def variable_count
       [subject, predicate, object, graph_name].inject(0) do |memo, term|
         memo += (term.is_a?(Variable) ? 1 :
-                 (term.is_a?(Pattern) ? term.variable_count : 0))
+                 (term.respond_to?(:variable_count) ? term.variable_count : 0))
       end
     end
     alias_method :cardinality, :variable_count
@@ -311,9 +322,9 @@ module RDF; class Query
     def bindings
       bindings = {}
       bindings.merge!(subject.bindings)    if subject && subject.variable?
-      bindings.merge!(predicate.bindings)  if predicate.is_a?(Variable)
+      bindings.merge!(predicate.bindings)  if predicate && predicate.variable?
       bindings.merge!(object.bindings)     if object && object.variable?
-      bindings.merge!(graph_name.bindings) if graph_name.is_a?(Variable)
+      bindings.merge!(graph_name.bindings) if graph_name && graph_name.variable?
       bindings
     end
 
@@ -354,24 +365,7 @@ module RDF; class Query
     #
     # @return [String]
     def to_s
-      StringIO.open do |buffer| # FIXME in RDF::Statement
-        buffer << 'OPTIONAL ' if optional?
-        buffer << [subject, predicate, object].map do |r|
-          if r.is_a?(RDF::Query::Variable)
-            r.to_s
-          elsif r.is_a?(RDF::Query::Pattern)
-            "<<#{r.to_s[0..-3]}>>"
-          else
-            RDF::NTriples.serialize(r)
-          end
-        end.join(" ")
-        buffer << case graph_name
-          when nil, false then " ."
-          when Variable then " #{graph_name.to_s} ."
-          else " #{RDF::NTriples.serialize(graph_name)} ."
-        end
-        buffer.string
-      end
+      (optional? ? 'OPTIONAL ' : '') + super
     end
   end # Pattern
 end; end # RDF::Query