rdf 3.2.11 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ef89e587b939972de3597dc342a8833f6815f2a00e06369c3384337ff78523b
-  data.tar.gz: 91754a8af99feb95e0c2d318d89eefe8593c8ceded4cf89e90765e77d21811b8
+  metadata.gz: c90d17f92036ca2959a7be98c9cf5322374c0f0a623d4b44782bde2478eb2a65
+  data.tar.gz: ce40842adb100ff6d2ec068cc20b0320a30dab85b5a1a47056823e10fac59302
 SHA512:
-  metadata.gz: da439fdf65b894cf527b85f6ac5315e5fc6c2066c9e642cd36ed67bb1c674b766adbb23a345030d2dbb8af4af1054efc416ebcc8731a04ee803eae682fb34229
-  data.tar.gz: 9da07ff7cf54522a90a0a396a5f8cad5b6b89d373a2675db89a5287865ee80db1d0359d03c6a10f30313d7eb93f101673ba2ff87cef9695e2df929a04d4e481d
+  metadata.gz: 4ac4099d5eadff8676d0d692433d1dc3f9875032cf6617f7e0da53a559a53a88afbd6191be491c28204ca5475d007813858beefef2ac4b51f3a13c572b83aecb
+  data.tar.gz: 48688b3f9da835d74fed96bca2f60063da209db8567fb29932d878ab252c85fe0b4f08413ed627bd6cf95ec08ffc6447828c8f353ef897e055bbf5b786204a18

data/README.md

@@ -14,26 +14,28 @@ This is a pure-Ruby library for working with [Resource Description Framework
 
 1. [Features](#features)
 2. [Differences between RDF 1.0 and RDF 1.1](#differences-between-rdf-1-0-and-rdf-1-1)
-3. [Tutorials](#tutorials)
-4. [Command Line](#command-line)
-5. [Examples](#examples)
-6. [Reader/Writer convenience methods](#reader/writer-convenience-methods)
-7. [RDF* (RDFStar)](#rdf*-(rdfstar))
-8. [Documentation](#documentation)
-9. [Dependencies](#dependencies)
-10. [Installation](#installation)
-11. [Download](#download)
-12. [Resources](#resources)
-13. [Mailing List](#mailing-list)
-14. [Authors](#authors)
-15. [Contributors](#contributors)
-16. [Contributing](#contributing)
-17. [License](#license)
+3. [Differences between RDF 1.1 and RDF 1.2](#differences-between-rdf-1-1-and-rdf-1-2)
+4. [Tutorials](#tutorials)
+5. [Command Line](#command-line)
+6. [Examples](#examples)
+7. [Reader/Writer convenience methods](#reader/writer-convenience-methods)
+8. [RDF 1.2](#rdf\_12)
+9. [Documentation](#documentation)
+10. [Dependencies](#dependencies)
+11. [Installation](#installation)
+12. [Download](#download)
+13. [Resources](#resources)
+14. [Mailing List](#mailing-list)
+15. [Authors](#authors)
+16. [Contributors](#contributors)
+17. [Contributing](#contributing)
+18. [License](#license)
 
 ## Features
 
 * 100% pure Ruby with minimal dependencies and no bloat.
 * Fully compatible with [RDF 1.1][] specifications.
+* Provisional support for [RDF 1.2][] specifications.
 * 100% free and unencumbered [public domain](https://unlicense.org/) software.
 * Provides a clean, well-designed RDF object model and related APIs.
 * Supports parsing and serializing [N-Triples][] and [N-Quads][] out of the box, with more
@@ -45,11 +47,10 @@ This is a pure-Ruby library for working with [Resource Description Framework
   not modify any of Ruby's core classes or standard library.
 * Based entirely on Ruby's autoloading, meaning that you can generally make
   use of any one part of the library without needing to load up the rest.
-* Compatible with Ruby Ruby >= 2.4, Rubinius and JRuby 9.0+.
-  * Note, changes in mapping hashes to keyword arguments for Ruby 2.7+ may require that arguments be passed more explicitly, especially when the first argument is a Hash and there are optional keyword arguments. In this case, Hash argument may need to be explicitly included within `{}` and the optional keyword arguments may need to be specified using `**{}` if there are no keyword arguments.
+* Compatible with Ruby Ruby >= 3.0, Rubinius and JRuby 9.0+.
+  * Note, changes in mapping hashes to keyword arguments for Ruby 3+ may require that arguments be passed more explicitly, especially when the first argument is a Hash and there are optional keyword arguments. In this case, Hash argument may need to be explicitly included within `{}` and the optional keyword arguments may need to be specified using `**{}` if there are no keyword arguments.
 * Performs auto-detection of input to select appropriate Reader class if one
   cannot be determined from file characteristics.
-* Provisional support for [RDF*][].
 
 ### HTTP requests
 
@@ -102,6 +103,10 @@ the 1.1 release of RDF.rb:
 
 Notably, {RDF::Queryable#query} and {RDF::Query#execute} are now completely symmetric; this allows an implementation of {RDF::Queryable} to optimize queries using implementation-specific logic, allowing for substantial performance improvements when executing BGP queries.
 
+## Differences between RDF 1.1 and RDF 1.2
+* {RDF::Literal} has an optional `direction` property for directional language-tagged strings.
+* Removes support for legacy `text/plain` (as an alias for `application/n-triples`) and `text/x-nquads` (as an alias for `application/n-quads`)
+
 ## Tutorials
 
 * [Getting data from the Semantic Web using Ruby and RDF.rb](https://semanticweb.org/wiki/Getting_data_from_the_Semantic_Web_%28Ruby%29)
@@ -260,15 +265,16 @@ A separate [SPARQL][SPARQL doc] gem builds on basic BGP support to provide full
     foaf[:name]   #=> RDF::URI("http://xmlns.com/foaf/0.1/name")
     foaf['mbox']  #=> RDF::URI("http://xmlns.com/foaf/0.1/mbox")
 
-## RDF* (RDFStar)
+## RDF 1.2
 
-[RDF.rb][] includes provisional support for [RDF*][] with an N-Triples/N-Quads syntax extension that uses inline statements in the _subject_ or _object_ position.
+[RDF.rb][] includes provisional support for [RDF 1.2][] with an N-Triples/N-Quads syntax for quoted triples in the _subject_ or _object_ position.
+[RDF.rb][] includes provisional support for [RDF 1.2][] directional language-tagged strings, which are literals of type `rdf:dirLangString` having both a `language` and `direction`.
 
 Internally, an `RDF::Statement` is treated as another resource, along with `RDF::URI` and `RDF::Node`, which allows an `RDF::Statement` to have a `#subject` or `#object` which is also an `RDF::Statement`.
 
 **Note: This feature is subject to change or elimination as the standards process progresses.**
 
-### Serializing a Graph containing embedded statements
+### Serializing a Graph containing quoted triples
 
     require 'rdf/ntriples'
     statement = RDF::Statement(RDF::URI('bob'), RDF::Vocab::FOAF.age, RDF::Literal(23))
@@ -276,7 +282,7 @@ Internally, an `RDF::Statement` is treated as another resource, along with `RDF:
     graph.dump(:ntriples, validate: false)
     # => '<<<bob> <http://xmlns.com/foaf/0.1/age> "23"^^<http://www.w3.org/2001/XMLSchema#integer>>> <ex:certainty> "0.9"^^<http://www.w3.org/2001/XMLSchema#double> .'
 
-### Reading a Graph containing embedded statements
+### Reading a Graph containing quoted triples
 
 By default, the N-Triples reader will reject a document containing a subject resource.
 
@@ -286,13 +292,6 @@ By default, the N-Triples reader will reject a document containing a subject res
     end
     # => RDF::ReaderError
 
-Readers support a boolean valued `rdfstar` option.
-
-    graph = RDF::Graph.new do |graph|
-      RDF::NTriples::Reader.new(nt, rdfstar: true) {|reader| graph << reader}
-    end
-    graph.count #=> 1
-
 ## Documentation
 
 <https://ruby-rdf.github.io/rdf>
@@ -398,8 +397,9 @@ from BNode identity (i.e., they each entail the other)
 
 ## Dependencies
 
-* [Ruby](https://ruby-lang.org/) (>= 2.6)
+* [Ruby](https://ruby-lang.org/) (>= 3.0)
 * [LinkHeader][] (>= 0.0.8)
+* [bcp47_spec][] ( ~> 0.2)
 * Soft dependency on [RestClient][] (>= 2.1)
 
 ## Installation
@@ -407,7 +407,7 @@ from BNode identity (i.e., they each entail the other)
 The recommended installation method is via [RubyGems](https://rubygems.org/).
 To install the latest official release of RDF.rb, do:
 
-    % [sudo] gem install rdf             # Ruby 2.6+
+    % [sudo] gem install rdf             # Ruby 3+
 
 ## Download
 
@@ -481,8 +481,10 @@ This is free and unencumbered public domain software. For more information,
 see <https://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 
 [RDF]:              https://www.w3.org/RDF/
-[N-Triples]:        https://www.w3.org/TR/n-triples/
-[N-Quads]:          https://www.w3.org/TR/n-quads/
+[LinkHeader]:     https://github.com/asplake/link_header
+[bcp47_spec]:   https://github.com/dadah89/bcp47_spec
+[N-Triples]:        https://www.w3.org/TR/rdf-n-triples/
+[N-Quads]:          https://www.w3.org/TR/rdf-n-quads/
 [YARD]:             https://yardoc.org/
 [YARD-GS]:          https://rubydoc.info/docs/yard/file/docs/GettingStarted.md
 [PDD]:              https://unlicense.org/#unlicensing-contributions
@@ -496,6 +498,7 @@ see <https://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 [SPARQL doc]:       https://ruby-rdf.github.io/sparql
 [RDF 1.0]:          https://www.w3.org/TR/2004/REC-rdf-concepts-20040210/
 [RDF 1.1]:          https://www.w3.org/TR/rdf11-concepts/
+[RDF 1.2]:          https://www.w3.org/TR/rdf12-concepts/
 [SPARQL 1.1]:       https://www.w3.org/TR/sparql11-query/
 [RDF.rb]:           https://ruby-rdf.github.io/
 [RDF::DO]:          https://ruby-rdf.github.io/rdf-do
@@ -510,7 +513,6 @@ see <https://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 [RDF::TriX]:        https://ruby-rdf.github.io/rdf-trix
 [RDF::Turtle]:      https://ruby-rdf.github.io/rdf-turtle
 [RDF::Raptor]:      https://ruby-rdf.github.io/rdf-raptor
-[RDF*]:             https://w3c.github.io/rdf-star/rdf-star-cg-spec.html
 [LinkedData]:       https://ruby-rdf.github.io/linkeddata
 [JSON::LD]:         https://ruby-rdf.github.io/json-ld
 [RestClient]:       https://rubygems.org/gems/rest-client

data/VERSION

@@ -1 +1 @@
-3.2.11
+3.3.0

data/lib/rdf/cli.rb

@@ -60,7 +60,7 @@ module RDF
   #         RDF::CLI::Option.new(
   #           symbol: :canonicalize,
   #           on: ["--canonicalize"],
-  #           description: "Canonicalize input/output.") {true},
+  #           description: "Canonicalize URI/literal forms.") {true},
   #         RDF::CLI::Option.new(
   #           symbol: :uri,
   #           on: ["--uri STRING"],

data/lib/rdf/mixin/enumerable.rb

@@ -83,7 +83,8 @@ module RDF
     #   * `:literal_equality' preserves [term-equality](https://www.w3.org/TR/rdf11-concepts/#dfn-literal-term-equality) for literals. Literals are equal only if their lexical values and datatypes are equal, character by character. Literals may be "inlined" to value-space for efficiency only if `:literal_equality` is `false`.
     #   * `:validity` allows a concrete Enumerable implementation to indicate that it does or does not support valididty checking. By default implementations are assumed to support validity checking.
     #   * `:skolemize` supports [Skolemization](https://www.w3.org/wiki/BnodeSkolemization) of an `Enumerable`. Implementations supporting this feature must implement a `#skolemize` method, taking a base URI used for minting URIs for BNodes as stable identifiers and a `#deskolemize` method, also taking a base URI used for turning URIs having that prefix back into the same BNodes which were originally skolemized.
-    #   * `:rdfstar` supports RDF* where statements may be subjects or objects of other statements.
+    #   * `:quoted_triples` supports RDF 1.2 quoted triples.
+    #   * `:base_direction` supports RDF 1.2 directional language-tagged strings.
     #
     # @param  [Symbol, #to_sym] feature
     # @return [Boolean]
@@ -720,13 +721,33 @@ module RDF
     end
     alias_method :enum_graphs, :enum_graph
 
+    ##
+    # Enumerates each statement using its canonical representation.
+    #
+    # @note This is updated by `RDF::Normalize` to also canonicalize blank nodes.
+    #
+    # @return [RDF::Enumerable]
+    def canonicalize
+      this = self
+      Enumerable::Enumerator.new do |yielder|
+        this.send(:each_statement) {|y| yielder << y.canonicalize}
+      end
+    end
+
+    ##
+    # Mutating canonicalization not supported
+    #
+    # @raise NotImplementedError
+    def canonicalize!
+      raise NotImplementedError, "Canonicalizing enumerables not supported"
+    end
+
     ##
     # Returns all RDF statements in `self` as an array.
     #
     # Mixes in `RDF::Enumerable` into the returned object.
     #
     # @return [Array]
-    # @since  0.2.0
     def to_a
       super.extend(RDF::Enumerable)
     end

data/lib/rdf/mixin/queryable.rb

@@ -140,7 +140,7 @@ module RDF
     # method in order to provide for storage-specific optimized triple
     # pattern matching.
     #
-    # ## RDFStar (RDF*)
+    # ## RDF-star
     #
     # Statements may have embedded statements as either a subject or object, recursively.
     #

data/lib/rdf/mixin/writable.rb

@@ -127,8 +127,11 @@ module RDF
     def insert_statements(statements)
       each = statements.respond_to?(:each_statement) ? :each_statement : :each
       statements.__send__(each) do |statement|
-        if statement.embedded? && respond_to?(:supports?) && !supports?(:rdfstar)
-          raise ArgumentError, "Wriable does not support embedded statements"
+        if statement.embedded? && respond_to?(:supports?) && !supports?(:quoted_triples)
+          raise ArgumentError, "Writable does not support quoted triples"
+        end
+        if statement.object && statement.object.literal? && statement.object.direction? && !supports?(:base_direction)
+          raise ArgumentError, "Writable does not support directional languaged-tagged strings"
         end
         insert_statement(statement)
       end

data/lib/rdf/model/dataset.rb

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

data/lib/rdf/model/graph.rb

@@ -305,8 +305,11 @@ module RDF
     # @private
     # @see RDF::Mutable#insert
     def insert_statement(statement)
-      if statement.embedded? && !@data.supports?(:rdfstar)
-        raise ArgumentError, "Graph does not support embedded statements"
+      if statement.embedded? && !@data.supports?(:quoted_triples)
+        raise ArgumentError, "Graph does not support quoted triples"
+      end
+      if statement.object && statement.object.literal? && statement.object.direction? &&  !@data.supports?(:base_direction)
+        raise ArgumentError, "Graph does not support directional languaged-tagged strings"
       end
       statement = statement.dup
       statement.graph_name = graph_name

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

@@ -26,7 +26,7 @@ module RDF; class Literal
         when value.is_a?(::Numeric)    then BigDecimal(value)
         else
           value = value.to_s
-          value += "0" if value.end_with?(".")  # Normalization required in Ruby 2.4
+          value += "0" if value.end_with?(".")
           BigDecimal(value) rescue BigDecimal(0)
       end
     end

data/lib/rdf/model/literal.rb

@@ -1,4 +1,7 @@
 # -*- encoding: utf-8 -*-
+
+require 'bcp47_spec'
+
 module RDF
   ##
   # An RDF literal.
@@ -9,7 +12,9 @@ module RDF
   #
   # Specific typed literals may have behavior different from the default implementation. See the following defined sub-classes for specific documentation. Additional sub-classes may be defined, and will interoperate by defining `DATATYPE` and `GRAMMAR` constants, in addition other required overrides of RDF::Literal behavior.
   #
-  # In RDF 1.1, all literals are typed, including plain literals and language tagged literals. Internally, plain literals are given the `xsd:string` datatype and language tagged literals are given the `rdf:langString` datatype. Creating a plain literal, without a datatype or language, will automatically provide the `xsd:string` datatype; similar for language tagged literals. Note that most serialization formats will remove this datatype. Code which depends on a literal having the `xsd:string` datatype being different from a plain literal (formally, without a datatype) may break. However note that the `#has\_datatype?` will continue to return `false` for plain or language-tagged literals.
+  # In RDF 1.1, all literals are typed, including plain literals and language-tagged strings. Internally, plain literals are given the `xsd:string` datatype and language-tagged strings are given the `rdf:langString` datatype. Creating a plain literal, without a datatype or language, will automatically provide the `xsd:string` datatype; similar for language-tagged strings. Note that most serialization formats will remove this datatype. Code which depends on a literal having the `xsd:string` datatype being different from a plain literal (formally, without a datatype) may break. However note that the `#has\_datatype?` will continue to return `false` for plain or language-tagged strings.
+  #
+  # RDF 1.2 adds **directional language-tagged strings** which are effectively a subclass of **language-tagged strings** contining an additional **direction** component with value either **ltr** or **rtl** for Left-to-Right or Right-to-Left. This determines the general direction of a string when presented in n a user agent, where it might be in conflict with the inherent direction of the leading Unicode code points. Directional language-tagged strings are given the `rdf:langString` datatype.
   #
   # * {RDF::Literal::Boolean}
   # * {RDF::Literal::Date}
@@ -23,16 +28,23 @@ module RDF
   #   value = RDF::Literal.new("Hello, world!")
   #   value.plain?                                   #=> true`
   #
-  # @example Creating a language-tagged literal (1)
+  # @example Creating a language-tagged string (1)
   #   value = RDF::Literal.new("Hello!", language: :en)
   #   value.language?                                #=> true
   #   value.language                                 #=> :en
   #
-  # @example Creating a language-tagged literal (2)
+  # @example Creating a language-tagged string (2)
   #   RDF::Literal.new("Wazup?", language: :"en-US")
   #   RDF::Literal.new("Hej!",   language: :sv)
   #   RDF::Literal.new("¡Hola!", language: :es)
   #
+  # @example Creating a directional language-tagged string
+  #   value = RDF::Literal.new("Hello!", language: :en, direction: :ltr)
+  #   value.language?                                #=> true
+  #   value.language                                 #=> :en
+  #   value.direction?                               #=> true
+  #   value.direction                                #=> :ltr
+  #
   # @example Creating an explicitly datatyped literal
   #   value = RDF::Literal.new("2009-12-31", datatype: RDF::XSD.date)
   #   value.datatype?                                #=> true
@@ -105,8 +117,14 @@ module RDF
 
     ##
     # @private
-    def self.new(value, language: nil, datatype: nil, lexical: nil, validate: false, canonicalize: false, **options)
-      raise ArgumentError, "datatype with language must be rdf:langString" if language && (datatype || RDF.langString).to_s != RDF.langString.to_s
+    def self.new(value, language: nil, datatype: nil, direction: nil, lexical: nil, validate: false, canonicalize: false, **options)
+      if language && direction
+        raise ArgumentError, "datatype with language and direction must be rdf:dirLangString" if (datatype || RDF.dirLangString).to_s != RDF.dirLangString.to_s
+      elsif language
+        raise ArgumentError, "datatype with language must be rdf:langString" if (datatype || RDF.langString).to_s != RDF.langString.to_s
+      else
+        raise ArgumentError, "datatype not compatible with language or direction" if language || direction
+      end
 
       klass = case
         when !self.equal?(RDF::Literal)
@@ -128,7 +146,7 @@ module RDF
         end
       end
       literal = klass.allocate
-      literal.send(:initialize, value, language: language, datatype: datatype, **options)
+      literal.send(:initialize, value, language: language, datatype: datatype, direction: direction, **options)
       literal.validate!     if validate
       literal.canonicalize! if canonicalize
       literal
@@ -137,18 +155,24 @@ module RDF
     TRUE  = RDF::Literal.new(true)
     FALSE = RDF::Literal.new(false)
     ZERO  = RDF::Literal.new(0)
+    XSD_STRING = RDF::URI("http://www.w3.org/2001/XMLSchema#string")
 
-    # @return [Symbol] The language tag (optional).
+    # @return [Symbol] The language-tag (optional). Implies `datatype` is `rdf:langString`.
     attr_accessor :language
 
+    # @return [Symbol] The base direction (optional). Implies `datatype` is `rdf:dirLangString`.
+    attr_accessor :direction
+
     # @return [URI] The XML Schema datatype URI (optional).
     attr_accessor :datatype
 
     ##
-    # Literals without a datatype are given either xsd:string or rdf:langString
-    # depending on if there is language
+    # Literals without a datatype are given either `xsd:string`, `rdf:langString`, or `rdf:dirLangString`,
+    # depending on if there is `language` and/or `direction`.
     #
     # @param  [Object] value
+    # @param  [Symbol]  direction (nil)
+    #   Initial text direction.
     # @param  [Symbol]  language (nil)
     #   Language is downcased to ensure proper matching
     # @param [String]  lexical (nil)
@@ -163,16 +187,24 @@ module RDF
     # @see http://www.w3.org/TR/rdf11-concepts/#section-Graph-Literal
     # @see http://www.w3.org/TR/rdf11-concepts/#section-Datatypes
     # @see #to_s
-    def initialize(value, language: nil, datatype: nil, lexical: nil, validate: false, canonicalize: false, **options)
+    def initialize(value, language: nil, datatype: nil, direction: nil, lexical: nil, validate: false, canonicalize: false, **options)
       @object   = value.freeze
       @string   = lexical if lexical
       @string   = value if !defined?(@string) && value.is_a?(String)
       @string   = @string.encode(Encoding::UTF_8).freeze if instance_variable_defined?(:@string)
       @object   = @string if instance_variable_defined?(:@string) && @object.is_a?(String)
       @language = language.to_s.downcase.to_sym if language
+      @direction = direction.to_s.downcase.to_sym if direction
       @datatype = RDF::URI(datatype).freeze if datatype
       @datatype ||= self.class.const_get(:DATATYPE) if self.class.const_defined?(:DATATYPE)
-      @datatype ||= instance_variable_defined?(:@language) && @language ? RDF.langString : RDF::URI("http://www.w3.org/2001/XMLSchema#string")
+      @datatype ||= if instance_variable_defined?(:@language) && @language &&
+                       instance_variable_defined?(:@direction) && @direction
+        RDF.dirLangString
+      elsif instance_variable_defined?(:@language) && @language
+        RDF.langString
+      else
+        XSD_STRING
+      end
     end
 
     ##
@@ -202,8 +234,8 @@ module RDF
     #
     # Compatibility of two arguments is defined as:
     # * 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
+    # * The arguments are plain literals with identical language-tags and directions
+    # * The first argument is a plain literal with language-tag and the second argument is a simple literal or literal typed as xsd:string
     #
     # @example
     #     compatible?("abc"	"b")                         #=> true
@@ -224,11 +256,11 @@ module RDF
       return false unless other.literal? && plain? && other.plain?
 
       # * 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
-      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")
+      # * 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
+      language? || direction? ?
+        (language == other.language && direction == other.direction || other.datatype == XSD_STRING) :
+        other.datatype == XSD_STRING
     end
 
     ##
@@ -236,7 +268,7 @@ module RDF
     #
     # @return [Integer]
     def hash
-      @hash ||= [to_s, datatype, language].hash
+      @hash ||= [to_s, datatype, language, direction].compact.hash
     end
 
 
@@ -270,6 +302,7 @@ module RDF
          self.value_hash == other.value_hash &&
          self.value.eql?(other.value) &&
          self.language.to_s.eql?(other.language.to_s) &&
+         self.direction.to_s.eql?(other.direction.to_s) &&
          self.datatype.eql?(other.datatype))
     end
 
@@ -290,7 +323,10 @@ module RDF
         case
         when self.eql?(other)
           true
-        when self.language? && self.language.to_s == other.language.to_s
+        when self.direction? && self.direction == other.direction
+          # Literals with directions can compare if languages and directions are identical
+          self.value_hash == other.value_hash && self.value == other.value
+        when self.language? && self.language == other.language
           # Literals with languages can compare if languages are identical
           self.value_hash == other.value_hash && self.value == other.value
         when self.simple? && other.simple?
@@ -342,14 +378,18 @@ module RDF
 
     ##
     # Returns `true` if this is a plain literal. A plain literal
-    # may have a language, but may not have a datatype. For
+    # may have a language and direction, but may not have a datatype. For
     # all practical purposes, this includes xsd:string literals
     # too.
     #
     # @return [Boolean] `true` or `false`
     # @see http://www.w3.org/TR/rdf-concepts/#dfn-plain-literal
     def plain?
-      [RDF.langString, RDF::URI("http://www.w3.org/2001/XMLSchema#string")].include?(datatype)
+      [
+        RDF.langString,
+        RDF.dirLangString,
+        XSD_STRING
+      ].include?(datatype)
     end
 
     ##
@@ -359,19 +399,28 @@ module RDF
     # @return [Boolean] `true` or `false`
     # @see http://www.w3.org/TR/sparql11-query/#simple_literal
     def simple?
-      datatype == RDF::URI("http://www.w3.org/2001/XMLSchema#string")
+      datatype == XSD_STRING
     end
 
     ##
-    # Returns `true` if this is a language-tagged literal.
+    # Returns `true` if this is a language-tagged string.
     #
     # @return [Boolean] `true` or `false`
-    # @see http://www.w3.org/TR/rdf-concepts/#dfn-plain-literal
+    # @see https://www.w3.org/TR/rdf-concepts/#dfn-language-tagged-string
     def language?
-      datatype == RDF.langString
+      [RDF.langString, RDF.dirLangString].include?(datatype)
     end
     alias_method :has_language?, :language?
 
+    ##
+    # Returns `true` if this is a directional language-tagged string.
+    #
+    # @return [Boolean] `true` or `false`
+    # @see https://www.w3.org/TR/rdf-concepts/#dfn-dir-lang-string
+    def direction?
+      datatype == RDF.dirLangString
+    end
+
     ##
     # Returns `true` if this is a datatyped literal.
     #
@@ -380,7 +429,7 @@ module RDF
     # @return [Boolean] `true` or `false`
     # @see http://www.w3.org/TR/rdf-concepts/#dfn-typed-literal
     def datatype?
-      !plain? && !language?
+      !plain? && !language? && !direction?
     end
     alias_method :has_datatype?,  :datatype?
     alias_method :typed?,         :datatype?
@@ -393,10 +442,13 @@ module RDF
     # @return [Boolean] `true` or `false`
     # @since  0.2.1
     def valid?
-      return false if language? && language.to_s !~ /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/
+      BCP47.parse(language.to_s) if language?
+      return false if direction? && !%i{ltr rtl}.include?(direction)
       return false if datatype? && datatype.invalid?
       grammar = self.class.const_get(:GRAMMAR) rescue nil
       grammar.nil? || value.match?(grammar)
+    rescue BCP47::InvalidLanguageTag
+      false
     end
 
     ##
@@ -536,12 +588,12 @@ module RDF
 
     ##
     # @overload #to_str
-    #   This method is implemented when the datatype is `xsd:string` or `rdf:langString`
+    #   This method is implemented when the datatype is `xsd:string`, `rdf:langString`, or `rdf:dirLangString`
     #   @return [String]
     def method_missing(name, *args)
       case name
       when :to_str
-        return to_s if @datatype == RDF.langString || @datatype == RDF::URI("http://www.w3.org/2001/XMLSchema#string")
+        return to_s if [RDF.langString, RDF.dirLangString, XSD_STRING].include?(@datatype)
       end
       super
     end
@@ -549,7 +601,7 @@ module RDF
     def respond_to_missing?(name, include_private = false)
       case name
       when :to_str
-        return true if @datatype == RDF.langString || @datatype == RDF::URI("http://www.w3.org/2001/XMLSchema#string")
+        return true if [RDF.langString, RDF.dirLangString, XSD_STRING].include?(@datatype)
       end
       super
     end

data/lib/rdf/model/statement.rb

@@ -182,6 +182,7 @@ module RDF
     ##
     # Returns `true` if any element of the statement is, itself, a statement.
     #
+    # Note: Nomenclature is evolving, alternatives could include `#complex?` and `#nested?`
     # @return [Boolean]
     def embedded?
       subject && subject.statement? || object && object.statement?
@@ -410,7 +411,7 @@ module RDF
     end
 
     ##
-    # Canonicalizes each unfrozen term in the statement
+    # Canonicalizes each unfrozen term in the statement.
     #
     # @return [RDF::Statement] `self`
     # @since  1.0.8
@@ -436,6 +437,18 @@ module RDF
       nil
     end
 
+    # New statement with duplicated components (other than blank nodes)
+    #
+    # @return [RDF::Statement]
+    def dup
+      options = Hash[@options]
+      options[:subject] = subject.is_a?(RDF::Node) ? subject : subject.dup
+      options[:predicate] = predicate.dup
+      options[:object] = object.is_a?(RDF::Node) ? object : object.dup
+      options[:graph_name] = graph_name.is_a?(RDF::Node) ? graph_name : graph_name.dup if graph_name
+      RDF::Statement.new(options)
+    end
+
     ##
     # Returns the terms of this statement as a `Hash`.
     #

data/lib/rdf/nquads.rb

@@ -22,7 +22,6 @@ module RDF
     class Format < RDF::Format
       content_type     'application/n-quads',
                        extension: :nq,
-                       alias: 'text/x-nquads;q=0.2',
                        uri: RDF::URI("http://www.w3.org/ns/formats/N-Quads")
       content_encoding 'utf-8'
 

data/lib/rdf/ntriples/format.rb

@@ -18,7 +18,6 @@ module RDF::NTriples
   class Format < RDF::Format
     content_type     'application/n-triples',
                      extension: :nt,
-                     alias: 'text/plain;q=0.2',
                      uri: RDF::URI("http://www.w3.org/ns/formats/N-Triples")
     content_encoding 'utf-8'
 

data/lib/rdf/ntriples/reader.rb

@@ -28,7 +28,7 @@ module RDF::NTriples
   #     end
   #   end
   #
-  # ** RDFStar (RDF*)
+  # ** RDF=star
   #
   # Supports statements as resources using `<<s p o>>`.
   #
@@ -60,24 +60,16 @@ module RDF::NTriples
     U_CHARS2         = Regexp.compile("\\u00B7|[\\u0300-\\u036F]|[\\u203F-\\u2040]").freeze
     IRI_RANGE        = Regexp.compile("[[^<>\"{}\|\^`\\\\]&&[^\\x00-\\x20]]").freeze
 
-    # 163s
     PN_CHARS_BASE        = /[A-Z]|[a-z]|#{U_CHARS1}/.freeze
-    # 164s
     PN_CHARS_U           = /_|#{PN_CHARS_BASE}/.freeze
-    # 166s
     PN_CHARS             = /-|[0-9]|#{PN_CHARS_U}|#{U_CHARS2}/.freeze
-    # 159s
     ECHAR                = /\\[tbnrf"'\\]/.freeze
-    # 18
+
     IRIREF               = /<((?:#{IRI_RANGE}|#{UCHAR})*)>/.freeze
-    # 141s
     BLANK_NODE_LABEL     = /_:((?:[0-9]|#{PN_CHARS_U})(?:(?:#{PN_CHARS}|\.)*#{PN_CHARS})?)/.freeze
-    # 144s
-    LANGTAG              = /@([a-zA-Z]+(?:-[a-zA-Z0-9]+)*)/.freeze
-    # 22
+    LANG_DIR             = /@([a-zA-Z]+(?:-[a-zA-Z0-9]+)*(?:--[a-zA-Z]+)?)/.freeze
     STRING_LITERAL_QUOTE = /"((?:[^\"\\\n\r]|#{ECHAR}|#{UCHAR})*)"/.freeze
 
-    # RDF*
     ST_START              = /^<</.freeze
     ST_END                = /^\s*>>/.freeze
 
@@ -86,7 +78,7 @@ module RDF::NTriples
     NODEID                = /^#{BLANK_NODE_LABEL}/.freeze
     URIREF                = /^#{IRIREF}/.freeze
     LITERAL_PLAIN         = /^#{STRING_LITERAL_QUOTE}/.freeze
-    LITERAL_WITH_LANGUAGE = /^#{STRING_LITERAL_QUOTE}#{LANGTAG}/.freeze
+    LITERAL_WITH_LANGUAGE = /^#{STRING_LITERAL_QUOTE}#{LANG_DIR}/.freeze
     LITERAL_WITH_DATATYPE = /^#{STRING_LITERAL_QUOTE}\^\^#{IRIREF}/.freeze
     DATATYPE_URI          = /^\^\^#{IRIREF}/.freeze
     LITERAL               = Regexp.union(LITERAL_WITH_LANGUAGE, LITERAL_WITH_DATATYPE, LITERAL_PLAIN).freeze
@@ -95,6 +87,9 @@ module RDF::NTriples
     OBJECT                = Regexp.union(URIREF, NODEID, LITERAL).freeze
     END_OF_STATEMENT      = /^\s*\.\s*(?:#.*)?$/.freeze
 
+    # LANGTAG is deprecated
+    LANGTAG               = LANG_DIR
+
     ##
     # Reconstructs an RDF value from its serialized N-Triples
     # representation.
@@ -299,8 +294,10 @@ module RDF::NTriples
       if literal_str = match(LITERAL_PLAIN)
         literal_str = self.class.unescape(literal_str)
         literal = case
-          when language = match(LANGTAG)
-            RDF::Literal.new(literal_str, language: language)
+          when lang_dir = match(LANG_DIR)
+            language, direction = lang_dir.split('--')
+            raise ArgumentError if direction && !@options[:rdfstar]
+            RDF::Literal.new(literal_str, language: language, direction: direction)
           when datatype = match(/^(\^\^)/) # FIXME
             RDF::Literal.new(literal_str, datatype: read_uriref || fail_object)
           else
@@ -310,6 +307,10 @@ module RDF::NTriples
         literal.canonicalize! if canonicalize?
         literal
       end
+    rescue ArgumentError
+      v = literal_str
+      v += "@#{lang_dir}" if lang_dir
+      log_error("Invalid Literal (found: \"#{v}\")", lineno: lineno, token: "#v", exception: RDF::ReaderError)
     end
 
     ##

data/lib/rdf/ntriples/writer.rb

@@ -224,7 +224,7 @@ module RDF::NTriples
     end
 
     ##
-    # Returns the N-Triples representation of an RDF* reified statement.
+    # Returns the N-Triples representation of an RDF-star quoted triple.
     #
     # @param  [RDF::Statement] statement
     # @param  [Hash{Symbol => Object}] options ({})
@@ -312,6 +312,7 @@ module RDF::NTriples
           # Note, escaping here is more robust than in Term
           text = quoted(escaped(literal.value))
           text << "@#{literal.language}" if literal.language?
+          text << "--#{literal.direction}" if literal.direction?
           text << "^^<#{uri_for(literal.datatype)}>" if literal.datatype?
           text
         else

data/lib/rdf/ntriples.rb

@@ -8,14 +8,14 @@ module RDF
   # [Turtle](http://www.w3.org/TeamSubmission/turtle/) and
   # [Notation3](http://www.w3.org/TeamSubmission/n3/) (N3).
   #
-  # The MIME content type for N-Triples files is `text/plain` and the
+  # The MIME content type for N-Triples files is `application/n-triples` and the
   # recommended file extension is `.nt`.
   #
   # An example of an RDF statement in N-Triples format:
   #
   #     <https://rubygems.org/gems/rdf> <http://purl.org/dc/terms/title> "rdf" .
   #
-  # ## RDFStar (RDF*)
+  # ## Quoted Triples
   #
   # Supports statements as resources using `<<s p o>>`.
   #

data/lib/rdf/query/solution.rb

@@ -209,7 +209,7 @@ class RDF::Query
     # Merges the bindings from the given `other` query solution into this
     # one, overwriting any existing ones having the same name.
     #
-    # ## RDFStar (RDF*)
+    # ## RDF-star
     #
     # If merging a binding for a statement to a pattern,
     # merge their embedded solutions.

data/lib/rdf/reader.rb

@@ -133,7 +133,7 @@ module RDF
           on: ["--canonicalize"],
           control: :checkbox,
           default: false,
-          description: "Canonicalize input/output.") {true},
+          description: "Canonicalize URI/literal forms") {true},
         RDF::CLI::Option.new(
           symbol: :encoding,
           datatype: Encoding,
@@ -163,7 +163,7 @@ module RDF
           datatype: TrueClass,
           control: :checkbox,
           on: ["--rdfstar"],
-          description: "Parse RDF*."),
+          description: "Parse RDF-star for preliminary RDF 1.2 support."),
         RDF::CLI::Option.new(
           symbol: :validate,
           datatype: TrueClass,
@@ -271,13 +271,13 @@ module RDF
     #   the base URI to use when resolving relative URIs (not supported by
     #   all readers)
     # @param [Boolean]  canonicalize (false)
-    #   whether to canonicalize parsed literals
+    #   whether to canonicalize parsed URIs and Literals.
     # @param [Encoding] encoding     (Encoding::UTF_8)
     #   the encoding of the input stream
     # @param [Boolean]  intern       (true)
     #   whether to intern all parsed URIs
     # @param [Boolean] rdfstar      (false)
-    #   support parsing RDF* statement resources.
+    #   Preliminary support for RDF 1.2.
     # @param [Hash]     prefixes     (Hash.new)
     #   the prefix mappings to use (not supported by all readers)
     # @param  [Hash{Symbol => Object}] options
@@ -608,7 +608,9 @@ module RDF
     end
 
     ##
-    # Returns `true` if parsed values should be canonicalized.
+    # Returns `true` if parsed values should be in canonical form.
+    #
+    # @note This is for term canonicalization, for graph/dataset canonicalization use `RDF::Normalize`.
     #
     # @return [Boolean] `true` or `false`
     # @since  0.3.0

data/lib/rdf/repository.rb

@@ -182,7 +182,8 @@ module RDF
       when :validity         then @options.fetch(:with_validity, true)
       when :literal_equality then true
       when :atomic_write     then false
-      when :rdfstar          then false
+      when :quoted_triples   then false
+      when :base_direction   then false
       when :snapshots        then false
       else false
       end
@@ -269,7 +270,8 @@ module RDF
         when :validity         then @options.fetch(:with_validity, true)
         when :literal_equality then true
         when :atomic_write     then true
-        when :rdfstar          then true
+        when :quoted_triples   then true
+        when :base_direction   then true
         when :snapshots        then true
         else false
         end

data/lib/rdf/util/cache.rb

@@ -110,7 +110,7 @@ module RDF; module Util
 
     ##
     # This implementation uses the `WeakRef` class from Ruby's standard
-    # library, and provides adequate performance on JRuby and on Ruby 2.x.
+    # library, and provides adequate performance on JRuby and on Ruby 3.x.
     #
     # @see http://ruby-doc.org/stdlib-2.2.0/libdoc/weakref/rdoc/WeakRef.html
     class WeakRefCache < Cache

data/lib/rdf/vocab/rdfv.rb

@@ -92,6 +92,10 @@ module RDF
   #     # @return [RDF::Vocabulary::Term]
   #     # @attr_reader :langString
   #
+  #     # The datatype of directional language-tagged string values.
+  #     # @return [RDF::Vocabulary::Term]
+  #     # @attr_reader :dirLangString
+  #
   #     # RDF/XML node element.
   #     # @return [RDF::Vocabulary::Term]
   #     # @attr_reader :Description
@@ -283,6 +287,13 @@ module RDF
       "http://www.w3.org/2000/01/rdf-schema#seeAlso": %(http://www.w3.org/TR/rdf11-concepts/#section-Graph-Literal).freeze,
       subClassOf: "http://www.w3.org/2000/01/rdf-schema#Literal".freeze,
       type: "http://www.w3.org/2000/01/rdf-schema#Datatype".freeze
+    term :dirLangString,
+      comment: %(The datatype of directional language-tagged string values).freeze,
+      label: "dirLangString".freeze,
+      isDefinedBy: %(http://www.w3.org/1999/02/22-rdf-syntax-ns#).freeze,
+      "http://www.w3.org/2000/01/rdf-schema#seeAlso": %(http://www.w3.org/TR/rdf11-concepts/#section-Graph-Literal).freeze,
+      subClassOf: "http://www.w3.org/2000/01/rdf-schema#Literal".freeze,
+      type: "http://www.w3.org/2000/01/rdf-schema#Datatype".freeze
 
     # Extra definitions
    term :Description,

data/lib/rdf/writer.rb

@@ -392,7 +392,9 @@ module RDF
     end
 
     ##
-    # Returns `true` if terms should be canonicalized.
+    # Returns `true` if terms should be in canonical form.
+    #
+    # @note This is for term canonicalization, for graph/dataset canonicalization use `RDF::Normalize`.
     #
     # @return [Boolean] `true` or `false`
     # @since  1.0.8

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdf
 version: !ruby/object:Gem::Version
-  version: 3.2.11
+  version: 3.3.0
 platform: ruby
 authors:
 - Arto Bendiken
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-07 00:00:00.000000000 Z
+date: 2023-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: link_header
@@ -32,68 +32,76 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.0.8
+- !ruby/object:Gem::Dependency
+  name: bcp47_spec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: rdf-spec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: rdf-turtle
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: rdf-vocab
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: rdf-xsd
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.2.1
+        version: '3.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.2.1
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: rest-client
   requirement: !ruby/object:Gem::Requirement
@@ -142,14 +150,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.18'
+        version: '3.19'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.18'
+        version: '3.19'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -287,14 +295,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.6'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: A Ruby library for working with Resource Description Framework (RDF) data.