rdf 1.1.10 → 1.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c527ab8ceef6cc215b7b30f603e3a51d3a0ee403
-  data.tar.gz: 9c47a7510c2f8b4e0ff6dd6048167c32055de5d3
+  metadata.gz: a7d765dce315d0c9f719adae387e1cec7f945958
+  data.tar.gz: 9446ae5e871f78abf5a43e783e4a90d193160984
 SHA512:
-  metadata.gz: d9a8dc1d4eec0baab67d6407b677f1a72825149a525c37b6ce8a34fba96d76814be3824a776d1e456f10af088c667bf28c27f7c528e4fd02a0dc90fd16c1d1b3
-  data.tar.gz: d26dac7f54707765751e32a249eb244862e86abdcdad12c83dcd81a0356ad902c46b0302f1734dfbc93c31b9477303cec3456dd3bc281f69f1ca89e5f2602693
+  metadata.gz: 0b9b5e08ba70b4574a955c30154bc4702ba0ca5767b734aafdeb2d1919da2fe961ab93c74122d1ab89e023bb710943e5dbfc5a2072141db5f219a4d9756f91ca
+  data.tar.gz: 1dd2bae743a05599b83ddaa860817aa9afd2a4bc1e47dc6606a79aaf9b01e87583ef61ac3e9c0cba89fc0fbd31bd4c78be85e8c2e3c3bab9b260f72d75e8a83e

data/README

@@ -321,6 +321,15 @@ from BNode identity (i.e., they each entail the other)
 ### RDF Vocabularies
 
 * {RDF}         - Resource Description Framework (RDF)
+* {RDF::OWL}    - Web Ontology Language (OWL)
+* {RDF::RDFS}   - RDF Schema (RDFS)
+* {RDF::RDFV}   - RDF Vocabulary (RDFV)
+* {RDF::XSD}    - XML Schema (XSD)
+
+#### Deprecated Vocabularies
+
+The following vocabularies will be deprecated in RDF.rb 2.0 and moved to the rdf-vocab gem.
+
 * {RDF::CC}     - Creative Commons (CC)
 * {RDF::CERT}   - W3 Authentication Certificate (CERT)
 * {RDF::DC}     - Dublin Core (DC)
@@ -335,10 +344,7 @@ from BNode identity (i.e., they each entail the other)
 * {RDF::MA}     - Media Resources (MA)
 * {RDF::MO}     - Music Ontology (MO)
 * {RDF::OG}     - Open Graph protocol (OG)
-* {RDF::OWL}    - Web Ontology Language (OWL)
 * {RDF::PROV}   - Provenance on the web (PROV)
-* {RDF::RDFS}   - RDF Schema (RDFS)
-* {RDF::RDFV}   - RDF Vocabulary (RDFV)
 * {RDF::RSA}    - W3 RSA Keys (RSA)
 * {RDF::RSS}    - RDF Site Summary (RSS)
 * {RDF::SCHEMA} - Schema.org (SCHEMA)
@@ -354,7 +360,6 @@ from BNode identity (i.e., they each entail the other)
 * {RDF::WOT}    - Web of Trust (WOT)
 * {RDF::XHTML}  - Extensible HyperText Markup Language (XHTML)
 * {RDF::XHV}    - XHTML Vocabulary (XHV)
-* {RDF::XSD}    - XML Schema (XSD)
 
 ## Dependencies
 

data/VERSION

@@ -1 +1 @@
-1.1.10
+1.1.11

data/lib/rdf/model/node.rb

@@ -16,7 +16,7 @@ module RDF
     # Defines the maximum number of interned Node references that can be held
     # cached in memory at any one time.
     #
-    # Note that caching interned nodes means that two different invocations using the same symbol will result in the same node, which may not be appropriate depending on the context from which it is used. RDF requires that bnodes with the same label are, in fact, different bnodes, unless they are used wihin the same document.
+    # Note that caching interned nodes means that two different invocations using the same symbol will result in the same node, which may not be appropriate depending on the context from which it is used. RDF requires that bnodes with the same label are, in fact, different bnodes, unless they are used within the same document.
     CACHE_SIZE = -1 # unlimited by default
 
     ##

data/lib/rdf/util/file.rb

@@ -4,19 +4,270 @@ require 'time'
 
 module RDF; module Util
   ##
-  # Wrapper for Net::HTTP. This allows implementations to override
-  # for more sophisticated behavior.
-  #
+  # Wrapper for retrieving RDF resources from HTTP(S) and file: scheme locations.
+  # 
+  # By default, HTTP(S) resources are retrieved using Net::HTTP. However, 
   # If the [Rest Client](https://rubygems.org/gems/rest-client) gem is included,
-  # it will be used for retrieving resources allowing for
+  # it will be used for retrieving resources, allowing for
   # sophisticated HTTP caching using [REST Client Components](https://rubygems.org/gems/rest-client-components)
   # allowing the use of `Rack::Cache` to avoid network access.
   #
+  # To use other HTTP clients, consumers can subclass 
+  # {RDF::Util::File::HttpAdapter} and set the {RDF::Util::File.http_adapter}.
+  #
   # Also supports the file: scheme for access to local files.
   #
   #
   # @since 0.2.4
   module File
+
+    ##
+    # @abstract Subclass and override {.open_url} to implement a custom adapter
+    # @since 1.2
+    class HttpAdapter
+      ##
+      # @param  [Hash{Symbol => Object}] options
+      # @option options [Array, String] :headers
+      #   HTTP Request headers
+      # @return [Hash] A hash of HTTP request headers
+      def self.headers options
+        headers = options.fetch(:headers, {})
+        headers['Accept'] ||= default_accept_header
+        headers
+      end
+
+      ##
+      # @return [String] the value for an Accept header
+      def self.default_accept_header
+        # Receive text/html and text/plain at a lower priority than other formats
+        reader_types = RDF::Format.reader_types.map do |t|
+          case t.to_s
+          when /text\/(?:plain|html)/
+            "#{t};q=0.5"
+          when /application\/xhtml\+xml/
+            "#{t};q=0.7"
+          else
+            t
+          end
+        end
+
+        (reader_types + %w(*/*;q=0.1)).join(", ")
+      end
+      
+      ##
+      # @abstract
+      # @param [String] base_uri to open
+      # @param  [Hash{Symbol => Object}] options
+      #   options are ignored in this implementation. Applications are encouraged
+      #   to override this implementation to provide more control over HTTP
+      #   headers and redirect following.
+      # @option options [String] :proxy
+      #   HTTP Proxy to use for requests.
+      # @option options [Array, String] :headers
+      #   HTTP Request headers
+      # @option options [Boolean] :verify_none (false)
+      #   Don't verify SSL certificates
+      # @return [RemoteDocument, Object] A {RemoteDocument}. If a block is given, the result of evaluating the block is returned.
+      def self.open_url base_uri, options
+        raise NoMethodError.new("#{self.inspect} does not implement required method `open_url` for ", "open_url")
+      end
+    end
+
+    ##
+    # If the [Rest Client](https://rubygems.org/gems/rest-client) gem is included,
+    # it will be used for retrieving resources allowing for
+    # sophisticated HTTP caching using [REST Client Components](https://rubygems.org/gems/rest-client-components)
+    # allowing the use of `Rack::Cache` to avoid network access.
+    # @since 1.2
+    class RestClientAdapter < HttpAdapter
+      # @see HttpAdapter.open_url
+      # @param [String] base_uri to open
+      # @param  [Hash{Symbol => Object}] options
+      # @return [RemoteDocument, Object] A {RemoteDocument}. If a block is given, the result of evaluating the block is returned.
+      def self.open_url base_uri, options
+        ssl_verify = options[:verify_none] ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
+
+        # If RestClient is loaded, prefer it
+        RestClient.proxy = options[:proxy].to_s if options[:proxy]
+        client = RestClient::Resource.new(base_uri, verify_ssl: ssl_verify)
+        client.get(headers(options)) do |response, request, res, &blk|
+          case response.code
+          when 200..299
+            # found object
+
+            # If a Location is returned, it defines the base resource for this file, not it's actual ending location
+            document_options = {
+              base_uri:     RDF::URI(response.headers.fetch(:location, base_uri)),
+              charset:      Encoding::UTF_8,
+              code:         response.code.to_i,
+              headers:      response.headers
+            }
+
+            remote_document = RemoteDocument.new(response.body, document_options)
+          when 300..399
+            # Document base is redirected location
+            base_uri = response.headers[:location].to_s
+            response.follow_redirection(request, res, &blk)
+          else
+            raise IOError, "<#{base_uri}>: #{response.code}"
+          end
+        end
+      end
+    end
+
+    ##
+    # Net::HTTP adapter to retrieve resources without additional dependencies
+    # @since 1.2
+    class NetHttpAdapter < HttpAdapter
+      # @see HttpAdapter.open_url
+      # @param [String] base_uri to open
+      # @param  [Hash{Symbol => Object}] options
+      # @return [RemoteDocument, Object] A {RemoteDocument}. If a block is given, the result of evaluating the block is returned.
+      def self.open_url base_uri, options
+        ssl_verify = options[:verify_none] ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
+
+        redirect_count = 0
+        max_redirects = 5
+        parsed_url = ::URI.parse(base_uri)
+        parsed_proxy = ::URI.parse(options[:proxy].to_s)
+        base_uri = parsed_url.to_s
+        remote_document = nil
+
+        until remote_document do
+          Net::HTTP::start(parsed_url.host, parsed_url.port,
+                          parsed_proxy.host, parsed_proxy.port,
+                          open_timeout: 60 * 1000,
+                          use_ssl: parsed_url.scheme == 'https',
+                          verify_mode: ssl_verify
+          ) do |http|
+            request = Net::HTTP::Get.new(parsed_url.request_uri, headers(options))
+            http.request(request) do |response|
+              case response
+              when Net::HTTPSuccess
+                # found object
+
+                # Normalize headers using symbols
+                response_headers = response.to_hash.inject({}) do |out, (key, value)|
+                  out[key.gsub(/-/, '_').downcase.to_sym] = %w{ set-cookie }.include?(key.downcase) ? value : value.first
+                  out
+                end
+
+                # If a Location is returned, it defines the base resource for this file, not it's actual ending location
+                document_options = {
+                  base_uri:     RDF::URI(response["Location"] ? response["Location"] : base_uri),
+                  charset:      Encoding::UTF_8,
+                  code:         response.code.to_i,
+                  content_type: response.content_type,
+                  headers:      response_headers
+                }.merge(response.type_params)
+                document_options[:last_modified] = DateTime.parse(response["Last-Modified"]) if response["Last-Modified"]
+
+                remote_document = RemoteDocument.new(response.body, document_options)
+              when Net::HTTPRedirection
+                # Follow redirection
+                raise IOError, "Too many redirects" if (redirect_count += 1) > max_redirects
+
+                parsed_url = ::URI.parse(response["Location"])
+
+                base_uri = parsed_url.to_s
+              else
+                raise IOError, "<#{parsed_url}>: #{response.message}(#{response.code})"
+              end
+            end
+          end
+        end
+        remote_document
+      end
+    end
+
+    ##
+    # Use Faraday for retrieving resources
+    # @since 1.2
+    class FaradayAdapter < HttpAdapter
+      class <<self
+        ##
+        # Set the Faraday::Connection to use for retrieving RDF resources
+        def conn= conn
+          @conn = conn
+        end
+
+        ##
+        # Get the Faraday::Connection to use for retrieving RDF resources,
+        # or a default connect that follows redirects.
+        def conn
+          @conn ||= Faraday.new do |conn|
+            conn.use FaradayMiddleware::FollowRedirects
+            conn.adapter Faraday.default_adapter
+          end
+        end
+      end
+
+      # @see HttpAdapter.open_url
+      # @param [String] base_uri to open
+      # @param  [Hash{Symbol => Object}] options
+      # @return [RemoteDocument, Object] A {RemoteDocument}.
+      def self.open_url base_uri, options
+        response = conn.get do |req|
+          req.url base_uri
+          headers(options).each do |k,v|
+            req.headers[k] = v
+          end
+        end
+
+        case response.status
+        when 200..299
+          # found object
+
+          # If a Location is returned, it defines the base resource for this file, not it's actual ending location
+          document_options = {
+            base_uri:     RDF::URI(response.headers.fetch(:location, response.env.url)),
+            charset:      Encoding::UTF_8,
+            code:         response.status,
+            headers:      response.headers
+          }
+
+          remote_document = RemoteDocument.new(response.body, document_options)
+        else
+          raise IOError, "<#{base_uri}>: #{response.code}"
+        end
+      end
+    end
+
+    class <<self
+      ##
+      # Set the HTTP adapter
+      # @see .http_adapter
+      # @param [HttpAdapter] http_adapter
+      # @return [HttpAdapter]
+      # @since 1.2
+      def http_adapter= http_adapter
+        @http_adapter = http_adapter
+      end
+
+      ##
+      # Get current HTTP adapter. If no adapter has been explicitly set,
+      # use RestClientAdapter (if RestClient is loaded), or the NetHttpAdapter
+      #
+      # @param [Boolean] use_net_http use the NetHttpAdapter, even if other
+      #      adapters have been configured
+      # @return [HttpAdapter]
+      # @since 1.2
+      def http_adapter use_net_http = false
+        if use_net_http
+          NetHttpAdapter
+        else
+          @http_adapter ||= begin
+            # Otherwise, fallback to Net::HTTP
+            if defined?(RestClient)
+              RestClientAdapter
+            else
+              NetHttpAdapter
+            end
+          end
+        end
+      end
+    end
+
     ##
     # Open the file, returning or yielding {RemoteDocument}.
     #
@@ -59,94 +310,9 @@ module RDF; module Util
       remote_document = nil
 
       if filename_or_url.to_s =~ /^https?/
-        # Open as a URL with Net::HTTP
-        headers = options.fetch(:headers, {})
-        # Receive text/html and text/plain at a lower priority than other formats
-        reader_types = RDF::Format.reader_types.map do |t|
-          t.to_s =~ /text\/(?:plain|html)/  ? "#{t};q=0.5" : t
-        end
-        headers['Accept'] ||= (reader_types + %w(*/*;q=0.1)).join(", ")
-
         base_uri = filename_or_url.to_s
-        ssl_verify = options[:verify_none] ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
 
-        if defined?(RestClient) && !options[:use_net_http]
-          # If RestClient is loaded, prefer it
-          RestClient.proxy = options[:proxy].to_s if options[:proxy]
-          client = RestClient::Resource.new(base_uri, verify_ssl: ssl_verify)
-          client.get(headers) do |response, request, res, &blk|
-            case response.code
-            when 200..299
-              # found object
-
-              # If a Location is returned, it defines the base resource for this file, not it's actual ending location
-              document_options = {
-                base_uri:     RDF::URI(response.headers.fetch(:location, base_uri)),
-                charset:      Encoding::UTF_8,
-                code:         response.code.to_i,
-                headers:      response.headers
-              }
-
-              remote_document = RemoteDocument.new(response.body, document_options)
-            when 300..399
-              # Document base is redirected location
-              base_uri = response.headers[:location].to_s
-              response.follow_redirection(request, res, &blk)
-            else
-              raise IOError, "<#{base_uri}>: #{response.code}"
-            end
-          end
-        else
-          # Otherwise, fallback to Net::HTTP
-          redirect_count = 0
-          max_redirects = 5
-          parsed_url = ::URI.parse(filename_or_url.to_s)
-          parsed_proxy = ::URI.parse(options[:proxy].to_s)
-          base_uri = parsed_url.to_s
-          until remote_document do
-            Net::HTTP::start(parsed_url.host, parsed_url.port,
-                            parsed_proxy.host, parsed_proxy.port,
-                            open_timeout: 60 * 1000,
-                            use_ssl: parsed_url.scheme == 'https',
-                            verify_mode: ssl_verify
-            ) do |http|
-              request = Net::HTTP::Get.new(parsed_url.request_uri, headers)
-              http.request(request) do |response|
-                case response
-                when Net::HTTPSuccess
-                  # found object
-
-                  # Normalize headers using symbols
-                  response_headers = response.to_hash.inject({}) do |out, (key, value)|
-                    out[key.gsub(/-/, '_').downcase.to_sym] = %w{ set-cookie }.include?(key.downcase) ? value : value.first
-                    out
-                  end
-
-                  # If a Location is returned, it defines the base resource for this file, not it's actual ending location
-                  document_options = {
-                    base_uri:     RDF::URI(response["Location"] ? response["Location"] : base_uri),
-                    charset:      Encoding::UTF_8,
-                    code:         response.code.to_i,
-                    content_type: response.content_type,
-                    headers:      response_headers
-                  }.merge(response.type_params)
-                  document_options[:last_modified] = DateTime.parse(response["Last-Modified"]) if response["Last-Modified"]
-
-                  remote_document = RemoteDocument.new(response.body, document_options)
-                when Net::HTTPRedirection
-                  # Follow redirection
-                  raise IOError, "Too many redirects" if (redirect_count += 1) > max_redirects
-
-                  parsed_url = ::URI.parse(response["Location"])
-
-                  base_uri = parsed_url.to_s
-                else
-                  raise IOError, "<#{parsed_url}>: #{response.message}(#{response.code})"
-                end
-              end
-            end
-          end
-        end
+        remote_document = self.http_adapter(!!options[:use_net_http]).open_url(base_uri, options)
       else
         # Fake content type based on found format
         format = RDF::Format.for(filename_or_url.to_s)

data/lib/rdf/vocab/cc.rb

@@ -2,6 +2,7 @@
 # This file generated automatically using vocab-fetch from http://creativecommons.org/ns#
 require 'rdf'
 module RDF
+  # @deprecated Please use `RDF::Vocab::CC` from the rdf-vocab gem instead
   class CC < RDF::StrictVocabulary("http://creativecommons.org/ns#")
 
     # Class definitions
@@ -39,7 +40,7 @@ module RDF
     property :deprecatedOn,
       domain: "cc:License".freeze,
       label: "deprecatedOn".freeze,
-      range: "http://www.w3.org/2001/XMLSchema-datatypes#date".freeze,
+      range: "xsd:date".freeze,
       type: "rdf:Property".freeze
     property :jurisdiction,
       domain: "cc:License".freeze,

data/lib/rdf/vocab/cert.rb

@@ -2,6 +2,7 @@
 # This file generated automatically using vocab-fetch from http://www.w3.org/ns/auth/cert#
 require 'rdf'
 module RDF
+  # @deprecated Please use `RDF::Vocab::CERT` from the rdf-vocab gem instead
   class CERT < RDF::StrictVocabulary("http://www.w3.org/ns/auth/cert#")
 
     # Class definitions
@@ -132,7 +133,7 @@ module RDF
  <p>The only difference is that the octet string is then encoded using either xsd:base64Binary or xsd:hexBinary. Currently for all usages of this relation, the xsd:hexBinary datatype should be used until the SPARQL working group specifies specifies in its <a href="http://www.w3.org/TR/sparql11-entailment/#DEntRegime">D-Entailment</a> that those two types are equivalent.</p>
  <p>It would have been better had there been a hexInteger datatype that was standard and supported by all tools.</p>
    ).freeze,
-      domain: ["cert:DSAKey".freeze, "cert:RSAKey".freeze],
+      domain: ["cert:RSAKey".freeze],
       label: "modulus".freeze,
       range: ["xsd:base64Binary".freeze, "xsd:hexBinary".freeze],
       "rdfs:isDefinedBy" => %(cert:).freeze,
@@ -145,7 +146,7 @@ module RDF
           public_exponent*private_exponent = 1 modulo totient\(p*q\)
        The private exponent is often named 'd'
     ).freeze,
-      domain: "cert:RSAPrivateKey".freeze,
+      domain: "cert:PrivateKey".freeze,
       label: "private".freeze,
       range: "xsd:nonNegativeInteger".freeze,
       "rdfs:isDefinedBy" => %(cert:).freeze,