rdf-vocab 2.0.0 → 2.0.1

checksums.yaml

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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