rdf 3.1.5 → 3.1.10

data/lib/rdf/model/list.rb

@@ -45,18 +45,27 @@ module RDF
     # identified by `subject`, but will be invalid.
     #
     # @example add constructed list to existing graph
-    #     l = RDF::List(nil, nil (1, 2, 3))
+    #     l = RDF::List(values: (1, 2, 3))
     #     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?
@@ -68,8 +77,8 @@ module RDF
         if first || values.length > 0
           # Intantiate the list from values, and insert the first value using subject.
           values.reverse_each {|value| self.unshift(value)}
-          graph.insert RDF::Statement(subject, RDF.first, first || RDF.nil)
-          graph.insert RDF::Statement(subject, RDF.rest, @subject)
+          @graph.insert RDF::Statement(subject, RDF.first, first || RDF.nil)
+          @graph.insert RDF::Statement(subject, RDF.rest, @subject)
         end
         @subject = subject
       else
@@ -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
@@ -175,7 +200,7 @@ module RDF
     # @return [RDF::List]
     # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-26
     def &(other)
-      RDF::List[*(to_a & other.to_a)]
+      self.class.new(values: (to_a & other.to_a))
     end
 
     ##
@@ -193,7 +218,7 @@ module RDF
     # @return [RDF::List]
     # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-7C
     def |(other)
-      RDF::List[*(to_a | other.to_a)]
+      self.class.new(values: (to_a | other.to_a))
     end
 
     ##
@@ -206,7 +231,7 @@ module RDF
     # @return [RDF::List]
     # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-2B
     def +(other)
-      RDF::List[*(to_a + other.to_a)]
+      self.class.new(values: (to_a + other.to_a))
     end
 
     ##
@@ -220,7 +245,7 @@ module RDF
     # @return [RDF::List]
     # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-2D
     def -(other)
-      RDF::List[*(to_a - other.to_a)]
+      self.class.new(values: (to_a - other.to_a))
     end
 
     ##
@@ -250,7 +275,7 @@ module RDF
     # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-2A
     def *(int_or_str)
       case int_or_str
-        when Integer then RDF::List[*(to_a * int_or_str)]
+        when Integer then self.class.new(values: (to_a * int_or_str))
         else join(int_or_str.to_s)
       end
     end
@@ -538,13 +563,13 @@ module RDF
     ##
     # @private
     def slice_with_start_and_length(start, length)
-      RDF::List[*to_a.slice(start, length)]
+      self.class.new(values: to_a.slice(start, length))
     end
 
     ##
     # @private
     def slice_with_range(range)
-      RDF::List[*to_a.slice(range)]
+      self.class.new(values: to_a.slice(range))
     end
 
     protected :slice_with_start_and_length
@@ -851,7 +876,7 @@ module RDF
     # @return [RDF::List]
     # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-reverse
     def reverse
-      RDF::List[*to_a.reverse]
+      self.class.new(values: to_a.reverse)
     end
 
     ##
@@ -863,7 +888,7 @@ module RDF
     # @return [RDF::List]
     # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-sort
     def sort(&block)
-      RDF::List[*super]
+      self.class.new(values: super)
     end
 
     ##
@@ -875,7 +900,7 @@ module RDF
     # @return [RDF::List]
     # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-sort_by
     def sort_by(&block)
-      RDF::List[*super]
+      self.class.new(values: super)
     end
 
     ##
@@ -887,7 +912,7 @@ module RDF
     # @return [RDF::List]
     # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-uniq
     def uniq
-      RDF::List[*to_a.uniq]
+      self.class.new(values: to_a.uniq)
     end
 
     ##
@@ -964,7 +989,7 @@ module RDF
       case value
         when nil         then RDF.nil
         when RDF::Value  then value
-        when Array       then RDF::List.new(subject: nil, graph: graph, values: value)
+        when Array       then self.class.new(subject: nil, graph: graph, values: value)
         else value
       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
@@ -118,6 +118,7 @@ module RDF
           when ::Integer    then RDF::Literal::Integer
           when ::Float      then RDF::Literal::Double
           when ::BigDecimal then RDF::Literal::Decimal
+          when ::Rational   then RDF::Literal::Double
           when ::DateTime   then RDF::Literal::DateTime
           when ::Time       then RDF::Literal::DateTime
           when ::Date       then RDF::Literal::Date
@@ -224,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
@@ -288,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?
@@ -334,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.
@@ -346,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
@@ -385,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]
+    # @return [RDF::Literal::Decimal]
     def round
-      self.class.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
 
     ##
@@ -74,9 +80,9 @@ module RDF; class Literal
     # @example
     #   RDF::Literal(1).ceil            #=> RDF::Literal(1)
     #
-    # @return [RDF::Literal]
+    # @return [RDF::Literal::Integer]
     def ceil
-      self.class.new(to_d.ceil)
+      RDF::Literal::Integer.new(to_d.ceil)
     end
 
     ##
@@ -85,9 +91,9 @@ module RDF; class Literal
     # @example
     #   RDF::Literal(1).floor            #=> RDF::Literal(1)
     #
-    # @return [RDF::Literal]
+    # @return [RDF::Literal::Integer]
     def floor
-      self.class.new(to_d.floor)
+      RDF::Literal::Integer.new(to_d.floor)
     end
 
     ##

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

@@ -142,7 +142,7 @@ module RDF; class Literal
     end
 
     ##
-    # Returns the smallest number greater than or equal to `self`.
+    # Returns the smallest integer greater than or equal to `self`.
     #
     # @example
     #   RDF::Literal(1.2).ceil            #=> RDF::Literal(2)
@@ -150,14 +150,14 @@ module RDF; class Literal
     #   RDF::Literal(2.0).ceil            #=> RDF::Literal(2)
     #   RDF::Literal(-2.0).ceil           #=> RDF::Literal(-2)
     #
-    # @return [RDF::Literal]
+    # @return [RDF::Literal::Integer]
     # @since  0.2.3
     def ceil
-      self.class.new(to_f.ceil)
+      RDF::Literal::Integer.new(to_f.ceil)
     end
 
     ##
-    # Returns the largest number less than or equal to `self`.
+    # Returns the largest integer less than or equal to `self`.
     #
     # @example
     #   RDF::Literal(1.2).floor           #=> RDF::Literal(1)
@@ -165,10 +165,10 @@ module RDF; class Literal
     #   RDF::Literal(2.0).floor           #=> RDF::Literal(2)
     #   RDF::Literal(-2.0).floor          #=> RDF::Literal(-2)
     #
-    # @return [RDF::Literal]
+    # @return [RDF::Literal::Integer]
     # @since  0.2.3
     def floor
-      self.class.new(to_f.floor)
+      RDF::Literal::Integer.new(to_f.floor)
     end
 
     ##
@@ -183,9 +183,9 @@ 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]
+    # @return [RDF::Literal::Double]
     def round
-      self.class.new(to_f.round)
+      self.class.new(to_d.round(half: (to_d < 0 ? :down : :up)))
     end
 
     ##

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

@@ -123,6 +123,40 @@ module RDF; class Literal
       end
     end
 
+    ##
+    # Exponent − Performs exponential (power) calculation on operators.
+    #
+    # Promotes values, as necessary, with the result type depending on the input values.
+    #
+    # @param  [Literal::Numeric, #to_i, #to_f, #to_d] other
+    # @return [RDF::Literal::Numeric]
+    # @since  0.2.3
+    # @see https://www.w3.org/TR/xpath-functions/#func-math-pow
+    def **(other)
+      RDF::Literal(object ** (other.is_a?(RDF::Literal::Numeric) ? other.object : other))
+    rescue ZeroDivisionError
+      RDF::Literal::Double.new('INF')
+    end
+
+    ##
+    # Exponent − Performs remainder of `self` divided by `other`.
+    #
+    # @param  [Literal::Numeric, #to_i, #to_f, #to_d] other
+    # @return [RDF::Literal]
+    # @since  0.2.3
+    # @see https://www.w3.org/TR/xpath-functions/#func-numeric-mod
+    def %(other)
+      if self.class == Double || [Double, ::Float].include?(other.class)
+        self.class.new(to_f % other.to_f)
+      elsif ((self.class == RDF::Literal::Float || other.class == RDF::Literal::Float) rescue false)
+        self.class.new(to_f % other.to_f)
+      elsif self.class == Decimal || other.class == Decimal
+        self.class.new(to_d % (other.respond_to?(:to_d) ? other.to_d : BigDecimal(other.to_s)))
+      else
+        self.class.new(to_i % other.to_i)
+      end
+    end
+
     ##
     # Returns the quotient of `self` divided by `other`.
     #