rdf 3.2.10 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 948292ebb4f6e10c59b67e873d2d14884c53c5fab199e901e4e4dadf768f379f
-  data.tar.gz: 8731942201a15bcef71284fe0a79a3bc9a97b878ef2c53b757869cadefdadf54
+  metadata.gz: c90d17f92036ca2959a7be98c9cf5322374c0f0a623d4b44782bde2478eb2a65
+  data.tar.gz: ce40842adb100ff6d2ec068cc20b0320a30dab85b5a1a47056823e10fac59302
 SHA512:
-  metadata.gz: 41d8fca7513dc56c6447b3b40d995b04f407e986ffc4e1a7fc86de7632ca026b6effdb8e7d3d815ba7ddb27c44e6af53a08bbde43390a065170e9a58446231d8
-  data.tar.gz: 5c9895f52363ffee6bc408d5e476a9a345d7aec62ec8594a8ca49f5c3ef9016f307741c0ef8b537d6fc49f714a25d2a4b0bee64631951191c750ef53809533c4
+  metadata.gz: 4ac4099d5eadff8676d0d692433d1dc3f9875032cf6617f7e0da53a559a53a88afbd6191be491c28204ca5475d007813858beefef2ac4b51f3a13c572b83aecb
+  data.tar.gz: 48688b3f9da835d74fed96bca2f60063da209db8567fb29932d878ab252c85fe0b4f08413ed627bd6cf95ec08ffc6447828c8f353ef897e055bbf5b786204a18

data/README.md

@@ -5,7 +5,7 @@ This is a pure-Ruby library for working with [Resource Description Framework
 
 * <https://ruby-rdf.github.io/rdf>
 
-[![Gem Version](https://badge.fury.io/rb/rdf.png)](https://badge.fury.io/rb/rdf)
+[![Gem Version](https://badge.fury.io/rb/rdf.svg)](https://badge.fury.io/rb/rdf)
 [![Build Status](https://github.com/ruby-rdf/rdf/workflows/CI/badge.svg?branch=develop)](https://github.com/ruby-rdf/rdf/actions?query=workflow%3ACI)
 [![Coverage Status](https://coveralls.io/repos/ruby-rdf/rdf/badge.svg?branch=develop)](https://coveralls.io/github/ruby-rdf/rdf?branch=develop)
 [![Gitter chat](https://badges.gitter.im/ruby-rdf/rdf.png)](https://gitter.im/ruby-rdf/rdf)
@@ -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.10
+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/list.rb

@@ -280,19 +280,6 @@ module RDF
       end
     end
 
-    ##
-    # Returns the element at `index`.
-    #
-    # @example
-    #   RDF::List[1, 2, 3][0]                   #=> RDF::Literal(1)
-    #
-    # @param  [Integer] index
-    # @return [RDF::Term]
-    # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-5B-5D
-    def [](index)
-      at(index)
-    end
-
     ##
     # Element Assignment — Sets the element at `index`, or replaces a subarray from the `start` index for `length` elements, or replaces a subarray specified by the `range` of indices.
     #

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`.
     #