rdf 3.1.10 → 3.1.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5de713395026fd70491ac47ef4c5c89e63681bccf27d8b9e39fe21fcf63c1344
-  data.tar.gz: a2bc97b12d11858f4089fba2915f358ba28db0bb4704ce70e668f17c80e9a739
+  metadata.gz: 8747674533ca06af62b3ee536ea4342be3c8bedc8831b1a1838e244d927263cb
+  data.tar.gz: fbc0593916678f9f696d4c461b29df01549da5af7d436b700d66735f5350054d
 SHA512:
-  metadata.gz: 334cf936abb27e4c0a8fe225c4bd309b455ab96fcf1e79369abe3a763b28e922172b5d477a9a2112677f3ae21d8b3a0fdb9696d6d89bb6ce85bf49831464f611
-  data.tar.gz: 76d46e91f93f70e021f482b089fb4a5afebb955e835d89965e270688a46fb938a5b1e334d2c0e5d9992a149de97bb84c5f14e8f4da62019aaa7bec7fcb7f582e
+  metadata.gz: fb56f5b72af92421afb2216ca5d1dec10907860a2f1ad069e4d69e37ee3126219dfb0c60fab256c1088424b9a8dcc42f6637e98b1c52258cc88163b394e06fc5
+  data.tar.gz: dcd897b9313decf48df3a89d4e8885ac74da1b966d194c28faa56a2edff2f4b123d093322655985ae1c0c059c6e8e49be9f18bbc9b1ef9c87634394d9090064b

data/README.md

@@ -10,6 +10,26 @@ This is a pure-Ruby library for working with [Resource Description Framework
 [![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)
 
+## Table of contents
+
+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)
+
 ## Features
 
 * 100% pure Ruby with minimal dependencies and no bloat.
@@ -41,7 +61,7 @@ middleware.
 
 See {RDF::Util::File} for configuring other mechanisms for retrieving resources.
 
-### Term caching and configuration.
+### Term caching and configuration
 
 RDF.rb uses a weak-reference cache for storing internalized versions of URIs and Nodes. This is particularly useful for Nodes as two nodes are equivalent only if they're the same node.
 
@@ -76,7 +96,7 @@ the 1.1 release of RDF.rb:
 * {RDF::Util::File.open\_file} now performs redirects and manages `base_uri` based on W3C recommendations:
   * `base_uri` is set to the original URI if a status 303 is provided, otherwise any other redirect will set `base_uri` to the redirected location.
   * `base_uri` is set to the content of the `Location` header if status is _success_.
-* Additionally, {RDF::Util::File.open\_file} sets the result encoding from `charset` if provided, defaulting to `UTF-8`. Other access methods include `last_modified` and `content_type`, 
+* Additionally, {RDF::Util::File.open\_file} sets the result encoding from `charset` if provided, defaulting to `UTF-8`. Other access methods include `last_modified` and `content_type`,
 * {RDF::StrictVocabulary} added with an easy way to keep vocabulary definitions up to date based on their OWL or RDFS definitions. Most vocabularies are now StrictVocabularies meaning that an attempt to resolve a particular term in that vocabulary will error if the term is not defined in the vocabulary.
 * New vocabulary definitions have been added for [ICal](http://www.w3.org/2002/12/cal/icaltzd#), [Media Annotations (MA)](http://www.w3.org/ns/ma-ont#), [Facebook OpenGraph (OG)](http://ogp.me/ns#), [PROV](http://www.w3.org/ns/prov#), [SKOS-XL (SKOSXL)](http://www.w3.org/2008/05/skos-xl#), [Data Vocabulary (V)](http://rdf.data-vocabulary.org/), [VCard](http://www.w3.org/2006/vcard/ns#), [VOID](http://rdfs.org/ns/void#http://rdfs.org/ns/void#), [Powder-S (WDRS)](http://www.w3.org/2007/05/powder-s#), and [XHV](http://www.w3.org/1999/xhtml/vocab#).
 
@@ -89,6 +109,7 @@ Notably, {RDF::Queryable#query} and {RDF::Query#execute} are now completely symm
 * [Getting started with RDF and SPARQL using 4store and RDF.rb](https://www.jenitennison.com/blog/node/152)
 
 ## Command Line
+
 When installed, RDF.rb includes a `rdf` shell script which acts as a wrapper to perform a number of different
 operations on RDF files using available readers and writers.
 
@@ -112,7 +133,7 @@ Different RDF gems will augment the `rdf` script with more capabilities, which m
     require 'rdf/ntriples'
     graph = RDF::Graph.new << [:hello, RDF::RDFS.label, "Hello, world!"]
     graph.dump(:ntriples)
-    
+
 or
 
     RDF::Writer.open("hello.nt") { |writer| writer << graph }
@@ -121,7 +142,7 @@ or
 
     require 'rdf/ntriples'
     graph = RDF::Graph.load("https://ruby-rdf.github.com/rdf/etc/doap.nt")
-    
+
 or
 
     RDF::Reader.open("https://ruby-rdf.github.com/rdf/etc/doap.nt") do |reader|
@@ -131,19 +152,20 @@ or
     end
 
 ### Reading RDF data in other formats
+
 {RDF::Reader.open} and {RDF::Repository.load} use a number of mechanisms to determine the appropriate reader
 to use when loading a file. The specific format to use can be forced using, e.g. `format: :ntriples`
 option where the specific format symbol is determined by the available readers. Both also use
 MimeType or file extension, where available.
 
     require 'rdf/nquads'
-    
+
     graph = RDF::Graph.load("https://ruby-rdf.github.com/rdf/etc/doap.nq", format: :nquads)
 
 A specific sub-type of Reader can also be invoked directly:
 
     require 'rdf/nquads'
-    
+
     RDF::NQuads::Reader.open("https://ruby-rdf.github.com/rdf/etc/doap.nq") do |reader|
       reader.each_statement do |statement|
         puts statement.inspect
@@ -157,6 +179,7 @@ be detected from filename or other options, or that more than one format is iden
 match will be used to read the input.
 
 ### Writing RDF data using other formats
+
 {RDF::Writer.open}, {RDF::Enumerable#dump}, {RDF::Writer.dump} take similar options to {RDF::Reader.open} to determine the
 appropriate writer to use.
 
@@ -176,6 +199,7 @@ A specific sub-type of Writer can also be invoked directly:
     File.open("hello.nq", "w") {|f| f << repo.dump(:nquads)}
 
 ## Reader/Writer convenience methods
+
 {RDF::Enumerable} implements `to_{format}` for each available instance of {RDF::Reader}.
 For example, if `rdf/turtle` is loaded, this allows the following:
 
@@ -195,7 +219,7 @@ Note that no prefixes are loaded automatically, however they can be provided as
 ### Querying RDF data using basic graph patterns (BGPs)
 
     require 'rdf/ntriples'
-    
+
     graph = RDF::Graph.load("https://ruby-rdf.github.com/rdf/etc/doap.nt")
     query = RDF::Query.new({
       person: {
@@ -204,7 +228,7 @@ Note that no prefixes are loaded automatically, however they can be provided as
         FOAF.mbox => :email,
       }
     }, **{})
-    
+
     query.execute(graph) do |solution|
       puts "name=#{solution.name} email=#{solution.email}"
     end
@@ -451,7 +475,6 @@ This repository uses [Git Flow](https://github.com/nvie/gitflow) to mange develo
   which you will be asked to agree to on the first commit to a repo within the organization.
   Note that the agreement applies to all repos in the [Ruby RDF](https://github.com/ruby-rdf/) organization.
 
-
 ## License
 
 This is free and unencumbered public domain software. For more information,
@@ -492,4 +515,4 @@ see <https://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 [JSON::LD]:         https://ruby-rdf.github.com/json-ld
 [RestClient]:       https://rubygems.org/gems/rest-client
 [RestClient Components]: https://rubygems.org/gems/rest-client-components
-[Rack::Cache]:      https://rtomayko.github.io/rack-cache/
+[Rack::Cache]:      https://rtomayko.github.io/rack-cache/

data/VERSION

@@ -1 +1 @@
-3.1.10
+3.1.15

data/lib/rdf/cli.rb

@@ -256,8 +256,7 @@ module RDF
         lambda: ->(argv, opts) do
           writer_class = RDF::Writer.for(opts[:output_format]) || RDF::NTriples::Writer
           out = opts[:output]
-          opts = opts.merge(prefixes: {})
-          writer_opts = opts.merge(standard_prefixes: true)
+          writer_opts = {prefixes: {}, standard_prefixes: true}.merge(opts)
           writer_class.new(out, **writer_opts) do |writer|
             writer << repository
           end
@@ -536,6 +535,8 @@ module RDF
         count = 0
         self.parse(args, **options) do |reader|
           reader.each_statement {|st| @repository << st}
+          # Remember prefixes from reading
+          options[:prefixes] ||= reader.prefixes
         end
         secs = Time.new - start
         options[:logger].info "Parsed #{repository.count} statements with #{@readers.join(', ')} in #{secs} seconds @ #{count/secs} statements/second."

data/lib/rdf/mixin/enumerable.rb

@@ -136,8 +136,13 @@ module RDF
     #
     #   @param  [RDF::Statement] statement
     #   @return [Boolean]
-    def statement?(statement = nil)
-      statement && !enum_statement.find { |s| s.eql?(statement) }.nil?
+    def statement?(*args)
+      case args.length
+      when 0 then false
+      when 1
+        args.first && !enum_statement.find { |s| s.eql?(args.first) }.nil?        
+      else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
+      end
     end
     alias_method :has_statement?, :statement?
     alias_method :include?, :statement?
@@ -541,8 +546,12 @@ module RDF
     #   @param  [RDF::Resource] value
     #   @return [Boolean]
     #   @since 2.0
-    def term?(value = nil)
-      value && enum_term.include?(value)
+    def term?(*args)
+      case args.length
+      when 0 then super
+      when 1 then args.first && enum_term.include?(args.first)
+      else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
+      end
     end
     alias_method :has_term?, :term?
 

data/lib/rdf/model/graph.rb

@@ -138,11 +138,22 @@ module RDF
     end
 
     ##
-    # Returns `true` to indicate that this is a graph.
+    # @overload graph?
+    #   Returns `true` to indicate that this is a graph.
     #
-    # @return [Boolean]
-    def graph?
-      true
+    #   @return [Boolean]
+    # @overload graph?(name)
+    #   Returns `true` if `self` contains the given RDF graph_name.
+    #
+    #   @param  [RDF::Resource, false] graph_name
+    #     Use value `false` to query for the default graph_name
+    #   @return [Boolean]
+    def graph?(*args)
+      case args.length
+      when 0 then true
+      when 1 then graph_name == args.first
+      else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
+      end
     end
 
     ##
@@ -227,11 +238,15 @@ module RDF
     #   @param  [Statement] statement
     #   @return [Boolean]
     #   @see    RDF::Enumerable#statement?
-    def statement?(statement = nil)
-      return false if statement.nil?
-      statement = statement.dup
-      statement.graph_name = graph_name
-      @data.statement?(statement)
+    def statement?(*args)
+      case args.length
+      when 0 then false
+      when 1
+        statement = args.first.dup
+        statement.graph_name = graph_name
+        @data.statement?(statement)
+      else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
+      end
     end
     alias_method :has_statement?, :statement?
 

data/lib/rdf/model/literal.rb

@@ -308,6 +308,37 @@ module RDF
     end
     alias_method :===, :==
 
+    ##
+    # Compares `self` to `other` for sorting purposes (with type check).
+    #
+    # @param  [Object]  other
+    # @return [Integer] `-1`, `0`, or `1`
+    def <=>(other)
+      case other
+      when Literal
+        case
+        when self.eql?(other)
+          0
+        when self.language? && other.language?
+          # Literals with languages can compare if languages are identical
+          self.to_s <=> other.to_s
+        when self.simple? && other.simple?
+          self.to_s <=> other.to_s
+        when !self.valid?
+          type_error("#{self.inspect} is invalid") || 0
+        when !other.valid?
+          type_error("#{other.inspect} is invalid") || 0
+        when self.comperable_datatype2?(other)
+          self.object <=> other.object
+        else
+          type_error("#{self.inspect} and #{other.inspect} are not comperable") || 0
+        end
+      when String
+        self.simple? && self.value <=> other
+      else 1
+      end
+    end
+
     ##
     # Returns `true` if this is a plain literal. A plain literal
     # may have a language, but may not have a datatype. For
@@ -399,6 +430,32 @@ module RDF
       end
     end
 
+    ##
+    # Returns `true` if the literal has a datatype and the comparison should
+    # return false instead of raise a type error.
+    #
+    # Used for <=> operator.
+    #
+    # This behavior is intuited from SPARQL data-r2/expr-equal/eq-2-2
+    # @return [Boolean]
+    def comperable_datatype2?(other)
+      case self
+      when RDF::Literal::Numeric, RDF::Literal::Boolean
+        case other
+        when RDF::Literal::Numeric, RDF::Literal::Boolean
+          true
+        else
+          self.plain? || other.plain? ||
+          self.language? || other.language? ||
+          self.datatype == other.datatype
+        end
+      else
+        self.plain? || other.plain? ||
+        self.language? || other.language? ||
+        self.datatype == other.datatype
+      end
+    end
+
     ##
     # Converts this literal into its canonical lexical representation.
     #

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

@@ -11,6 +11,9 @@ module RDF; class Literal
     # @return [Integer] `-1`, `0`, or `1`
     # @since  0.3.0
     def <=>(other)
+      # If lexically invalid, use regular literal testing
+      return super unless self.valid? && (!other.respond_to?(:valid?) || other.valid?)
+
       case other
         when ::Numeric
           to_d <=> other
@@ -30,11 +33,10 @@ module RDF; class Literal
     # @since  0.3.0
     def ==(other)
       # If lexically invalid, use regular literal testing
-      return super unless self.valid?
+      return super unless self.valid? && (!other.respond_to?(:valid?) || other.valid?)
 
       case other
       when Literal::Numeric
-        return super unless other.valid?
         (cmp = (self <=> other)) ? cmp.zero? : false
       when RDF::URI, RDF::Node
         # Interpreting SPARQL data-r2/expr-equal/eq-2-2, numeric can't be compared with other types

data/lib/rdf/model/statement.rb

@@ -136,23 +136,45 @@ module RDF
     end
 
     ##
-    # Returns `true` to indicate that this value is a statement.
+    # @overload statement?
+    #   Returns `true` if `self` is a {RDF::Statement}.
     #
-    # @return [Boolean]
-    def statement?
-      true
+    #   @return [Boolean]
+    # @overload statement?(statement)
+    #   Returns `true` if `self` contains the given {RDF::Statement}.
+    #
+    #   @param  [RDF::Statement] statement
+    #   @return [Boolean]
+    def statement?(*args)
+      case args.length
+      when 0 then true
+      when 1 then self == args.first || subject.statement?(*args) || object.statement?(*args)
+      else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
+      end
     end
 
     ##
-    # Returns `true` if any element of the statement is not a
+    # @overload variable?
+    #   Returns `true` if any element of the statement is not a
     # URI, Node or Literal.
     #
-    # @return [Boolean]
-    def variable?
-      !(subject?    && subject.constant? &&
-        predicate?  && predicate.constant? &&
-        object?     && object.constant? &&
-        (graph?     ? graph_name.constant? : true))
+    #   @return [Boolean]
+    # @overload variable?(variables)
+    #   Returns `true` if this statement contains any of the variables.
+    #
+    #   @param  [Array<Symbol, #to_sym>] variables
+    #   @return [Boolean]
+    def variable?(*args)
+      case args.length
+      when 0
+        !(subject?    && subject.constant? &&
+          predicate?  && predicate.constant? &&
+          object?     && object.constant? &&
+          (graph?     ? graph_name.constant? : true))
+      when 1
+        to_quad.any? {|t| t.respond_to?(:variable?) && t.variable?(*args)}
+      else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
+      end
     end
 
     ##
@@ -215,9 +237,22 @@ module RDF
     end
 
     ##
-    # @return [Boolean]
-    def graph?
-      !!graph_name
+    # @overload graph?
+    #   Returns `true` if the statement has a graph name.
+    #
+    #   @return [Boolean]
+    # @overload graph?(name)
+    #   Returns `true` if `self` contains the given RDF graph_name.
+    #
+    #   @param  [RDF::Resource, false] graph_name
+    #     Use value `false` to query for the default graph_name
+    #   @return [Boolean]
+    def graph?(*args)
+      case args.length
+      when 0 then !!graph_name
+      when 1 then graph_name == args.first
+      else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
+      end
     end
     alias_method :name?, :graph?
     alias_method :has_graph?, :graph?
@@ -266,7 +301,7 @@ module RDF
     # @see RDF::Literal#==
     # @see RDF::Query::Variable#==
     def eql?(other)
-      other.is_a?(Statement) && self == other && (self.graph_name || false) == (other.graph_name || false)
+      other.is_a?(Statement) && self.to_a.eql?(other.to_a) && (self.graph_name || false) == (other.graph_name || false)
     end
 
     ##

data/lib/rdf/model/term.rb

@@ -57,11 +57,21 @@ module RDF
     end
 
     ##
-    # Returns `true` if `self` is a {RDF::Term}.
+    # @overload term?
+    #   Returns `true` if `self` is a {RDF::Term}.
     #
-    # @return [Boolean]
-    def term?
-      true
+    #   @return [Boolean]
+    # @overload term?(name)
+    #   Returns `true` if `self` contains the given RDF subject term.
+    #
+    #   @param  [RDF::Resource] value
+    #   @return [Boolean]
+    def term?(*args)
+      case args.length
+      when 0 then true
+      when 1 then false
+      else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
+      end
     end
 
     ##