RubyGems - rdf-vocab - Versions diffs - 2.0.0 → 2.0.1 - Mend

rdf-vocab 2.0.0 → 2.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

checksums.yaml +4 -4
data/README.md +8 -1
data/lib/rdf/vocab/extensions.rb +475 -2
data/spec/extensions_spec.rb +356 -0
data/spec/matchers.rb +28 -0
data/spec/spec_helper.rb +3 -1
metadata +125 -9

checksums.yaml CHANGED

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9dfb94f2012dade90af150f17edda4c58213674f
-  data.tar.gz: 5fd4c0ae73ebbc74c5653e5771a694f2f20db4e9
+  metadata.gz: bb1e1b3846cdba7d14e15c200cc8ea1d3e15e712
+  data.tar.gz: d787b2d4898d7c9c62d95a422b31d9d8bb5cad09
 SHA512:
-  metadata.gz: 2e9c681c7e0a78cb1006d8944c313a59388841b4d773e78e8fc4c9666773f9d88bdb0a06c22a220c81b408da61a99af131c6bff858a8805bcd7efa2e478b73d1
-  data.tar.gz: 66fd025a3ae4de0ec56e84b051cf062140cf1e18217ea5ad5b11ae01a5d9715b16870a0c5e83391be2e13b13eee22e619c680d812118d01a6d157f82f44a3470
+  metadata.gz: 042f2e6832b90e4c9c48d68d446f6c5535d201352db7be8a673685bdd7a81eea51d06b8dfa96e57292690813b38878552ef247817d6a66f85bb4d15444aabeda
+  data.tar.gz: 5d570b5447478ecb809df8fc8e9655cdc6683a6c67bb86857eab15d4ffe95f25a560fdf0b250dae4e5980e14d097f338aa37a063e60510b492636abce4703bc6

data/README.md CHANGED

@@ -4,7 +4,12 @@ Common OWL/RDFS Vocabularies for use with Ruby [RDF.rb][]
 [![Gem Version](https://badge.fury.io/rb/rdf-vocab.png)](http://badge.fury.io/rb/rdf-vocab)
 [![Build Status](https://travis-ci.org/ruby-rdf/rdf-vocab.png?branch=master)](http://travis-ci.org/ruby-rdf/rdf-vocab)
-##Vocabularies
+## Extensions
+This gem extends `RDF::Vocabulary` with `#to_ttl`, `#to_jsonld`, and `#to_html` methods to create special-purpose vocabulary serializations. The HTML version is templated using a Haml template to allow output to be customized.
+Also extends `RDF::Vocabulary::Format` with the `gen-vocab` command extension to the `rdf` executable.
+## Vocabularies
 * RDF::Vocab::ACL       - [Web Access Control](http://www.w3.org/wiki/WebAccessControl) (W3C)
 * RDF::Vocab::Bibframe  - [Bibliographic Framework Initiaitive](http://bibframe.org/vocab/) (LoC)
@@ -80,6 +85,8 @@ then
 This will load all the vocabulary classes in the library.
+Also adds the `gen-vocab` command to the `rdf` command-line executable to generate specifically generated output in Turtle, JSON-LD, and HTML+RDFa for either built-in or arbitrary vocabularies.
 ## Adding new vocabularies
 * First, add an entry to `lib/rdf/vocab.rb`, the key names contained within

data/lib/rdf/vocab/extensions.rb CHANGED

@@ -1,5 +1,5 @@
-require 'rdf'
 # frozen_string_literal: true
+require 'rdf'
 require 'rdf/vocabulary'
 require 'rdf/vocab'
@@ -20,7 +20,6 @@ module RDF
         # Ruby's autoloading facility, meaning that `@@subclasses` will be
         # empty until each subclass has been touched or require'd.
         RDF::Vocab::VOCABS.each do |n, params|
-          class_name = params.fetch(:class_name, n.upcase).to_sym
           begin
             require "rdf/vocab/#{n}"
           rescue LoadError
@@ -30,6 +29,480 @@ module RDF
         end
         _orig_each(&block)
       end
+      begin
+        require 'rdf/turtle'
+        ##
+        # Generate Turtle representation, specific to vocabularies
+        #
+        # @param [RDF::Queryable] :graph Optional graph, otherwise uses statements from vocabulary.
+        # @param [Hash{#to_sym => String}] Prefixes to add to output
+        # @return [String]
+        def to_ttl(graph: nil, prefixes: nil)
+          output = []
+          # Find namespaces used in the vocabulary
+          graph = RDF::Graph.new {|g| each_statement {|s| g << s}} if graph.nil? || graph.empty?
+          prefixes = vocab_prefixes(graph).merge(prefixes || {})
+          pfx_width = prefixes.keys.map(&:to_s).map(&:length).max
+          prefixes.each do |pfx, uri|
+            output << "@prefix %*s: <%s> .\n" % [pfx_width, pfx, uri]
+          end
+          # Determine the category for each subject in the vocabulary graph
+          cats = subject_categories(graph)
+          writer = RDF::Turtle::Writer.new(StringIO.new, prefixes: prefixes)
+          {
+            ont: {
+              heading:  "# #{__name__.split('::').last} Vocabulary definition\n"
+            },
+            classes: {
+              heading:  "# Class definitions\n"
+            },
+            properties: {
+              heading:  "# Property definitions\n"
+            },
+            datatypes: {
+              heading:  "# Datatype definitions\n"
+            },
+            other: {
+              heading:  "# Other definitions\n"
+            }
+          }.each do |key, hash|
+            next unless cats[key]
+            output << "\n\n#{hash[:heading]}"
+            cats[key].each do |subject|
+              po = {}
+              # Group predicates with their values
+              graph.query(subject: subject) do |statement|
+                # Sanity check this, as these are set to an empty string if not defined.
+                next if [RDF::RDFS.label, RDF::RDFS.comment].include?(statement.predicate) && statement.object.to_s.empty?
+                po[statement.predicate] ||= []
+                po[statement.predicate] << statement.object
+              end
+              next if po.empty?
+              po_list = []
+              unless (types = po.delete(RDF.type)).empty?
+                po_list << 'a ' + types.map {|o| writer.format_term(o)}.join(", ")
+              end
+              # Serialize other predicate/objects
+              po.each do |predicate, objects|
+                resource = predicate.qname ? predicate.pname : "<#{predicate}>"
+                po_list << resource + ' ' + objects.map {|o| writer.format_term(o)}.join(", ")
+              end
+              # Output statements for this subject
+              subj = subject.qname ? subject.pname : "<#{subject}>"
+              output << "#{subj} " + po_list.join(";\n  ") + "\n  .\n"
+            end
+          end
+          output.join("")
+        end
+      rescue LoadError
+        # No Turtle serialization unless gem loaded
+      end
+      begin
+        require 'json/ld'
+        ##
+        # Generate JSON-LD representation, specific to vocabularies
+        #
+        # @param [RDF::Queryable] :graph Optional graph, otherwise uses statements from vocabulary.
+        # @param [Hash{#to_sym => String}] Prefixes to add to output
+        # @return [String]
+        def to_jsonld(graph: nil, prefixes: nil)
+          context = {}
+          rdfs_context = ::JSON.parse %({
+            "dc:title": {"@container": "@language"},
+            "dc:description": {"@container": "@language"},
+            "dc:date": {"@type": "xsd:date"},
+            "rdfs:comment": {"@container": "@language"},
+            "rdfs:domain": {"@type": "@vocab"},
+            "rdfs:label": {"@container": "@language"},
+            "rdfs:range": {"@type": "@vocab"},
+            "rdfs:seeAlso": {"@type": "@id"},
+            "rdfs:subClassOf": {"@type": "@vocab"},
+            "rdfs:subPropertyOf": {"@type": "@vocab"},
+            "schema:domainIncludes": {"@type": "@vocab"},
+            "schema:rangeIncludes": {"@type": "@vocab"},
+            "owl:equivalentClass": {"@type": "@vocab"},
+            "owl:equivalentProperty": {"@type": "@vocab"},
+            "owl:oneOf": {"@container": "@list", "@type": "@vocab"},
+            "owl:imports": {"@type": "@id"},
+            "owl:versionInfo": {"@type": "@id"},
+            "owl:inverseOf": {"@type": "@vocab"},
+            "owl:unionOf": {"@type": "@vocab", "@container": "@list"},
+            "rdfs_classes": {"@reverse": "rdfs:isDefinedBy", "@type": "@id"},
+            "rdfs_properties": {"@reverse": "rdfs:isDefinedBy", "@type": "@id"},
+            "rdfs_datatypes": {"@reverse": "rdfs:isDefinedBy", "@type": "@id"},
+            "rdfs_instances": {"@reverse": "rdfs:isDefinedBy", "@type": "@id"}
+          })
+          rdfs_classes, rdfs_properties, rdfs_datatypes, rdfs_instances = [], [], [], [], []
+          ontology = {
+            "@context" => rdfs_context,
+            "@id" => to_uri.to_s
+          }
+          # Find namespaces used in the vocabulary
+          graph = RDF::Graph.new {|g| each_statement {|s| g << s}} if graph.nil? || graph.empty?
+          prefixes = vocab_prefixes(graph).merge(prefixes || {})
+          prefixes.each do |pfx, uri|
+            context[pfx.to_s] = uri.to_s unless pfx.to_s.empty?
+          end
+          # Determine the category for each subject in the vocabulary graph
+          cats = subject_categories(graph)
+          # Generate term definitions from graph subjects
+          cats.values.flatten.each do |term|
+            next unless Array(term.qname).length == 2
+            context[term.qname.last.to_s] = term.to_uri.to_s
+          end
+          # Parse the two contexts so we know what terms are in scope
+          jld_context = ::JSON::LD::Context.new.parse([context, rdfs_context])
+          {
+            ont: {
+              heading:  "# #{__name__.split('::').last} Vocabulary definition\n",
+              bucket:   ontology,
+            },
+            classes: {
+              heading:  "# Class definitions\n",
+              bucket:   rdfs_classes,
+              rev_prop: "rdfs_classes"
+            },
+            properties: {
+              heading:  "# Property definitions\n",
+              bucket:   rdfs_properties,
+              rev_prop: "rdfs_properties"
+            },
+            datatypes: {
+              heading:  "# Datatype definitions\n",
+              bucket:   rdfs_datatypes,
+              rev_prop: "rdfs_datatypes"
+            },
+            other: {
+              heading:  "# Other definitions\n",
+              bucket:   rdfs_instances,
+              rev_prop: "rdfs_instances"
+            }
+          }.each do |key, hash|
+            next unless cats[key]
+            cats[key].each do |subject|
+              node = {"@id" => subject.pname}
+              po = {}
+              # Group predicates with their values
+              graph.query(subject: subject) do |statement|
+                # Sanity check this, as these are set to an empty string if not defined.
+                next if [RDF::RDFS.label, RDF::RDFS.comment].include?(statement.predicate) && statement.object.to_s.empty?
+                po[statement.predicate] ||= []
+                po[statement.predicate] << statement.object
+              end
+              next if po.empty?
+              node['@type'] = po.delete(RDF.type).map {|t| jld_context.compact_iri(t, vocab: true)}
+              po.each do |predicate, objects|
+                term = jld_context.compact_iri(predicate, vocab: true)
+                node[term] = if jld_context.container(term) == '@language'
+                  lang_map = objects.inject({}) do |memo, o|
+                    raise "Language-mapped term #{term} with non plain-literal #{o.inspect}" unless o.literal? && o.plain?
+                    memo.merge(o.language.to_s => o.value)
+                  end
+                  # Don't use language map if there's only one entry with no language
+                  lang_map = lang_map[""] if lang_map.keys == [""]
+                  [lang_map]
+                else
+                  objects.map do |o|
+                    expanded_value = jld_context.expand_value(term, o)
+                    jld_context.compact_value(term, expanded_value)
+                  end
+                end
+              end
+              node.each do |property, values|
+                case values.length
+                when 0 then node.delete(property)
+                when 1 then node[property] = values.first
+                end
+              end
+              # Either set bucket from node, or append node to bucket
+              if hash[:bucket].is_a?(Hash)
+                hash[:bucket].merge!(node)
+              else
+                ontology[hash[:rev_prop]] ||= hash[:bucket]
+                hash[:bucket] << node
+              end
+            end
+          end
+          # Serialize result
+          {
+            "@context" => context,
+            "@graph" => ontology
+          }.to_json(::JSON::LD::JSON_STATE)
+        end
+      rescue LoadError
+        # No JSON-LD serialization unless gem loaded
+      end
+      ##
+      # Generate HTML+RDFa representation, specific to vocabularies. This uses generated JSON-LD and a Haml template.
+      #
+      # @param [RDF::Queryable] :graph Optional graph, otherwise uses statements from vocabulary.
+      # @param [Hash{#to_sym => String}] Prefixes to add to output
+      # @param [String, Hash] jsonld
+      #   If not provided, the `to_jsonld` method is used to generate it.
+      # @param [String] template The path to a Haml or ERB template used to generate the output using the JSON-LD serialization
+      # @return [String]
+      def to_html(graph: nil, prefixes: nil, jsonld: nil, template: nil)
+        # Find namespaces used in the vocabulary
+        graph = RDF::Graph.new {|g| each_statement {|s| g << s}} if graph.nil? || graph.empty?
+        # Get JSON as an object
+        json = case jsonld
+        when String then ::JSON.parse(File.read jsonld)
+        when Hash   then jsonld
+        else
+          ::JSON.parse(to_jsonld(graph: graph, prefixes: prefixes))
+        end
+        raise "Expected JSON-LD data within the '@graph' key" unless json.has_key?('@graph')
+        template ||= File.expand_path("../../../../etc/template.erb", __FILE__)
+        prefixes = vocab_prefixes(graph).merge(prefixes || {})
+        prefixes[:owl] = RDF::OWL.to_uri.to_s
+        # Make sure ontology is typed
+        json['@graph']['@type'] ||= ['owl:Ontology']
+        jld_context = ::JSON::LD::Context.new.parse([json['@context'], json['@graph']['@context']])
+        # Expand the JSON-LD to normalize accesses
+        expanded = ::JSON::LD::API.expand(json).first
+        expanded.delete('@reverse')
+        # Re-compact keys
+        expanded = expanded.inject({}) do |memo, (k, v)|
+          term = RDF::Vocabulary.find_term(k)
+          k = term.pname if term
+          memo.merge(k => v)
+        end
+        # Normalize label accessors
+        expanded['rdfs:label'] ||= %w(dc:title dc11:title skos:prefLabel).inject(nil) do |memo, key|
+          memo || expanded[key]
+        end || [{'@value' => json['@graph']['@id']}]
+        %w(rdfs_classes rdfs_properties rdfs_datatypes rdfs_instances).each do |section|
+          next unless json['@graph'][section]
+          json['@graph'][section].each do |node|
+            node['rdfs:label'] ||= %w(dc:title dc11:title skos:prefLabel).inject do |memo, key|
+              memo || node[key]
+            end || [{'@value' => node['@id']}]
+          end
+        end
+        # Expand each part separately, as well.
+        %w(rdfs_classes rdfs_properties rdfs_datatypes rdfs_instances).each do |section|
+          next unless json['@graph'][section]
+          expanded_section = ::JSON::LD::API.expand(json['@graph'][section], expandContext: jld_context)
+          # Re-compact keys
+          expanded[section] = expanded_section.map do |node|
+            node.inject({}) do |memo, (k, v)|
+              term = RDF::Vocabulary.find_term(k)
+              k = term.pname if term
+              memo.merge(k => v)
+            end
+          end
+        end
+        # Template invoked with expanded JSON-LD with outer object including `rdfs_classes`, `rdfs_properties`, and `rdf_instances` sections.
+        case template
+        when /.haml$/
+          require 'haml'
+          haml = Haml::Engine.new(File.read(template))
+          haml.render(self, ont: expanded, context: json['@context'], prefixes: prefixes)
+        when /.erb$/
+          require 'erubis'
+          eruby = Erubis::FastEruby.new(File.read(template))
+          result = eruby.evaluate(binding: self, ont: expanded, context: json['@context'], prefixes: prefixes)
+        else
+          raise "Unknown template type #{template}. Should have '.erb' or '.haml' extension"
+        end
+      end
+      ##
+      # Create HTML for values (Helper method, needs to be public)
+      def value_to_html(property, value, tag)
+        value.map do |v|
+          %(<#{tag} property="#{property}") +
+          if v['@value']
+            (v['@language'] ? %( language="#{v['@language']}") : "") +
+            (v['@type'] ? %( datatype="#{RDF::URI(v['@type']).pname}") : "") +
+            %(>#{v['@value']})
+          elsif v['@id']
+            %( resource="#{RDF::URI(v['@id']).pname}">#{RDF::URI(v['@id']).pname})
+          else
+            raise "Unknown value type: #{v.inspect}, #{property}"
+          end +
+          %(</#{tag}>)
+        end.join("\n")
+      end
+    private
+      ##
+      # Prefixes used in this vocabulary
+      #
+      # @param [RDF::Graph] graph
+      # @return [Hash{Symbol => RDF::URI}]
+      def vocab_prefixes(graph)
+        vocabs = graph.
+          terms.
+          select(&:uri?).
+          map {|u| RDF::Vocabulary.find(u)}.
+          uniq.
+          compact.
+          sort_by(&:__prefix__)
+        vocabs << RDF::XSD  # incase we need it for a literal
+        # Generate prefix definitions
+        vocabs.inject({}) do |memo, v|
+          memo.merge(v.__prefix__ => v.to_uri)
+        end
+      end
+      ##
+      # Categorize each subject in the graph
+      #
+      # @param [RDF::Graph] graph
+      # @return [Hash{RDF::URI => Symbol}]
+      def subject_categories(graph)
+        cats = {}
+        categorized = {}
+        uncategorized = {}
+        graph.query(predicate: RDF.type) do |statement|
+          # Only serialize statements that are in the defined vocabulary
+          next unless statement.subject.start_with?(self.to_uri)
+          case statement.object
+          when RDF.Property,
+               RDF::OWL.AnnotationProperty,
+               RDF::OWL.DatatypeProperty,
+               RDF::OWL.FunctionalProperty,
+               RDF::OWL.ObjectProperty,
+               RDF::OWL.OntologyProperty
+            (cats[:properties] ||= []) << statement.subject unless categorized[statement.subject]
+            categorized[statement.subject] = true
+          when RDF::RDFS.Class, RDF::OWL.Class
+            (cats[:classes] ||= []) << statement.subject unless categorized[statement.subject]
+            categorized[statement.subject] = true
+          when RDF::RDFS.Datatype, RDF::OWL.DataRange
+            (cats[:datatypes] ||= []) << statement.subject unless categorized[statement.subject]
+            categorized[statement.subject] = true
+          when RDF::OWL.Ontology
+            (cats[:ont] ||= []) << statement.subject unless categorized[statement.subject]
+            categorized[statement.subject] = true
+          else
+            if statement.subject == self.to_uri
+              (cats[:ont] ||= []) << statement.subject unless categorized[statement.subject]
+              categorized[statement.subject] = true
+            else
+              uncategorized[statement.subject] = true
+            end
+          end
+        end
+        # Add all uncategorized subjects as :other
+        uncat = (uncategorized.keys - categorized.keys)
+        cats[:other] = uncat unless uncat.empty?
+        cats
+      end
     end
+    module VocabFormatExtensions
+      ##
+      # Hash of CLI commands appropriate for this format
+      # @return [Hash{Symbol => Lambda(Array, Hash)}]
+      def cli_commands
+        super.merge({
+          :"gen-vocab" => {
+            description: "Generate a vocabulary using a special serialization. Accepts an input graph, or serializes built-in vocabulary",
+            parse: false,  # Only parse if there are input files, otherwise, uses vocabulary
+            help: "gen-vocab --uri <vocabulary-URI> [--output format ttl|jsonld|html] [options] [files]\n",
+            lambda: ->(files, options) do
+              $stdout.puts "Generate Vocabulary"
+              raise ArgumentError, "Must specify vocabulary URI" unless options[:base_uri]
+              # Parse input graphs, if repository is not already created
+              if RDF::CLI.repository.empty? && !files.empty?
+                RDF::CLI.parse(files, options) do |reader|
+                  RDF::CLI.repository << reader
+                end
+              end
+              # Lookup vocabulary, or generate a new vocabulary from this URI
+              vocab = RDF::Vocabulary.find(options[:base_uri]) || begin
+                raise ArgumentError, "Must specify vocabulary prefix if vocabulary not built-in" unless options[:prefix]
+                RDF::Vocabulary.from_graph(RDF::CLI.repository, url: options[:base_uri], class_name: options[:prefix].to_s.upcase)
+              end
+              prefixes = {}
+              prefixes[options[:prefix]] = options[:base_uri] if options[:prefix]
+              out = options[:output] || $stdout
+              case options[:output_format]
+              when :ttl, nil then out.write vocab.to_ttl(graph: RDF::CLI.repository, prefixes: prefixes)
+              when :jsonld then out.write vocab.to_jsonld(graph: RDF::CLI.repository, prefixes: prefixes)
+              when :html then out.write vocab.to_html(graph: RDF::CLI.repository, prefixes: prefixes, template: options[:template])
+              else
+                # Use whatever writer we find
+                writer = RDF::Writer.for(options[:output_format]) || RDF::NTriples::Writer
+                writer.new(out, options) do |w|
+                  if RDF::CLI.repository.empty?
+                    vocab.each_statement {|s| w << s}
+                  else
+                    w << RDF::CLI.repository
+                  end
+                end
+              end
+            end,
+            options: [
+              RDF::CLI::Option.new(
+                symbol: :prefix,
+                datatype: String,
+                on: ["--prefix PREFIX"],
+                description: "Prefix associated with vocabulary, if not built-in."),
+              RDF::CLI::Option.new(
+                symbol: :template,
+                datatype: String,
+                on: ["--template TEMPLATE"],
+                description: "Path to local template for generating HTML, either Haml or ERB, depending on file extension.\n" +
+                            "See https://github.com/ruby-rdf/rdf-vocab/tree/develop/etc for built-in templates."),
+            ]
+          }
+        })
+      end
+    end
+    # Add cli_commands as class method to RDF::Vocabulary::Format
+    # TODO: in Ruby 2.0, `prepend` seems to be a private method of the class singleton; works okay elsewhere.
+    Format.singleton_class.send(:prepend, VocabFormatExtensions)
   end
 end

data/spec/extensions_spec.rb ADDED

@@ -0,0 +1,356 @@
+# frozen_string_literal: true
+require File.expand_path("../spec_helper", __FILE__)
+require 'json-schema'
+describe RDF::Vocabulary do
+  describe ".to_ttl" do
+    before(:all) do
+      @acl  = RDF::Vocab::ACL.to_ttl
+      @bibo = RDF::Vocab::BIBO.to_ttl
+      @dc   = RDF::Vocab::DC.to_ttl
+      @foaf = RDF::Vocab::FOAF.to_ttl
+    end
+    let(:acl) {@acl}
+    let(:bibo) {@bibo}
+    let(:dc) {@dc}
+    let(:foaf) {@foaf}
+    it "defines prefixes used in vocabulary" do
+      %w(dc dc11 foaf geo owl rdf rdfs skos vs).each do |pfx|
+        expect(foaf).to match(/@prefix\s+#{pfx}: /)
+      end
+    end
+    it "Does not generate an ontology if missing" do
+      expect(acl).not_to include "Vocabulary definition"
+      expect(foaf).to include "Vocabulary definition"
+    end
+    it "Creates Classes" do
+      expect(foaf).to include "Class definitions"
+      expect(foaf).to match /foaf:Agent a .*owl:Class/
+    end
+    it "Creates Properties" do
+      expect(foaf).to include "Property definitions"
+      expect(foaf).to match /foaf:account a .*rdf:Property/
+      expect(foaf).to match /foaf:account a .*owl:ObjectProperty/
+    end
+    it "Creates Datatypes" do
+      expect(dc).to include "Datatype definitions"
+      expect(dc).to include "dc:Box a rdfs:Datatype"
+    end
+    it "Creates Other definitions" do
+      expect(bibo).to include "Other definitions"
+      expect(bibo).to match /bdarcus a .*foaf:Person/
+    end
+    it "Serializes dates" do
+      expect(dc).to match %r("\d{4}-\d{2}-\d{2}"\^\^xsd:date)
+    end
+    it "Serializes long literals" do
+      expect(acl).to include '"""'
+    end
+    it "Serializes PNAME_NS" do
+      expect(foaf).to include "rdfs:isDefinedBy foaf:"
+    end
+    it "Serializes PNAME_LN" do
+      expect(foaf).to match /rdfs:subClassOf .*foaf:Document/
+    end
+    it "Serializes URIs" do
+      expect(foaf).to match %r(rdfs:subClassOf .*<http:)
+    end
+    context "smoke test", slow: true do
+      RDF::Vocabulary.each do |vocab|
+        it "serializes #{vocab.__name__} without raising exception" do
+          expect do
+            ttl = vocab.to_ttl
+            RDF::Turtle::Reader.new(ttl, validate: true).each_statement {}
+          end.not_to raise_error
+        end
+      end
+    end
+  end
+  describe ".to_jsonld" do
+    before(:all) do
+      @acl  = RDF::Vocab::ACL.to_jsonld
+      @bibo = RDF::Vocab::BIBO.to_jsonld
+      @dc   = RDF::Vocab::DC.to_jsonld
+      @foaf = RDF::Vocab::FOAF.to_jsonld
+    end
+    let(:acl) {JSON.parse @acl}
+    let(:bibo) {JSON.parse @bibo}
+    let(:dc) {JSON.parse @dc}
+    let(:foaf) {JSON.parse @foaf}
+    it "defines prefixes used in vocabulary" do
+      %w(dc dc11 foaf geo owl rdf rdfs skos vs).each do |pfx|
+        expect(foaf).to match_json_schema({
+          "$schema" => "http://json-schema.org/draft-04/schema#",
+          type: "object",
+          required: ["@context"],
+          properties: {
+            "@context" => {
+              type: "object",
+              required: [pfx]
+            }
+          }
+        })
+      end
+    end
+    it "Does not generate an ontology if missing" do
+      schema = {
+        "$schema" => "http://json-schema.org/draft-04/schema#",
+        type: "object",
+        required: ["@context", "@graph"],
+        properties: {
+          "@graph" => {
+            type: "object",
+            required: ["@type"]
+          }
+        }
+      }
+      expect(acl).not_to match_json_schema(schema)
+      expect(foaf).to match_json_schema(schema)
+    end
+    it "Creates Classes" do
+      schema = {
+        "$schema" => "http://json-schema.org/draft-04/schema#",
+        type: "object",
+        required: ["@context", "@graph"],
+        properties: {
+          "@graph" => {
+            type: "object",
+            required: ["rdfs_classes"],
+            properties: {
+              "rdfs_classes" => {
+                type: "array",
+                items: {
+                  allOf: [{
+                    type: "object",
+                    required: ["@id", "@type"]
+                  }]
+                }
+              }
+            }
+          }
+        }
+      }
+      expect(foaf).to match_json_schema(schema)
+      #expect(foaf).to match_json_path "$..rdfs_classes[?(@.@id='foaf:Agent')]"
+    end
+    it "Creates Properties" do
+      schema = {
+        "$schema" => "http://json-schema.org/draft-04/schema#",
+        type: "object",
+        required: ["@context", "@graph"],
+        properties: {
+          "@graph" => {
+            type: "object",
+            required: ["rdfs_properties"],
+            properties: {
+              "rdfs_properties" => {
+                type: "array",
+                items: {
+                  allOf: [{
+                    type: "object",
+                    required: ["@id", "@type"]
+                  }]
+                }
+              }
+            }
+          }
+        }
+      }
+      expect(foaf).to match_json_schema(schema)
+      #expect(foaf).to match_json_path "$..rdfs_properties[?(@.@id='foaf:account')]"
+    end
+    it "Creates Datatypes" do
+      schema = {
+        "$schema" => "http://json-schema.org/draft-04/schema#",
+        type: "object",
+        required: ["@context", "@graph"],
+        properties: {
+          "@graph" => {
+            type: "object",
+            required: ["rdfs_datatypes"],
+            properties: {
+              "rdfs_datatypes" => {
+                type: "array",
+                items: {
+                  allOf: [{
+                    type: "object",
+                    required: ["@id", "@type"]
+                  }]
+                }
+              }
+            }
+          }
+        }
+      }
+      expect(dc).to match_json_schema(schema)
+      #expect(dc).to match_json_path "$..rdfs_datatypes[?(@.@id='dc:Box')]"
+    end
+    it "Creates Other definitions" do
+      schema = {
+        "$schema" => "http://json-schema.org/draft-04/schema#",
+        type: "object",
+        required: ["@context", "@graph"],
+        properties: {
+          "@graph" => {
+            type: "object",
+            required: ["rdfs_instances"],
+            properties: {
+              "rdfs_instances" => {
+                type: "array",
+                items: {
+                  allOf: [{
+                    type: "object",
+                    required: ["@id", "@type"]
+                  }]
+                }
+              }
+            }
+          }
+        }
+      }
+      expect(bibo).to match_json_schema(schema)
+      #expect(bibo).to match_json_path "$..rdfs_instances[?(@.@id='bdarcus')]"
+    end
+    context "smoke test", slow: true do
+      RDF::Vocabulary.each do |vocab|
+        it "serializes #{vocab.__name__} without raising exception" do
+          expect do
+            jsonld = vocab.to_jsonld
+            JSON::LD::Reader.new(jsonld, validate: true).each_statement {}
+          end.not_to raise_error
+        end
+      end
+    end
+  end
+  describe ".to_html" do
+    before(:all) do
+      @acl  = RDF::Vocab::ACL.to_html
+      @bibo = RDF::Vocab::BIBO.to_html
+      @dc   = RDF::Vocab::DC.to_html
+      @foaf = RDF::Vocab::FOAF.to_html
+    end
+    let(:acl) {Nokogiri::HTML.parse @acl}
+    let(:bibo) {Nokogiri::HTML.parse @bibo}
+    let(:dc) {Nokogiri::HTML.parse @dc}
+    let(:foaf) {Nokogiri::HTML.parse @foaf}
+    it "defines prefixes used in vocabulary" do
+      %w(dc dc11 foaf geo owl rdf rdfs skos vs).each do |pfx|
+        expect(foaf.at_xpath('/html/body/@prefix').to_s).to include("#{pfx}: ")
+      end
+    end
+    it "Creates Classes" do
+      expect(foaf.xpath('//section/h2').to_s).to include("Class Definitions")
+      expect(foaf.at_xpath('//td[@resource="foaf:Group"]')).not_to be_nil
+    end
+    it "Creates Properties" do
+      expect(foaf.xpath('//section/h2').to_s).to include("Property Definitions")
+      expect(foaf.at_xpath('//td[@resource="foaf:isPrimaryTopicOf"]')).not_to be_nil
+    end
+    it "Creates Datatypes" do
+      expect(dc.xpath('//section/h2').to_s).to include("Datatype Definitions")
+      expect(dc.at_xpath('//td[@resource="dc:RFC1766"]')).not_to be_nil
+    end
+    it "Creates Other definitions" do
+      expect(dc.xpath('//section/h2').to_s).to include("Instance Definitions")
+      expect(dc.at_xpath('//td[@resource="dc:NLM"]')).not_to be_nil
+    end
+    context "smoke test", slow: true do
+      skips = [
+        RDF::Vocab::Bibframe,
+        RDF::Vocab::EBUCore,
+        RDF::Vocab::GEONAMES,
+        RDF::Vocab::IIIF,
+        RDF::Vocab::MO,
+        RDF::Vocab::PREMIS,
+        RDF::Vocab::SIOC,
+      ]
+      RDF::Vocabulary.each do |vocab|
+        it "serializes #{vocab.__name__} without raising exception", skip: (skips.include?(vocab)) do
+          expect do
+            rdfa = vocab.to_html
+            RDF::RDFa::Reader.new(rdfa, validate: true, base_uri: vocab.to_uri).each_statement {}
+          end.not_to raise_error
+        end
+      end
+    end
+  end
+  describe RDF::Vocabulary::Format do
+    describe ".cli_commands", skip: ("Rubinius issues in RDF.rb" if RUBY_ENGINE == "rbx") do
+      require 'rdf/cli'
+      describe "gen-vocab" do
+        let(:vocab) {RDF::Vocab::IANA}
+        it "generates Turtle by default" do
+          stringio = StringIO.new
+          RDF::CLI.exec(["gen-vocab"], base_uri: vocab.to_uri, output: stringio)
+          expect(stringio.string).not_to be_empty
+          graph = RDF::Graph.new
+          RDF::Turtle::Reader.new(stringio.string, validate: true) {|r| graph << r}
+          expect(graph).not_to be_empty
+          expect(graph).to be_valid
+        end
+        it "generates Turtle explictly" do
+          stringio = StringIO.new
+          RDF::CLI.exec(["gen-vocab"], base_uri: vocab.to_uri, output_format: :ttl, output: stringio)
+          expect(stringio.string).not_to be_empty
+          graph = RDF::Graph.new
+          RDF::Turtle::Reader.new(stringio.string, validate: true) {|r| graph << r}
+          expect(graph).not_to be_empty
+          expect(graph).to be_valid
+        end
+        it "generates JSON-LD" do
+          stringio = StringIO.new
+          RDF::CLI.exec(["gen-vocab"], base_uri: vocab.to_uri, output_format: :jsonld, output: stringio)
+          expect(stringio.string).not_to be_empty
+          graph = RDF::Graph.new
+          JSON::LD::Reader.new(stringio.string, validate: true) {|r| graph << r}
+          expect(graph).not_to be_empty
+          expect(graph).to be_valid
+        end
+        it "generates HTML" do
+          stringio = StringIO.new
+          RDF::CLI.exec(["gen-vocab"], base_uri: vocab.to_uri, output_format: :html, output: stringio)
+          expect(stringio.string).not_to be_empty
+          graph = RDF::Graph.new
+          RDF::RDFa::Reader.new(stringio.string, validate: true, base_uri: vocab.to_uri) {|r| graph << r}
+          expect(graph).not_to be_empty
+          expect(graph).to be_valid
+        end
+      end
+    end
+  end
+end

data/spec/matchers.rb ADDED

@@ -0,0 +1,28 @@
+require 'rspec/matchers' # @see http://rubygems.org/gems/rspec
+require 'json-schema'
+require 'jsonpath'
+RSpec::Matchers.define :match_json_schema do |schema|
+  match do |actual|
+    @error_message = JSON::Validator.fully_validate(schema, actual, validate_schema: true).join("")
+    @error_message.empty?
+  end
+  failure_message do |actual|
+    @error_message +
+    "\nActual: #{actual.to_json(JSON::LD::JSON_STATE)}" +
+    "\nSchema: #{schema.to_json(JSON::LD::JSON_STATE)}"
+  end
+end
+RSpec::Matchers.define :match_json_path do |path|
+  match do |actual|
+    matched = JsonPath.new(path).on(actual)
+    !matched.empty?
+  end
+  failure_message do |actual|
+    "Path #{path} not found in data" +
+    "\nActual: #{actual.to_json(JSON::LD::JSON_STATE)}"
+  end
+end

data/spec/spec_helper.rb CHANGED

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 require "bundler/setup"
 require 'rdf/vocab'
+require 'matchers'
 RSpec.configure do |config|
-  config.filter_run :focus => true
+  config.filter_run focus: true
+  config.filter_run_excluding slow: true
   config.run_all_when_everything_filtered = true
 end

metadata CHANGED

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdf-vocab
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - David Chandek-Stark
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-04-10 00:00:00.000000000 Z
+date: 2016-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -27,33 +27,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: ld-patch
+  name: haml
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '4.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
-  name: rdf-reasoner
+  name: erubis
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '2.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '2.7'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -68,6 +68,76 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: json-ld
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: jsonpath
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: ld-patch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -82,6 +152,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rdf-rdfa
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rdf-reasoner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: rdf-turtle
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -201,6 +313,8 @@ files:
 - lib/rdf/vocab/wot.rb
 - lib/rdf/vocab/xhtml.rb
 - lib/rdf/vocab/xhv.rb
+- spec/extensions_spec.rb
+- spec/matchers.rb
 - spec/spec_helper.rb
 - spec/vocab_spec.rb
 homepage: http://ruby-rdf.github.com/rdf-vocab
@@ -223,11 +337,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key:
 specification_version: 4
 summary: A library of RDF vocabularies
 test_files:
+- spec/extensions_spec.rb
+- spec/matchers.rb
 - spec/spec_helper.rb
 - spec/vocab_spec.rb
 has_rdoc: false