rdf 3.1.6 → 3.1.11

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

@@ -215,18 +215,25 @@ 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)
+    #   @param  [Statement] statement
+    #   @return [Boolean]
+    #   @see    RDF::Enumerable#statement?
+    def statement?(statement = nil)
+      return false if statement.nil?
       statement = statement.dup
       statement.graph_name = graph_name
-      @data.has_statement?(statement)
+      @data.statement?(statement)
     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/decimal.rb

@@ -63,9 +63,15 @@ module RDF; class Literal
     ##
     # Returns the number with no fractional part that is closest to the argument. If there are two such numbers, then the one that is closest to positive infinity is returned. An error is raised if arg is not a numeric value.
     #
-    # @return [RDF::Literal::Integer]
+    # @return [RDF::Literal::Decimal]
     def round
-      RDF::Literal::Integer.new(to_d.round)
+      rounded = to_d.round(half: (to_d < 0 ? :down : :up))
+      if rounded == -0.0
+        # to avoid -0.0
+        self.class.new(0.0)
+      else
+        self.class.new(rounded)
+      end
     end
 
     ##

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

@@ -181,11 +181,11 @@ module RDF; class Literal
     end
 
     ##
-    # Returns the integer with no fractional part that is closest to the argument. If there are two such numbers, then the one that is closest to positive infinity is returned. An error is raised if arg is not a numeric value.
+    # Returns the number with no fractional part that is closest to the argument. If there are two such numbers, then the one that is closest to positive infinity is returned. An error is raised if arg is not a numeric value.
     #
-    # @return [RDF::Literal::Integer]
+    # @return [RDF::Literal::Double]
     def round
-      RDF::Literal::Integer.new(to_f.round)
+      self.class.new(to_d.round(half: (to_d < 0 ? :down : :up)))
     end
 
     ##

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