rdf 3.1.7 → 3.1.12

data/lib/rdf/mixin/mutable.rb

@@ -122,7 +122,7 @@ module RDF
 
       statements.each do |statement|
         if (statement = Statement.from(statement))
-          if statement.has_object?
+          if statement.object?
             delete_insert([[statement.subject, statement.predicate, nil]], [statement])
           else
             delete([statement.subject, statement.predicate, nil])

data/lib/rdf/model/dataset.rb

@@ -104,7 +104,7 @@ module RDF
     # @private
     # @see RDF::Enumerable#supports?
     def supports?(feature)
-      return true if [:graph_name, :rdfstar].include?(feature)
+      return true if %i(graph_name rdfstar).include?(feature)
       super
     end
 

data/lib/rdf/model/graph.rb

@@ -138,11 +138,22 @@ module RDF
     end
 
     ##
-    # Returns `true` to indicate that this is a graph.
+    # @overload graph?
+    #   Returns `true` to indicate that this is a graph.
     #
-    # @return [Boolean]
-    def graph?
-      true
+    #   @return [Boolean]
+    # @overload graph?(name)
+    #   Returns `true` if `self` contains the given RDF graph_name.
+    #
+    #   @param  [RDF::Resource, false] graph_name
+    #     Use value `false` to query for the default graph_name
+    #   @return [Boolean]
+    def graph?(*args)
+      case args.length
+      when 0 then true
+      when 1 then graph_name == args.first
+      else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
+      end
     end
 
     ##
@@ -215,18 +226,29 @@ module RDF
     end
 
     ##
-    # Returns `true` if this graph contains the given RDF statement.
+    # @overload statement?
+    #   Returns `false` indicating this is not an RDF::Statemenet.
+    #   @see RDF::Value#statement?
+    #   @return [Boolean]
+    # @overload statement?(statement)
+    #   Returns `true` if this graph contains the given RDF statement.
     #
-    # A statement is in a graph if the statement if it has the same triples without regard to graph_name.
+    #   A statement is in a graph if the statement if it has the same triples without regard to graph_name.
     #
-    # @param  [Statement] statement
-    # @return [Boolean]
-    # @see    RDF::Enumerable#has_statement?
-    def has_statement?(statement)
-      statement = statement.dup
-      statement.graph_name = graph_name
-      @data.has_statement?(statement)
+    #   @param  [Statement] statement
+    #   @return [Boolean]
+    #   @see    RDF::Enumerable#statement?
+    def statement?(*args)
+      case args.length
+      when 0 then false
+      when 1
+        statement = args.first.dup
+        statement.graph_name = graph_name
+        @data.statement?(statement)
+      else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
+      end
     end
+    alias_method :has_statement?, :statement?
 
     ##
     # Enumerates each RDF statement in this graph.

data/lib/rdf/model/list.rb

@@ -49,14 +49,23 @@ module RDF
     #     g = RDF::Graph.new << l
     #     g.count # => l.count
     #
+    # @example use a transaction for block initialization
+    #     l = RDF::List(graph: graph, wrap_transaction: true) do |list|
+    #       list << RDF::Literal(1)
+    #       # list.graph.rollback will rollback all list changes within this block.
+    #     end
+    #     list.count #=> 1
+    #
     # @param  [RDF::Resource]         subject (RDF.nil)
     #   Subject should be an {RDF::Node}, not a {RDF::URI}. A list with an IRI head will not validate, but is commonly used to detect if a list is valid.
     # @param  [RDF::Graph]        graph (RDF::Graph.new)
     # @param  [Array<RDF::Term>]  values
     #   Any values which are not terms are coerced to `RDF::Literal`.
+    # @param [Boolean] wrap_transaction (false)
+    #   Wraps the callback in a transaction, and replaces the graph with that transaction for the duraction of the callback. This has the effect of allowing any list changes to be made atomically, or rolled back.
     # @yield  [list]
     # @yieldparam [RDF::List] list
-    def initialize(subject: nil, graph: nil, values: nil, &block)
+    def initialize(subject: nil, graph: nil, values: nil, wrap_transaction: false, &block)
       @subject = subject || RDF.nil
       @graph   = graph   || RDF::Graph.new
       is_empty = @graph.query({subject: subject, predicate: RDF.first}).empty?
@@ -78,9 +87,25 @@ module RDF
       end
 
       if block_given?
-        case block.arity
-          when 1 then block.call(self)
-          else instance_eval(&block)
+        if wrap_transaction
+          old_graph = @graph
+          begin
+            Transaction.begin(@graph, graph_name: @graph.graph_name, mutable: @graph.mutable?) do |trans|
+              @graph = trans
+              case block.arity
+                when 1 then block.call(self)
+                else instance_eval(&block)
+              end
+              trans.execute if trans.mutated?
+            end
+          ensure
+            @graph = old_graph
+          end
+        else
+          case block.arity
+            when 1 then block.call(self)
+            else instance_eval(&block)
+          end
         end
       end
     end

data/lib/rdf/model/literal.rb

@@ -25,7 +25,7 @@ module RDF
   #
   # @example Creating a language-tagged literal (1)
   #   value = RDF::Literal.new("Hello!", language: :en)
-  #   value.has_language?                            #=> true
+  #   value.language?                                #=> true
   #   value.language                                 #=> :en
   #
   # @example Creating a language-tagged literal (2)
@@ -35,12 +35,12 @@ module RDF
   #
   # @example Creating an explicitly datatyped literal
   #   value = RDF::Literal.new("2009-12-31", datatype: RDF::XSD.date)
-  #   value.has_datatype?                            #=> true
+  #   value.datatype?                                #=> true
   #   value.datatype                                 #=> RDF::XSD.date
   #
   # @example Creating an implicitly datatyped literal
   #   value = RDF::Literal.new(Date.today)
-  #   value.has_datatype?                            #=> true
+  #   value.datatype?                                #=> true
   #   value.datatype                                 #=> RDF::XSD.date
   #
   # @example Creating implicitly datatyped literals
@@ -225,7 +225,7 @@ module RDF
       # * The arguments are simple literals or literals typed as xsd:string
       # * The arguments are plain literals with identical language tags
       # * The first argument is a plain literal with language tag and the second argument is a simple literal or literal typed as xsd:string
-      has_language? ?
+      language? ?
         (language == other.language || other.datatype == RDF::URI("http://www.w3.org/2001/XMLSchema#string")) :
         other.datatype == RDF::URI("http://www.w3.org/2001/XMLSchema#string")
     end
@@ -289,7 +289,7 @@ module RDF
         case
         when self.eql?(other)
           true
-        when self.has_language? && self.language.to_s == other.language.to_s
+        when self.language? && self.language.to_s == other.language.to_s
           # Literals with languages can compare if languages are identical
           self.value_hash == other.value_hash && self.value == other.value
         when self.simple? && other.simple?
@@ -335,10 +335,10 @@ module RDF
     #
     # @return [Boolean] `true` or `false`
     # @see http://www.w3.org/TR/rdf-concepts/#dfn-plain-literal
-    def has_language?
+    def language?
       datatype == RDF.langString
     end
-    alias_method :language?, :has_language?
+    alias_method :has_language?, :language?
 
     ##
     # Returns `true` if this is a datatyped literal.
@@ -347,12 +347,12 @@ module RDF
     #
     # @return [Boolean] `true` or `false`
     # @see http://www.w3.org/TR/rdf-concepts/#dfn-typed-literal
-    def has_datatype?
+    def datatype?
       !plain? && !language?
     end
-    alias_method :datatype?,  :has_datatype?
-    alias_method :typed?,     :has_datatype?
-    alias_method :datatyped?, :has_datatype?
+    alias_method :has_datatype?,  :datatype?
+    alias_method :typed?,         :datatype?
+    alias_method :datatyped?,     :datatype?
 
     ##
     # Returns `true` if the value adheres to the defined grammar of the
@@ -386,16 +386,16 @@ module RDF
     # This behavior is intuited from SPARQL data-r2/expr-equal/eq-2-2
     # @return [Boolean]
     def comperable_datatype?(other)
-      return false unless self.plain? || self.has_language?
+      return false unless self.plain? || self.language?
 
       case other
       when RDF::Literal::Numeric, RDF::Literal::Boolean,
            RDF::Literal::Date, RDF::Literal::Time, RDF::Literal::DateTime
         # Invald types can be compared without raising a TypeError if literal has a language (open-eq-08)
-        !other.valid? && self.has_language?
+        !other.valid? && self.language?
       else
         # An unknown datatype may not be used for comparison, unless it has a language? (open-eq-8)
-        self.has_language?
+        self.language?
       end
     end
 

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

@@ -51,11 +51,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.
@@ -72,7 +74,7 @@ module RDF; class Literal
     # @since 1.1.6
     def humanize(lang = :en)
       d = object.strftime("%A, %d %B %Y")
-      if has_timezone?
+      if timezone?
         d += if self.tz == 'Z'
           " UTC"
         else

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

@@ -30,7 +30,7 @@ module RDF; class Literal
     # @see    http://www.w3.org/TR/xmlschema11-2/#dateTime
     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', '')
@@ -45,7 +45,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
@@ -85,21 +85,25 @@ module RDF; class Literal
     #
     # @return [Boolean]
     # @since 1.1.6
-    def has_milliseconds?
+    def milliseconds?
       self.format("%L").to_i > 0
     end
-    alias_method :has_ms?, :has_milliseconds?
+    alias_method :has_milliseconds?, :milliseconds?
+    alias_method :has_ms?, :milliseconds?
+    alias_method :ms?, :milliseconds?
 
     ##
     # Does the literal representation include a timezone? Note that this is only possible if initialized using a string, or `:lexical` option.
     #
     # @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 `timezone` of the literal. If the
@@ -118,7 +122,7 @@ module RDF; class Literal
     # @since 1.1.6
     def humanize(lang = :en)
       d = object.strftime("%r on %A, %d %B %Y")
-      if has_timezone?
+      if timezone?
         zone = if self.tz == 'Z'
           "UTC"
         else

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
@@ -136,23 +136,45 @@ module RDF
     end
 
     ##
-    # Returns `true` to indicate that this value is a statement.
+    # @overload statement?
+    #   Returns `true` if `self` is a {RDF::Statement}.
     #
-    # @return [Boolean]
-    def statement?
-      true
+    #   @return [Boolean]
+    # @overload statement?(statement)
+    #   Returns `true` if `self` contains the given {RDF::Statement}.
+    #
+    #   @param  [RDF::Statement] statement
+    #   @return [Boolean]
+    def statement?(*args)
+      case args.length
+      when 0 then true
+      when 1 then self == args.first || subject.statement?(*args) || object.statement?(*args)
+      else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
+      end
     end
 
     ##
-    # Returns `true` if any element of the statement is not a
+    # @overload variable?
+    #   Returns `true` if any element of the statement is not a
     # URI, Node or Literal.
     #
-    # @return [Boolean]
-    def variable?
-      !(has_subject?    && subject.constant? &&
-        has_predicate?  && predicate.constant? &&
-        has_object?     && object.constant? &&
-        (has_graph?     ? graph_name.constant? : true))
+    #   @return [Boolean]
+    # @overload variable?(variables)
+    #   Returns `true` if this statement contains any of the variables.
+    #
+    #   @param  [Array<Symbol, #to_sym>] variables
+    #   @return [Boolean]
+    def variable?(*args)
+      case args.length
+      when 0
+        !(subject?    && subject.constant? &&
+          predicate?  && predicate.constant? &&
+          object?     && object.constant? &&
+          (graph?     ? graph_name.constant? : true))
+      when 1
+        to_quad.any? {|t| t.respond_to?(:variable?) && t.variable?(*args)}
+      else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
+      end
     end
 
     ##
@@ -172,10 +194,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
 
     ##
@@ -215,32 +237,51 @@ module RDF
     end
 
     ##
-    # @return [Boolean]
-    def has_graph?
-      !!graph_name
+    # @overload graph?
+    #   Returns `true` if the statement has a graph name.
+    #
+    #   @return [Boolean]
+    # @overload graph?(name)
+    #   Returns `true` if `self` contains the given RDF graph_name.
+    #
+    #   @param  [RDF::Resource, false] graph_name
+    #     Use value `false` to query for the default graph_name
+    #   @return [Boolean]
+    def graph?(*args)
+      case args.length
+      when 0 then !!graph_name
+      when 1 then graph_name == args.first
+      else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
+      end
     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 +353,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 +400,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 +414,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