rdf-resource 0.0.1

data/README.md

@@ -0,0 +1,9 @@
+[![Build Status](https://travis-ci.org/sul-dlss/rdf-resource.svg?branch=master)](https://travis-ci.org/sul-dlss/rdf-resource) [![Coverage Status](https://coveralls.io/repos/sul-dlss/rdf-resource/badge.png)](https://coveralls.io/r/sul-dlss/rdf-resource) [![Dependency Status](https://gemnasium.com/sul-dlss/rdf-resource.svg)](https://gemnasium.com/sul-dlss/rdf-resource) [![Gem Version](https://badge.fury.io/rb/rdf-resource.svg)](http://badge.fury.io/rb/rdf-resource)
+
+# rdf-resource
+A utility for working with RDF resources and vocabularies
+
+It uses RDF.rb and several RDF::Vocab, with options for
+caching RDF resources.
+
+See https://github.com/sul-dlss/rdf-resource/blob/master/lib/rdf-resource/resource.rb

data/Rakefile

@@ -0,0 +1,45 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rdf'
+require 'linkeddata'
+require 'rdf/cli/vocab-loader'
+
+desc 'Default: run specs.'
+task :default => :spec
+task :specs => :spec
+
+# Derived from https://raw.githubusercontent.com/ruby-rdf/rdf/develop/Rakefile
+desc "Generate Vocabularies"
+vocab_sources = {
+  Content: {
+    uri: 'http://www.w3.org/2011/content#',
+    source: 'http://www.w3.org/2011/content',
+    strict: true
+  },
+}
+
+task :gen_vocabs => vocab_sources.keys.map {|v| "lib/rdf/vocab/#{v}.rb"}
+
+vocab_sources.each do |id, v|
+  file "lib/rdf/vocab/#{id}.rb" => :do_build do
+    puts "Generate lib/rdf/vocab/#{id}.rb"
+    begin
+      out = StringIO.new
+      loader = RDF::VocabularyLoader.new(id.to_s.upcase)
+      loader.uri = v[:uri]
+      loader.source = v[:source] if v[:source]
+      loader.extra = v[:extra] if v[:extra]
+      loader.strict = v.fetch(:strict, true)
+      loader.output = out
+      loader.run
+      out.rewind
+      File.open("lib/rdf/vocab/#{id}.rb", "w") {|f| f.write out.read}
+    rescue
+      puts "Failed to load #{id}: #{$!.message}"
+    end
+  end
+end
+
+task :do_build

data/bin/console

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'rdf-resource'
+CONFIG = RDFResource.configuration
+binding.pry
+

data/bin/ctags.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+system "find . -name '*.rb' | ctags -f .tags --languages=Ruby -L -"
+
+if File.exist? './Gemfile'
+  require 'bundler'
+  paths = Bundler.load.specs.map(&:full_gem_path).join(' ')
+  system "ctags -R -f .gemtags --languages=Ruby #{paths}"
+end

data/lib/rdf-resource.rb

@@ -0,0 +1,27 @@
+require 'requires'
+
+module RDFResource
+
+  AGENT = RDF::URI.parse('https://github.com/sul-dlss/rdf-resource')
+
+  # configuration at the module level, see
+  # http://brandonhilkert.com/blog/ruby-gem-configuration-patterns/
+
+  class << self
+    attr_writer :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.reset
+    @configuration = Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+end
+

data/lib/rdf-resource/configuration.rb

@@ -0,0 +1,64 @@
+
+module RDFResource
+
+  class Configuration
+
+    attr_accessor :debug
+
+    attr_accessor :prefixes
+
+    attr_accessor :use_foaf
+    attr_accessor :use_schema
+
+    attr_accessor :log_file
+    attr_accessor :logger
+
+    def initialize
+      @debug = env_boolean('DEBUG')
+
+      # Vocabulary options
+      # foaf:Person or schema:Person or both?
+      @use_foaf = env_boolean('USE_FOAF')
+      @use_schema = env_boolean('USE_SCHEMA') # schema.org
+
+      # RDF prefixes
+      @prefixes = {}
+      @prefixes['bf'] = 'http://bibframe.org/vocab/'
+      @prefixes['foaf'] = 'http://xmlns.com/foaf/0.1/'
+      @prefixes['isni'] = 'http://www.isni.org/isni/'
+      @prefixes['loc_names'] = 'http://id.loc.gov/authorities/names/'
+      @prefixes['loc_subjects'] = 'http://id.loc.gov/authorities/subjects/'
+      @prefixes['rdf'] = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'
+      @prefixes['rdfs'] = 'http://www.w3.org/2000/01/rdf-schema#'
+      @prefixes['schema'] = 'http://schema.org/'
+      @prefixes['owl'] = 'http://www.w3.org/2002/07/owl#'
+      @prefixes['viaf'] = 'http://viaf.org/viaf/'
+
+      # logging
+      log_file = ENV['RDF_LOG_FILE'] || 'log/rdf-resource.log'
+      log_file = File.absolute_path log_file
+      @log_file = log_file
+      log_path = File.dirname log_file
+      unless File.directory? log_path
+        # try to create the log directory
+        Dir.mkdir log_path rescue nil
+      end
+      begin
+        log_file = File.new(@log_file, 'w+')
+      rescue
+        log_file = $stderr
+        @log_file = 'STDERR'
+      end
+      @logger = Logger.new(log_file, 'monthly')
+      @logger.level = @debug ? Logger::DEBUG : Logger::INFO
+
+    end
+
+    def env_boolean(var)
+      # check if an ENV variable is true, use false as default
+      ENV[var].to_s.upcase == 'TRUE' rescue false
+    end
+
+  end
+
+end

data/lib/rdf-resource/resource.rb

@@ -0,0 +1,265 @@
+
+module RDFResource
+
+  class Resource
+
+    @@config = nil
+
+    def self.http_head_request(url)
+      uri = nil
+      begin
+        response = RestClient.head(url)
+        uri = response.args[:url]
+      rescue
+        @@config.logger.error "RestClient.head failed for #{url}"
+        begin
+          response = RestClient.get(url)
+          uri = response.args[:url]
+        rescue
+          @@config.logger.error "RestClient.get failed for #{url}"
+        end
+      end
+      uri
+    end
+
+
+    attr_accessor :iri
+
+    def initialize(uri=nil)
+      @@agent ||= RDFResource::AGENT
+      @@config ||= RDFResource.configuration
+      if uri =~ /\A#{URI::regexp}\z/
+        uri = Addressable::URI.parse(uri.to_s) rescue nil
+      end
+      raise 'invalid uri' unless uri.instance_of? Addressable::URI
+      @iri = uri
+    end
+
+    def id
+      @iri.basename
+    end
+
+    def iri_type?(type)
+      iri_types.include? RDF::URI.parse(type)
+    end
+
+    def iri_types
+      q = [rdf_uri, RDF.type, :o]
+      rdf.query(q).collect {|s| s.object }
+    end
+
+    # Assert PROV.SoftwareAgent and PROV.generatedAtTime
+    def provenance
+      s = [rdf_uri, RDF::PROV.SoftwareAgent, @@agent]
+      rdf.insert(s)
+      s = [rdf_uri, RDF::PROV.generatedAtTime, rdf_now]
+      rdf.insert(s)
+    end
+
+    # Retrieve RDF graph from iri; the results may be cached when
+    # the RDF::Graph.load method uses RestClient and it is configured
+    # to cache results.
+    # This method is often overloaded in subclasses because
+    # RDF services use variations in the URL 'extension' patterns.
+    # @return [RDF::Graph|nil] an RDF graph
+    def rdf
+      return @rdf unless @rdf.nil?
+      uri4rdf = @iri.to_s
+      tries = 0
+      begin
+        tries += 1
+        @rdf = RDF::Graph.load(uri4rdf)
+      rescue
+        sleep 1*tries
+        retry if tries < 3
+        binding.pry if @@config.debug
+        @@config.logger.error("Failed to retrieve RDF for #{uri4rdf}")
+        @rdf = nil
+      end
+    end
+
+    # RDF query to find all objects of a predicate
+    # @param predicate [RDF::URI] An RDF predicate, the ?p in ?s ?p ?o
+    # @return [Array] The objects of predicate, the ?o in ?s ?p ?o
+    def query_predicate_objects(predicate)
+      q = [:s, predicate, :o]
+      rdf.query(q).collect {|s| s.object }
+    end
+
+    # RDF query to find all subjects with a predicate
+    # @param predicate [RDF::URI] An RDF predicate, the ?p in ?s ?p ?o
+    # @return [Array] The subjects with predicate, the ?s in ?s ?p ?o
+    def query_predicate_subjects(predicate)
+      q = [:s, predicate, :o]
+      rdf.query(q).collect {|s| s.subject }
+    end
+
+    # Regexp search to find an object matching a string, if it belongs to @iri
+    # @param id [String] A string literal used to construct a Regexp
+    # @return [RDF::URI] The first object matching the Regexp
+    def rdf_find_object(id)
+      return nil unless rdf_valid?
+      rdf.each_statement do |s|
+        if s.subject == @iri.to_s
+          return s.object if s.object.to_s =~ Regexp.new(id, Regexp::IGNORECASE)
+        end
+      end
+      nil
+    end
+
+    # Regexp search to find a subject matching a string
+    # @param id [String] A string literal used to construct a Regexp
+    # @return [RDF::URI] The first subject matching the Regexp
+    def rdf_find_subject(id)
+      return nil unless rdf_valid?
+      rdf.each_subject do |s|
+        return s if s.to_s =~ Regexp.new(id, Regexp::IGNORECASE)
+      end
+      nil
+    end
+
+    # @param object [RDF::Node] An RDF blank node
+    # @return [RDF::Graph] graph of recursive resolution for a blank node
+    def rdf_expand_blank_nodes(object)
+      g = RDF::Graph.new
+      if object.node?
+        rdf.query([object, nil, nil]) do |s,p,o|
+          g << [s,p,o]
+          g << rdf_expand_blank_nodes(o) if o.node?
+        end
+      end
+      g
+    end
+
+    # ----
+    # RDF::Graph convenience wrappers
+
+    def rdf_insert(uriS, uriP, uriO)
+      @rdf.insert RDF::Statement(uriS, uriP, uriO)
+    end
+    def rdf_insert_sameAs(uriS, uriO)
+      rdf_insert(uriS, RDF::OWL.sameAs, uriO)
+    end
+    def rdf_insert_seeAlso(uriS, uriO)
+      rdf_insert(uriS, RDF::RDFS.seeAlso, uriO)
+    end
+    def rdf_insert_creator(uriS, uriO)
+      rdf_insert(uriS, RDF::SCHEMA.creator, uriO)
+    end
+    def rdf_insert_contributor(uriS, uriO)
+      rdf_insert(uriS, RDF::SCHEMA.contributor, uriO)
+    end
+    def rdf_insert_editor(uriS, uriO)
+      rdf_insert(uriS, RDF::SCHEMA.editor, uriO)
+    end
+    def rdf_insert_exampleOfWork(uriS, uriO)
+      rdf_insert(uriS, RDF::SCHEMA.exampleOfWork, uriO)
+    end
+    def rdf_insert_foafFocus(uriS, uriO)
+      # http://xmlns.com/foaf/spec/#term_focus
+      # relates SKOS:Concept to a 'real world thing'
+      rdf_insert(uriS, RDF::FOAF.focus, uriO)
+    end
+    def rdf_insert_name(uriS, name)
+      rdf_insert(uriS, RDF::FOAF.name, name) if @@config.use_foaf
+      rdf_insert(uriS, RDF::SCHEMA.name, name) if @@config.use_schema
+    end
+
+    def rdf_now
+      RDF::Literal.new(Time.now.utc, :datatype => RDF::XSD.dateTime)
+    end
+
+    def rdf_uri
+      RDF::URI.new(@iri)
+    end
+
+    # Methods that assert RDF.type
+
+    def rdf_insert_type(uriS, uriO)
+      rdf_insert(uriS, RDF.type, uriO)
+    end
+
+    def rdf_type_agent(uriS)
+      # Note: schema.org has no immediate parent for Person or Organization
+      rdf_insert_type(uriS, RDF::FOAF.Agent) if @@config.use_foaf
+      rdf_insert_type(uriS, RDF::SCHEMA.Thing) if @@config.use_schema
+    end
+
+    def rdf_type_concept(uriS)
+      rdf_insert_type(uriS, RDF::SKOS.Concept)
+    end
+
+    def rdf_type_organization(uriS)
+      rdf_insert_type(uriS, RDF::FOAF.Organization) if @@config.use_foaf
+      rdf_insert_type(uriS, RDF::SCHEMA.Organization) if @@config.use_schema
+    end
+
+    def rdf_type_person(uriS)
+      rdf_insert_type(uriS, RDF::FOAF.Person) if @@config.use_foaf
+      rdf_insert_type(uriS, RDF::SCHEMA.Person) if @@config.use_schema
+    end
+
+    def rdf_valid?
+      iri_types.length > 0
+    end
+
+
+
+    # ---
+    # HTTP methods
+
+    # @param url [String|URI] A URL that can be resolved via HTTP request
+    # @return [String|nil] the URL, after resolving redirections
+    def resolve_url(url)
+      begin
+        # RestClient does all the response code handling and redirection.
+        url = Resource.http_head_request(url)
+        if url.nil?
+          @@config.logger.warn "#{@iri}\t// #{url}"
+        else
+          @@config.logger.debug "Mapped #{@iri}\t-> #{url}"
+        end
+      rescue
+        binding.pry if @@config.debug
+        @@config.logger.error "unknown http error for #{@iri}"
+        url = nil
+      end
+      url
+    end
+
+    def same_as_org_graph
+      return @same_as_org_graph unless @same_as_org_graph.nil?
+      same_as_url = 'http://sameas.org/rdf?uri=' + URI.encode(@iri.to_s)
+      @same_as_org_graph = RDF::Graph.load(same_as_url)
+    end
+    def same_as_org_query
+      # q = SPARQL.parse("SELECT * WHERE { <#{@iri}> <http://www.w3.org/2002/07/owl#sameAs> ?o }")
+      q = [rdf_uri, RDF::OWL.sameAs, nil]
+      same_as_org_graph.query(q).collect {|s| s.object }
+    end
+
+
+
+    # ---
+    # Transforms or Serialization
+
+    # A json-ld object for the rdf resource
+    def as_jsonld
+      JSON::LD::API::fromRdf(rdf)
+    end
+
+    # A json-ld serialization of the rdf resource
+    def to_jsonld
+      rdf.dump(:jsonld, standard_prefixes: true)
+    end
+
+    # A turtle serialization of the rdf resource
+    def to_ttl
+      rdf.dump(:ttl, standard_prefixes: true)
+    end
+
+  end
+
+end
+
+

data/lib/rdf/vocab/Content.rb

@@ -0,0 +1,112 @@
+# -*- encoding: utf-8 -*-
+# This file generated automatically using vocab-fetch from http://www.w3.org/2011/content
+require 'rdf'
+module RDF
+  class CONTENT < RDF::StrictVocabulary("http://www.w3.org/2011/content#")
+
+    # Class definitions
+    term :Content,
+      comment: %(The content.).freeze,
+      label: "Content".freeze,
+      type: ["rdfs:Class".freeze, "owl:Class".freeze]
+    term :ContentAsBase64,
+      comment: %(The base64 encoded content \(can be used for binary content\).).freeze,
+      label: "Base64 content".freeze,
+      subClassOf: "http://www.w3.org/2011/content#Content".freeze,
+      type: ["rdfs:Class".freeze, "owl:Class".freeze]
+    term :ContentAsText,
+      comment: %(The text content \(can be used for text content\).).freeze,
+      label: "Text content".freeze,
+      subClassOf: "http://www.w3.org/2011/content#Content".freeze,
+      type: ["rdfs:Class".freeze, "owl:Class".freeze]
+    term :ContentAsXML,
+      comment: %(The XML content \(can only be used for XML-wellformed content\).).freeze,
+      label: "XML content".freeze,
+      subClassOf: "http://www.w3.org/2011/content#Content".freeze,
+      type: ["rdfs:Class".freeze, "owl:Class".freeze]
+    term :DoctypeDecl,
+      comment: %(The document type declaration.).freeze,
+      label: "Document type declaration".freeze,
+      type: ["rdfs:Class".freeze, "owl:Class".freeze]
+
+    # Property definitions
+    property :bytes,
+      comment: %(The Base64 encoded byte sequence of the content.).freeze,
+      domain: "http://www.w3.org/2011/content#ContentAsBase64".freeze,
+      label: "Base64 encoded byte sequence".freeze,
+      range: "xsd:base64Binary".freeze,
+      type: ["rdf:Property".freeze, "owl:ObjectProperty".freeze]
+    property :characterEncoding,
+      comment: %(The character encoding used to create a character sequence from a byte sequence or vice versa.).freeze,
+      domain: "http://www.w3.org/2011/content#Content".freeze,
+      label: "Character encoding".freeze,
+      range: "rdfs:Literal".freeze,
+      type: ["rdf:Property".freeze, "owl:ObjectProperty".freeze]
+    property :chars,
+      comment: %(The character sequence of the text content.).freeze,
+      domain: "http://www.w3.org/2011/content#ContentAsText".freeze,
+      label: "Character sequence".freeze,
+      range: "rdfs:Literal".freeze,
+      type: ["rdf:Property".freeze, "owl:ObjectProperty".freeze]
+    property :declaredEncoding,
+      comment: %(The character encoding declared in the XML declaration.).freeze,
+      domain: "http://www.w3.org/2011/content#ContentAsXML".freeze,
+      label: "XML character encoding".freeze,
+      range: "rdfs:Literal".freeze,
+      type: ["rdf:Property".freeze, "owl:ObjectProperty".freeze]
+    property :doctypeName,
+      comment: %(The document type name.).freeze,
+      domain: "http://www.w3.org/2011/content#DoctypeDecl".freeze,
+      label: "Document type name".freeze,
+      range: "rdfs:Literal".freeze,
+      type: ["rdf:Property".freeze, "owl:ObjectProperty".freeze]
+    property :dtDecl,
+      comment: %(The document type declaration.).freeze,
+      domain: "http://www.w3.org/2011/content#ContentAsXML".freeze,
+      label: "Document type declaration".freeze,
+      range: "http://www.w3.org/2011/content#DoctypeDecl".freeze,
+      type: ["rdf:Property".freeze, "owl:ObjectProperty".freeze]
+    property :internalSubset,
+      comment: %(The internal document type definition subset within the document type declarations.).freeze,
+      domain: "http://www.w3.org/2011/content#DoctypeDecl".freeze,
+      label: "Internal DTD subset".freeze,
+      range: "rdfs:Literal".freeze,
+      type: ["rdf:Property".freeze, "owl:ObjectProperty".freeze]
+    property :leadingMisc,
+      comment: %(The XML content preceding the document type declaration.).freeze,
+      domain: "http://www.w3.org/2011/content#ContentAsXML".freeze,
+      label: "XML leading misc".freeze,
+      range: "rdfs:XMLLiteral".freeze,
+      type: ["rdf:Property".freeze, "owl:ObjectProperty".freeze]
+    property :publicId,
+      comment: %(The document type declarations's public identifier.).freeze,
+      domain: "http://www.w3.org/2011/content#DoctypeDecl".freeze,
+      label: "Public ID".freeze,
+      range: "rdfs:Literal".freeze,
+      type: ["rdf:Property".freeze, "owl:ObjectProperty".freeze]
+    property :rest,
+      comment: %(The XML content following the document type declaration.).freeze,
+      domain: "http://www.w3.org/2011/content#ContentAsXML".freeze,
+      label: "XML rest".freeze,
+      range: "rdfs:XMLLiteral".freeze,
+      type: ["rdf:Property".freeze, "owl:ObjectProperty".freeze]
+    property :standalone,
+      comment: %(The standalone declaration in the XML declaration.).freeze,
+      domain: "http://www.w3.org/2011/content#ContentAsXML".freeze,
+      label: "XML standalone document declaration".freeze,
+      range: "rdfs:Literal".freeze,
+      type: ["rdf:Property".freeze, "owl:ObjectProperty".freeze]
+    property :systemId,
+      comment: %(The document type declarations's system identifier \(typed: xsd:anyURI\)).freeze,
+      domain: "http://www.w3.org/2011/content#DoctypeDecl".freeze,
+      label: "System ID".freeze,
+      range: "xsd:anyURI".freeze,
+      type: ["rdf:Property".freeze, "owl:ObjectProperty".freeze]
+    property :version,
+      comment: %(The XML version declared in the XML declaration.).freeze,
+      domain: "http://www.w3.org/2011/content#ContentAsXML".freeze,
+      label: "XML version".freeze,
+      range: "rdfs:Literal".freeze,
+      type: ["rdf:Property".freeze, "owl:ObjectProperty".freeze]
+  end
+end