├── VERSION
├── spec
    ├── spec.opts
    ├── .gitignore
    ├── jruby_spec.rb
    ├── spec_helper.rb
    ├── context_spec.rb
    ├── format_spec.rb
    ├── suite_spec.rb
    ├── matchers.rb
    ├── suite_helper.rb
    └── expansion_spec.rb
├── pkg
    └── .gitignore
├── AUTHORS
├── lib
    └── rdf
    │   ├── .gitignore
    │   ├── rdfa
    │       ├── patches
    │       │   └── string_hacks.rb
    │       ├── version.rb
    │       ├── context
    │       │   ├── html.rb
    │       │   ├── xhtml.rb
    │       │   └── xml.rb
    │       ├── format.rb
    │       ├── vocab.rb
    │       ├── context.rb
    │       ├── expansion.rb
    │       ├── reader
    │       │   ├── nokogiri.rb
    │       │   └── rexml.rb
    │       └── writer
    │       │   └── haml_templates.rb
    │   └── rdfa.rb
├── CONTRIBUTORS
├── .coveralls.yml
├── dependencyci.yml
├── example-files
    ├── franz.com.html
    ├── java-nokogiri-issue.html
    ├── typed-property.xhtml
    ├── no-resource-href-6.xhtml
    ├── no-resource-href-11.xhtml
    ├── no-resource-about-typeof-5-1.xhtml
    ├── no-resource-about-typeof-5-2.xhtml
    ├── reece-dunn.html
    ├── 0265.xhtml
    ├── bb-test.rb
    ├── jeni-ice-cream.html
    ├── property-copying.html
    ├── schema-person.html
    ├── stain-validation.html
    ├── 0316-out.html
    ├── payswarm.n3
    ├── erdf_profile.html
    ├── webid.html
    ├── data-view.xhtml
    └── core.ttl
├── .gitignore
├── .yardopts
├── example.rb
├── .github
    └── workflows
    │   ├── generate-docs.yml
    │   └── ci.yml
├── UNLICENSE
├── Gemfile-pure
├── Rakefile
├── Gemfile
├── CONTRIBUTING.md
├── rdf-rdfa.gemspec
├── etc
    ├── doap.nt
    └── doap.html
├── script
    ├── intern_context
    ├── parse
    └── tc
└── History.md


/VERSION:
--------------------------------------------------------------------------------
1 | 3.3.0
2 | 


--------------------------------------------------------------------------------
/spec/spec.opts:
--------------------------------------------------------------------------------
1 | --colour


--------------------------------------------------------------------------------
/pkg/.gitignore:
--------------------------------------------------------------------------------
1 | /*.gem
2 | 


--------------------------------------------------------------------------------
/AUTHORS:
--------------------------------------------------------------------------------
1 | * Gregg Kellogg <gregg@greggkellogg.net>


--------------------------------------------------------------------------------
/lib/rdf/.gitignore:
--------------------------------------------------------------------------------
1 | /rdfxml
2 | /rdfxml.rb
3 | 


--------------------------------------------------------------------------------
/spec/.gitignore:
--------------------------------------------------------------------------------
1 | /test-suite
2 | /uri-cache/
3 | 


--------------------------------------------------------------------------------
/CONTRIBUTORS:
--------------------------------------------------------------------------------
1 | * Nicholas Humfrey <nicholas.humfrey@bbc.co.uk>


--------------------------------------------------------------------------------
/.coveralls.yml:
--------------------------------------------------------------------------------
1 | repo_token: Yru5qnQnb3gwAJQk2jg83tkdo1LBkiWu1
2 | 


--------------------------------------------------------------------------------
/dependencyci.yml:
--------------------------------------------------------------------------------
1 | platform:
2 |   Rubygems:
3 |     rdf-isomorphic:
4 |       tests:
5 |         unmaintained: skip


--------------------------------------------------------------------------------
/example-files/franz.com.html:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ruby-rdf/rdf-rdfa/HEAD/example-files/franz.com.html


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | /.DS_Store
 2 | /pkg
 3 | /doc/
 4 | /.yardoc/
 5 | /*.lock
 6 | /.rbx/
 7 | /.bundle
 8 | /coverage
 9 | /.byebug_history
10 | 


--------------------------------------------------------------------------------
/example-files/java-nokogiri-issue.html:
--------------------------------------------------------------------------------
1 | <html>
2 |   <head>
3 |     <meta http-equiv="Content-Type" content="text/html;charset=utf-8"/>
4 |   </head>
5 | </html>
6 | 


--------------------------------------------------------------------------------
/.yardopts:
--------------------------------------------------------------------------------
 1 | --title "RDFa reader/writer for RDF.rb."
 2 | --output-dir doc/yard
 3 | --protected
 4 | --no-private
 5 | --hide-void-return
 6 | --markup markdown
 7 | --readme README.md
 8 | -
 9 | AUTHORS
10 | History.md
11 | CONTRIBUTORS
12 | VERSION
13 | UNLICENSE
14 | 


--------------------------------------------------------------------------------
/example-files/typed-property.xhtml:
--------------------------------------------------------------------------------
 1 | <html xmlns="http://www.w3.org/1999/xhtml">
 2 | <head><title>Typed Property</title>
 3 | </head>
 4 | <body>
 5 |   <p vocab="http://www.milowski.com/V/" property="bit" typeof="thing">
 6 |     <span property="name">Fizzbit</span>
 7 |   </p>
 8 | </body>
 9 | </html>
10 | 
11 | 


--------------------------------------------------------------------------------
/example-files/no-resource-href-6.xhtml:
--------------------------------------------------------------------------------
 1 | <html xmlns="http://www.w3.org/1999/xhtml">
 2 | <head>
 3 | <title>Testing @resource=[]</title>
 4 | </head>
 5 | <body>
 6 |   <a href="license.xhtml" rel="license" resource="[]">The Foo Document</a>
 7 |   <p>When the @resource resolves to nothing, the href resource should be used.</p>
 8 | </body>
 9 | </html>
10 | 


--------------------------------------------------------------------------------
/example-files/no-resource-href-11.xhtml:
--------------------------------------------------------------------------------
 1 | <html xmlns="http://www.w3.org/1999/xhtml">
 2 | <head>
 3 | <title>Testing @resource=[]</title>
 4 | </head>
 5 | <body>
 6 |   <a href="license.xhtml" property="license" resource="[]">The Foo Document</a>
 7 |   <p>When the @resource resolves to nothing, the href resource should be used.</p>
 8 | </body>
 9 | </html>
10 | 


--------------------------------------------------------------------------------
/lib/rdf/rdfa/patches/string_hacks.rb:
--------------------------------------------------------------------------------
 1 | class ::String
 2 |   # Trim beginning of each line by the amount of indentation in the first line
 3 |   def align_left
 4 |     str = self.sub(/^\s*$/, '')  # Remove leading newline
 5 |     str = str[1..-1] if str[0,1] == "\n"
 6 |     ws = str.match(/^(\s*)\S/m) ? $1 : ''
 7 |     str.gsub(/^#{ws}/m, '')
 8 |   end
 9 | end
10 | 


--------------------------------------------------------------------------------
/example-files/no-resource-about-typeof-5-1.xhtml:
--------------------------------------------------------------------------------
 1 | <html xmlns="http://www.w3.org/1999/xhtml">
 2 | <head>
 3 |   <title>Testing @typeof and @about=[]</title>
 4 | </head>
 5 | <body>
 6 |   <div about="[]" typeof="foaf:Person" property="foaf:name">Alex Milowski</div>
 7 |   <p>When the @about resolves to nothing, the typed resource should be a blank node.</p>
 8 | </body>
 9 | </html>
10 | 


--------------------------------------------------------------------------------
/example-files/no-resource-about-typeof-5-2.xhtml:
--------------------------------------------------------------------------------
 1 | <html xmlns="http://www.w3.org/1999/xhtml">
 2 | <head>
 3 | <title>Testing @typeof and @about=[]</title>
 4 | </head>
 5 | <body>
 6 |   <div about="[]" typeof="foaf:Person">
 7 |     <span property="foaf:name">Alex Milowski</span>
 8 |   </div>
 9 |   <p>When the @about resolves to nothing, the typed resource should be a blank node.</p>
10 | </body>
11 | </html>
12 | 


--------------------------------------------------------------------------------
/example-files/reece-dunn.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html xmlns="http://www.w3.org/1999/xhtml" lang="en" prefix="dct: http://purl.org/dc/terms/ xsd: http://www.w3.org/2001/XMLSchema# s: http://schema.org/">
 3 |  <head>
 4 |   <title>Test Case</title>
 5 |  </head>
 6 |  <body about="http://example.org/foo">
 7 |   <p property="dct:date" datatype="xsd:string" content="2010-11-12">2010</p>
 8 |  </body>
 9 | </html>
10 | 


--------------------------------------------------------------------------------
/example-files/0265.xhtml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.1//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-2.dtd">
 3 | <html xmlns="http://www.w3.org/1999/xhtml" version="XHTML+RDFa 1.1" about="http://www.example.com">
 4 | <head  property="rdfs:seeAlso" resource="http://www.example.org">
 5 | 	<title>Test 0265</title>
 6 | </head>
 7 | <body>
 8 |   <p> </p>
 9 | </div>
10 | </body>
11 | </html>
12 | 


--------------------------------------------------------------------------------
/example-files/bb-test.rb:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env ruby
 2 | 
 3 | require 'net/http'
 4 | 
 5 | url = URI.parse("http://www.bestbuy.com/shop/thermometers")
 6 | 
 7 | req = Net::HTTP::Get.new(url.path)
 8 | req.add_field("User-Agent", "Ruby RDF Distiller")
 9 | Net::HTTP.start(url.host, url.port) do |http|
10 |   http.request(req) do |res|
11 |     res.value # Raises HTTP error, unless response is successful
12 |     puts "read returned:\n#{res.body}"
13 |   end
14 | end
15 | 


--------------------------------------------------------------------------------
/example-files/jeni-ice-cream.html:
--------------------------------------------------------------------------------
 1 | <div vocab="#" typeof="">
 2 |   <p>Flavors in my favorite ice cream:</p>
 3 |   <div rel="flavor">
 4 |     <ul vocab="http://www.w3.org/1999/02/22-rdf-syntax-ns#" typeof="List">
 5 |       <li property="first">Lemon sorbet</li>
 6 |       <li rel="rest">
 7 |         <span typeof="List">
 8 |           <span property="first">Apricot sorbet</span>
 9 |         <span rel="rest" resource="rdf:nil"></span>
10 |       </span>
11 |       </li>
12 |     </ul>
13 |   </div>
14 | </div>
15 | 


--------------------------------------------------------------------------------
/lib/rdf/rdfa/version.rb:
--------------------------------------------------------------------------------
 1 | module RDF::RDFa::VERSION
 2 |   VERSION_FILE = File.join(File.expand_path(File.dirname(__FILE__)), "..", "..", "..", "VERSION")
 3 |   MAJOR, MINOR, TINY, EXTRA = File.read(VERSION_FILE).chop.split(".")
 4 | 
 5 |   STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')
 6 | 
 7 |   ##
 8 |   # @return [String]
 9 |   def self.to_s()   STRING end
10 | 
11 |   ##
12 |   # @return [String]
13 |   def self.to_str() STRING end
14 | 
15 |   ##
16 |   # @return [Array(Integer, Integer, Integer)]
17 |   def self.to_a() STRING.split(".") end
18 | end
19 | 


--------------------------------------------------------------------------------
/lib/rdf/rdfa/context/html.rb:
--------------------------------------------------------------------------------
 1 | # This file is automatically generated by ./script/intern_context
 2 | # RDFa context for http://www.w3.org/2011/rdfa-context/html-rdfa-1.1
 3 | 
 4 | class RDF::RDFa::Context
 5 |   def self.find_with_html_rdfa_1_1(uri)
 6 |     if uri.to_s == "http://www.w3.org/2011/rdfa-context/html-rdfa-1.1"
 7 |       @_html_rdfa_1_1_prof ||= RDF::RDFa::Context.new(RDF::URI("http://www.w3.org/2011/rdfa-context/html-rdfa-1.1"),
 8 |       )
 9 |     else
10 |       find_without_html_rdfa_1_1(uri)
11 |     end
12 |   end
13 | 
14 |   class << self
15 |     ##
16 |     # Override find to return this context, if matched
17 |     alias_method :find_without_html_rdfa_1_1, :find
18 |     alias_method :find, :find_with_html_rdfa_1_1
19 |   end
20 | end
21 | 


--------------------------------------------------------------------------------
/example.rb:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env ruby
 2 | 
 3 | require 'rubygems'
 4 | require 'rdf/rdfa'
 5 | 
 6 | data = <<-EOF;
 7 |   <?xml version="1.0" encoding="UTF-8"?>
 8 |   <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.0//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd"> 
 9 |   <html xmlns="http://www.w3.org/1999/xhtml" version="XHTML+RDFa 1.0" 
10 |      xmlns:dc="http://purl.org/dc/elements/1.1/">
11 |   <head>
12 |      <title>Test 0001</title>
13 |   </head>
14 |   <body>
15 |      <p>This photo was taken by <span class="author" about="photo1.jpg" property="dc:creator">Mark Birbeck</span>.</p>
16 |   </body>
17 |   </html>
18 | EOF
19 | 
20 | reader = RDF::RDFa::Reader.new(data, base_uri: 'http://rdfa.info/test-suite/test-cases/xhtml1/0001.xhtml')
21 | reader.each_statement do |statement|
22 |   statement.inspect!
23 | end
24 | 


--------------------------------------------------------------------------------
/.github/workflows/generate-docs.yml:
--------------------------------------------------------------------------------
 1 | name: Build & deploy documentation
 2 | on:
 3 |   push:
 4 |     branches:
 5 |       - master
 6 |   workflow_dispatch:
 7 | jobs:
 8 |   build:
 9 |     runs-on: ubuntu-latest
10 |     name: Update gh-pages with docs
11 |     steps:
12 |       - name: Clone repository
13 |         uses: actions/checkout@v3
14 |       - name: Set up Ruby
15 |         uses: ruby/setup-ruby@v1
16 |         with:
17 |           ruby-version: "3.1"
18 |       - name: Install required gem dependencies
19 |         run: gem install yard --no-document
20 |       - name: Build YARD Ruby Documentation
21 |         run: yardoc
22 |       - name: Deploy
23 |         uses: peaceiris/actions-gh-pages@v3
24 |         with:
25 |           github_token: ${{ secrets.GITHUB_TOKEN }}
26 |           publish_dir: ./doc/yard
27 |           publish_branch: gh-pages
28 | 


--------------------------------------------------------------------------------
/example-files/property-copying.html:
--------------------------------------------------------------------------------
 1 | <div vocab="http://schema.org/">
 2 |   <div resource="#muse" typeof="rdfa:Pattern">
 3 |     <link property="image" href="Muse1.jpg"/>
 4 |     <link property="image" href="Muse2.jpg"/>
 5 |     <link property="image" href="Muse3.jpg"/>
 6 |     <span property="name">Muse</span>
 7 |   </div>
 8 | 
 9 |   <p typeof="MusicEvent">
10 |     <link property="rdfa:copy" href="#muse"/>
11 |     Muse at the United Center.
12 |     <time property="startDate" datetime="2013-03-03">March 3rd 2013</time>, 
13 |     <a property="location" href="#united">United Center, Chicago, Illinois</a>
14 |     ...
15 |   </p>
16 | 
17 |   <p typeof="MusicEvent">
18 |     <link property="rdfa:copy" href="#muse"/>
19 |     Muse at the Target Center.
20 |     <time property="startDate" datetime="2013-03-07">March 7th 2013</time>, 
21 |     <a property="location" href="#target">Target Center, Minneapolis, Minnesota</a>
22 |     ...
23 |   </p>
24 | </div>


--------------------------------------------------------------------------------
/spec/jruby_spec.rb:
--------------------------------------------------------------------------------
 1 | # coding: utf-8
 2 | require_relative 'spec_helper'
 3 | require 'rdf/spec/reader'
 4 | 
 5 | if RUBY_PLATFORM.to_s == 'jruby'
 6 |   # Some specific issues that fail with jRuby to be resolved
 7 |   have_nokogiri = true
 8 |   begin
 9 |     require 'nokogiri'
10 |   rescue LoadError
11 |     have_nokogiri = false
12 |   end
13 | 
14 |   # Some specific issues that fail with jRuby to be resolved
15 |   describe "JRuby", skip: ("Not unless Nokogiri loaded" if !defined?(Nokogiri)) do
16 |     describe "Nokogiri::XML" do
17 |       describe "parse" do
18 |         it "parses namespaced elements without a namespace" do
19 |           expect(Nokogiri::XML.parse("<dc:sup>bar</dc:sup>").root).not_to be_nil
20 |         end
21 |       end
22 |     end
23 | 
24 |     describe "Nokogiri::HTML", skip: ("Not unless Nokogiri loaded" if !defined?(Nokogiri)) do
25 |       describe "xmlns" do
26 |         it "shows namespace definitions" do
27 |           doc = Nokogiri::HTML.parse(%q(<html xmlns:dc="http://purl.org/dc/elements/1.1/"></html>))
28 |           expect(doc.root.namespace_definitions).to be_empty
29 |           expect(doc.root.attributes).not_to be_empty
30 |         end
31 |       end
32 |     end
33 |   end
34 | end
35 | 


--------------------------------------------------------------------------------
/UNLICENSE:
--------------------------------------------------------------------------------
 1 | This is free and unencumbered software released into the public domain.
 2 | 
 3 | Anyone is free to copy, modify, publish, use, compile, sell, or
 4 | distribute this software, either in source code form or as a compiled
 5 | binary, for any purpose, commercial or non-commercial, and by any
 6 | means.
 7 | 
 8 | In jurisdictions that recognize copyright laws, the author or authors
 9 | of this software dedicate any and all copyright interest in the
10 | software to the public domain. We make this dedication for the benefit
11 | of the public at large and to the detriment of our heirs and
12 | successors. We intend this dedication to be an overt act of
13 | relinquishment in perpetuity of all present and future rights to this
14 | software under copyright law.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 | OTHER DEALINGS IN THE SOFTWARE.
23 | 
24 | For more information, please refer to <https://unlicense.org/>
25 | 


--------------------------------------------------------------------------------
/example-files/schema-person.html:
--------------------------------------------------------------------------------
 1 | <div vocab="http://schema.org/" about="#manu" typeof="Person">
 2 |   <span property="name">Manu Sporny</span>
 3 |   <img property="image" src="manu.jpg" />
 4 | 
 5 |   Gender: <span property="gender">Male</span>
 6 | 
 7 |   <span property="jobTitle">Founder/CEO</span>
 8 |   <div property="address" resource="#manu-address" typeof="PostalAddress">
 9 |     <span property="streetAddress">1700 Kraft Drive, Suite 2408</span>
10 |     <span property="addressLocality">Blacksburg</span>,
11 |     <span property="addressRegion">VA</span>
12 |     <span property="postalCode">24060</span>
13 |   </div>
14 |   <span property="telephone">(540) 961-4469</span>
15 |   <a property="email" href="mailto:msporny@digitalbazaar.com">msporny@digitalbazaar.com</a>
16 | 
17 |   Manu's home page:
18 |   <a property="url" href="http://manu.sporny.org/">manu.sporny.org</a>
19 | 
20 |   Colleagues:
21 |   <a property="colleagues" href="http://greggkellogg.net/foaf#me">Gregg Kellogg</a>
22 |   <a property="colleagues" href="http://openspring.net/scor#me">Stéphan Corlosquet</a>
23 |   
24 |   Acquaintences:
25 |   <div rel="knows">
26 |     <span typeof="Person" property="name">Michael Hausenblas</span>
27 |     <span typeof="Person" property="name">Richard Cyganiak</span>
28 |     <span typeof="Person" property="name">Stéphane Corlosquet</span>
29 |   </div>
30 | </div>
31 | 


--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
 1 | # This workflow runs continuous CI across different versions of ruby on all branches and pull requests to develop.
 2 | 
 3 | name: CI
 4 | on:
 5 |   push:
 6 |     branches: [ '**' ]
 7 |   pull_request:
 8 |     branches: [ develop ]
 9 |   workflow_dispatch:
10 | 
11 | jobs:
12 |   tests:
13 |     name: Ruby ${{ matrix.ruby }} ${{ matrix.gemfile }}
14 |     if: "contains(github.event.commits[0].message, '[ci skip]') == false"
15 |     runs-on: ubuntu-latest
16 |     env:
17 |       CI: true
18 |       ALLOW_FAILURES: ${{ endsWith(matrix.ruby, 'head') || matrix.ruby == 'jruby' }}
19 |       BUNDLE_GEMFILE: "${{ matrix.gemfile }}"
20 |     strategy:
21 |       fail-fast: false
22 |       matrix:
23 |         ruby: ['3.0', 3.1, 3.2, 3.3, ruby-head, jruby]
24 |         gemfile:
25 |           - Gemfile
26 |           - Gemfile-pure
27 |     steps:
28 |       - name: Clone repository
29 |         uses: actions/checkout@v3
30 |       - name: Set up Ruby
31 |         uses: ruby/setup-ruby@v1
32 |         with:
33 |           ruby-version: ${{ matrix.ruby }}
34 |       - name: Install dependencies
35 |         run: bundle install --jobs 4 --retry 3
36 |       - name: Run tests
37 |         run: ruby --version; bundle exec rspec spec || $ALLOW_FAILURES
38 |       - name: Coveralls GitHub Action
39 |         uses: coverallsapp/github-action@v2
40 |         if: ${{ matrix.ruby == '3.3' && matrix.gemfile == 'Gemfile' }}
41 |         with:
42 |           github-token: ${{ secrets.GITHUB_TOKEN }}
43 | 


--------------------------------------------------------------------------------
/lib/rdf/rdfa.rb:
--------------------------------------------------------------------------------
 1 | $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..')))
 2 | require 'rdf'
 3 | 
 4 | module RDF
 5 |   ##
 6 |   # **`RDF::RDFa`** is an RDFa extension for RDF.rb.
 7 |   #
 8 |   # @example Requiring the `RDF::RDFa` module
 9 |   #   require 'rdf/rdfa'
10 |   #
11 |   # @example Parsing RDF statements from an XHTML+RDFa file
12 |   #   RDF::RDFa::Reader.open("etc/doap.html") do |reader|
13 |   #     reader.each_statement do |statement|
14 |   #       puts statement.inspect
15 |   #     end
16 |   #   end
17 |   #
18 |   # @see https://rubygems.org/gems/rdf
19 |   # @see https://www.w3.org/TR/rdfa-syntax/#s_model RDFa 1.0
20 |   # @see https://www.w3.org/TR/2012/REC-rdfa-core-20120607/
21 |   # @see https://www.w3.org/TR/2012/CR-xhtml-rdfa-20120313/
22 |   # @see https://dev.w3.org/html5/rdfa/
23 |   #
24 |   # @author [Gregg Kellogg](https://greggkellogg.net/)
25 |   module RDFa
26 |     require 'rdf/rdfa/format'
27 |     require 'rdf/rdfa/vocab'
28 |     require 'rdf/rdfa/patches/string_hacks'
29 |     autoload :Expansion,  'rdf/rdfa/expansion'
30 |     autoload :Context,    'rdf/rdfa/context'
31 |     autoload :Reader,     'rdf/rdfa/reader'
32 |     autoload :Writer,     'rdf/rdfa/writer'
33 |     autoload :VERSION,    'rdf/rdfa/version'
34 | 
35 |     HTML_RDFA_CONTEXT   = "http://www.w3.org/2011/rdfa-context/html-rdfa-1.1"
36 |     XHTML_RDFA_CONTEXT  = "http://www.w3.org/2011/rdfa-context/xhtml-rdfa-1.1"
37 |     XML_RDFA_CONTEXT    = "http://www.w3.org/2011/rdfa-context/rdfa-1.1"
38 |   end
39 | end
40 | 


--------------------------------------------------------------------------------
/Gemfile-pure:
--------------------------------------------------------------------------------
 1 | # "Pure" version with out C dependencies
 2 | source "https://rubygems.org"
 3 | 
 4 | gemspec
 5 | 
 6 | gem "rdf",            github: "ruby-rdf/rdf",      branch: "develop"
 7 | gem "rdf-spec",       github: "ruby-rdf/rdf-spec", branch: "develop"
 8 | gem "rdf-xsd",        github: "ruby-rdf/rdf-xsd",  branch: "develop"
 9 | 
10 | group :development, :test do
11 |   gem 'ebnf',               github: "dryruby/ebnf",                 branch: "develop"
12 |   gem 'json-ld',            github: "ruby-rdf/json-ld",             branch: "develop"
13 |   gem 'rdf-aggregate-repo', github: "ruby-rdf/rdf-aggregate-repo",  branch: "develop"
14 |   gem "rdf-microdata",      github: "ruby-rdf/rdf-microdata",       branch: "develop"
15 |   gem 'rdf-turtle',         github: "ruby-rdf/rdf-turtle",          branch: "develop"
16 |   gem 'rdf-tabular',        github: "ruby-rdf/rdf-tabular",         branch: "develop"
17 |   gem 'rdf-isomorphic',     github: "ruby-rdf/rdf-isomorphic",      branch: "develop"
18 |   gem 'rdf-rdfxml',         github: "ruby-rdf/rdf-rdfxml",          branch: "develop"
19 |   gem 'rdf-vocab',          github: "ruby-rdf/rdf-vocab",           branch: "develop"
20 |   gem 'sparql',             github: "ruby-rdf/sparql",              branch: "develop"
21 |   gem 'sparql-client',      github: "ruby-rdf/sparql-client",       branch: "develop"
22 |   gem 'sxp',                github: "dryruby/sxp.rb",               branch: "develop"
23 | end
24 | 
25 | group :debug do
26 |   gem "syntax"
27 |   gem "byebug", platforms: :mri
28 | end
29 | 


--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
 1 | require 'rubygems'
 2 | require 'yard'
 3 | require 'rspec/core/rake_task'
 4 | 
 5 | namespace :gem do
 6 |   desc "Build the rdf-rdfa-#{File.read('VERSION').chomp}.gem file"
 7 |   task :build do
 8 |     sh "gem build rdf-rdfa.gemspec && mv rdf-rdfa-#{File.read('VERSION').chomp}.gem pkg/"
 9 |   end
10 | 
11 |   desc "Release the rdf-rdfa-#{File.read('VERSION').chomp}.gem file"
12 |   task :release do
13 |     sh "gem push pkg/rdf-rdfa-#{File.read('VERSION').chomp}.gem"
14 |   end
15 | end
16 | 
17 | RSpec::Core::RakeTask.new(:spec)
18 | 
19 | desc "Run specs through RCov"
20 | RSpec::Core::RakeTask.new("spec:rcov") do |spec|
21 |   spec.rcov = true
22 |   spec.rcov_opts =  %q[--exclude "spec"]
23 | end
24 | 
25 | desc "Update RDFa Contexts"
26 | task :update_contexts do
27 |   {
28 |     html: "http://www.w3.org/2011/rdfa-context/html-rdfa-1.1",
29 |     xhtml: "http://www.w3.org/2011/rdfa-context/xhtml-rdfa-1.1",
30 |     xml: "http://www.w3.org/2011/rdfa-context/rdfa-1.1",
31 |   }.each do |v, uri|
32 |     puts "Build #{uri}"
33 |     vocab = File.expand_path(File.join(File.dirname(__FILE__), "lib", "rdf", "rdfa", "context", "#{v}.rb"))
34 |     FileUtils.rm_rf(vocab)
35 |     `./script/intern_context -o #{vocab} #{uri}`
36 |   end
37 | end
38 | 
39 | namespace :doc do
40 |   YARD::Rake::YardocTask.new
41 | 
42 |   desc "Generate HTML report specs"
43 |   RSpec::Core::RakeTask.new("spec") do |spec|
44 |     spec.rspec_opts = ["--format", "html", "-o", "doc/spec.html"]
45 |   end
46 | end
47 | 
48 | task default: :spec
49 | task specs: :spec


--------------------------------------------------------------------------------
/example-files/stain-validation.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en" prefix="ex: http://example.com/ ">
 3 | <head>
 4 |   <title>HTML5 + RDFa support ? #19</title>
 5 |   <meta charset="utf-8"/>
 6 |   <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.5/css/bootstrap.min.css"/>
 7 | </head>
 8 | <body>
 9 |   <!-- Typical Bootstrap use of HTML5 tag <nav> -->
10 |   <nav class="navbar navbar-inverse navbar-fixed-top">
11 |     <div class="container">
12 |       <div class="navbar-header">
13 |         <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar">
14 |           <span class="sr-only">Toggle navigation</span>
15 |           <span class="icon-bar"></span>
16 |         </button>
17 |         Ontology
18 |       </div>
19 |       <div id="navbar" class="collapse navbar-collapse">
20 |         <ul class="nav navbar-nav">
21 |           <li class="active"><a href="#">Home</a></li>
22 |           <li><a href="#_classes">Classes</a></li>
23 |         </ul>
24 |       </div>
25 |     </div>
26 |   </nav>
27 | 
28 | <!-- Bootstrap use of "container" div and role="main" -->
29 | <div class="container" role="main" style="margin-top: 3em">
30 | 
31 | <!-- START RDFa bit -->
32 |   <div about="http://example.com/">
33 |     <div rev="skos:inScheme">
34 |       <section id="_classes">
35 |         <h2>Classes</h2>
36 |         <div id="Example" about="http://example.com/Example" typeof="owl:Class">
37 |           <h3 property="rdfs:label">Example label</h3>
38 |         </div>
39 |       </section>
40 |     </div>
41 |   </div>
42 | <!-- END RDFa bit -->
43 | 
44 | </div>
45 | 
46 | 
47 | </body>
48 | </html>
49 | 


--------------------------------------------------------------------------------
/example-files/0316-out.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html prefix='rdf: http://www.w3.org/1999/02/22-rdf-syntax-ns# rdfs: http://www.w3.org/2000/01/rdf-schema#' xmlns='http://www.w3.org/1999/xhtml'>
 3 |   <head>
 4 |     <title>http://example.org/profiles/director.html</title>
 5 |     <link href='http://rdf.greggkellogg.net/css/distiller.css' rel='stylesheet' type='text/css'>
 6 |     <script src='https://ajax.googleapis.com/ajax/libs/jquery/1.5.1/jquery.min.js' type='text/javascript'></script>
 7 |     <script src='http://rdf.greggkellogg.net/js/distiller.js' type='text/javascript'></script>
 8 |   </head>
 9 |   <body>
10 |     <div resource='http://rdfa.info/test-suite/test-cases/rdfa1.1/html5/0316.html'>
11 |       <table class='properties'>
12 |         <tr class='property'>
13 |           <td class='label'>
14 |             http://example.org/role
15 |           </td>
16 |           <td rel='http://example.org/role' resource='_:g70159584611200' typeof=''>
17 |             <span class='type'></span>
18 |             <table class='properties'>
19 |               <tr class='property'>
20 |                 <td class='label'>
21 |                   rdfs:label
22 |                 </td>
23 |                 <td rel='rdfs:label' resource='http://example.org/profiles/director.html' typeof='http://example.org/Role'>
24 |                   <span class='type'>http://example.org/Role</span>
25 |                   <table class='properties'>
26 |                   </table>
27 |                 </td>
28 |               </tr>
29 |             </table>
30 |           </td>
31 |         </tr>
32 |       </table>
33 |     </div>
34 | 
35 |     <footer>
36 |       <p>Written by <a href='https://rubygems.org/gems/rdf-rdfa'>RDF::RDFa</a> version 2.1.1</p>
37 |     </footer>
38 |   </body>
39 | </html>
40 | 


--------------------------------------------------------------------------------
/Gemfile:
--------------------------------------------------------------------------------
 1 | source "https://rubygems.org"
 2 | 
 3 | gemspec
 4 | 
 5 | gem "rdf",            github: "ruby-rdf/rdf",      branch: "develop"
 6 | gem "rdf-spec",       github: "ruby-rdf/rdf-spec", branch: "develop"
 7 | gem "rdf-xsd",        github: "ruby-rdf/rdf-xsd",  branch: "develop"
 8 | gem "nokogiri",       '~> 1.15', '>= 1.13.4', platforms: [:mri, :jruby]
 9 | gem 'equivalent-xml', '~> 0.6'
10 | 
11 | group :development, :test do
12 |   gem 'ebnf',               github: "dryruby/ebnf",                 branch: "develop"
13 |   gem 'json-ld',            github: "ruby-rdf/json-ld",             branch: "develop"
14 |   gem 'rdf-aggregate-repo', github: "ruby-rdf/rdf-aggregate-repo",  branch: "develop"
15 |   gem 'rdf-isomorphic',     github: "ruby-rdf/rdf-isomorphic",      branch: "develop"
16 |   gem "rdf-microdata",      github: "ruby-rdf/rdf-microdata",       branch: "develop"
17 |   gem 'rdf-rdfxml',         github: "ruby-rdf/rdf-rdfxml",          branch: "develop"
18 |   gem 'rdf-tabular',        github: "ruby-rdf/rdf-tabular",         branch: "develop"
19 |   gem 'rdf-turtle',         github: "ruby-rdf/rdf-turtle",          branch: "develop"
20 |   gem 'rdf-vocab',          github: "ruby-rdf/rdf-vocab",           branch: "develop"
21 |   gem 'sparql',             github: "ruby-rdf/sparql",              branch: "develop"
22 |   gem 'sparql-client',      github: "ruby-rdf/sparql-client",       branch: "develop"
23 |   gem 'sxp',                github: "dryruby/sxp.rb",               branch: "develop"
24 | end
25 | 
26 | group :test do
27 |   gem 'simplecov', '~> 0.22',  platforms: :mri
28 |   gem 'simplecov-lcov', '~> 0.8',  platforms: :mri
29 | end
30 | 
31 | group :debug do
32 |   gem "syntax"
33 |   gem "byebug", platforms: :mri
34 |   gem "rake"
35 | end
36 | 
37 | platforms :jruby do
38 |   gem 'gson',     '~> 0.6'
39 | end
40 | 


--------------------------------------------------------------------------------
/spec/spec_helper.rb:
--------------------------------------------------------------------------------
 1 | $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 2 | 
 3 | require "bundler/setup"
 4 | require 'rubygems'
 5 | require 'rspec'
 6 | require 'yaml'
 7 | require 'rdf/isomorphic'
 8 | require 'rdf/spec'
 9 | require 'rdf/spec/matchers'
10 | require 'rdf/turtle'
11 | require 'rdf/vocab'
12 | require_relative 'matchers'
13 | 
14 | begin
15 |   require 'nokogiri'
16 | rescue LoadError
17 | end
18 | begin
19 |   require 'simplecov'
20 |   require 'simplecov-lcov'
21 |   SimpleCov::Formatter::LcovFormatter.config do |config|
22 |     #Coveralls is coverage by default/lcov. Send info results
23 |     config.report_with_single_file = true
24 |     config.single_report_path = 'coverage/lcov.info'
25 |   end
26 | 
27 |   SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
28 |     SimpleCov::Formatter::HTMLFormatter,
29 |     SimpleCov::Formatter::LcovFormatter
30 |   ])
31 |   SimpleCov.start do
32 |     add_filter "/spec/"
33 |     add_filter "/lib/rdf/rdfa/reader/rexml.rb"
34 |     add_filter "/lib/rdf/rdfa/context.rb"
35 |   end
36 | rescue LoadError
37 | end
38 | require 'rdf/rdfa'
39 | 
40 | ::RSpec.configure do |c|
41 |   c.filter_run focus: true
42 |   c.run_all_when_everything_filtered = true
43 |   c.exclusion_filter = {
44 |     ruby:     lambda { |version| !(RUBY_VERSION.to_s =~ /^#{version}/) },
45 |   }
46 |   c.include(RDF::Spec::Matchers)
47 | end
48 | 
49 | TMP_DIR = File.join(File.expand_path(File.dirname(__FILE__)), "tmp")
50 | 
51 | # Heuristically detect the input stream
52 | def detect_format(stream)
53 |   # Got to look into the file to see
54 |   if stream.is_a?(IO) || stream.is_a?(StringIO)
55 |     stream.rewind
56 |     string = stream.read(1000)
57 |     stream.rewind
58 |   else
59 |     string = stream.to_s
60 |   end
61 |   case string
62 |   when /<html/i   then RDF::RDFa::Reader
63 |   when /@prefix/i then RDF::Turtle::Reader
64 |   else                 RDF::NTriples::Reader
65 |   end
66 | end
67 | 


--------------------------------------------------------------------------------
/lib/rdf/rdfa/format.rb:
--------------------------------------------------------------------------------
 1 | module RDF::RDFa
 2 |   ##
 3 |   # RDFa format specification.
 4 |   #
 5 |   # @example Obtaining an RDFa format class
 6 |   #   RDF::Format.for(:rdfa)     #=> RDF::RDFa::Format
 7 |   #   RDF::Format.for("etc/doap.html")
 8 |   #   RDF::Format.for(file_name:      "etc/doap.html")
 9 |   #   RDF::Format.for(file_extension: "html")
10 |   #   RDF::Format.for(content_type:   "text/html")
11 |   #   RDF::Format.for(content_type:   "application/xhtml+xml")
12 |   #
13 |   # @example Obtaining serialization format MIME types
14 |   #   RDF::Format.content_types      #=> {"text/html" => [RDF::RDFa::Format]}
15 |   #
16 |   # @example Obtaining serialization format file extension mappings
17 |   #   RDF::Format.file_extensions    #=> {xhtml: "application/xhtml+xml"}
18 |   #
19 |   # @see https://www.w3.org/TR/rdf-testcases/#ntriples
20 |   class Format < RDF::Format
21 |     content_encoding 'utf-8'
22 |     content_type     'text/html;q=0.5',
23 |       aliases: %w(application/xhtml+xml;q=0.7 image/svg+xml;q=0.4),
24 |       extensions: [:html, :xhtml, :svg],
25 |       uri: 'http://www.w3.org/ns/formats/RDFa'
26 |     reader { RDF::RDFa::Reader }
27 |     writer { RDF::RDFa::Writer }
28 | 
29 |     ##
30 |     # Sample detection to see if it matches RDFa (not RDF/XML or Microdata)
31 |     #
32 |     # Use a text sample to detect the format of an input file. Sub-classes implement
33 |     # a matcher sufficient to detect probably format matches, including disambiguating
34 |     # between other similar formats.
35 |     #
36 |     # @param [String] sample Beginning several bytes (~ 1K) of input.
37 |     # @return [Boolean]
38 |     def self.detect(sample)
39 |       (sample.match(/<[^>]*(about|resource|prefix|typeof|property|vocab)\s*="[^>]*>/m) ||
40 |        sample.match(/<[^>]*DOCTYPE\s+html[^>]*>.*xmlns:/im)
41 |       ) && !sample.match(/<(\w+:)?(RDF)/)
42 |     end
43 | 
44 |     def self.symbols
45 |       [:rdfa, :lite, :html, :xhtml, :svg]
46 |     end
47 |   end
48 | end
49 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # How to contribute
 2 | 
 3 | Community contributions are essential for keeping Ruby RDF great. We want to keep it as easy as possible to contribute changes that get things working in your environment. There are a few guidelines that we need contributors to follow so that we can have a chance of keeping on top of things.
 4 | 
 5 | ## Development
 6 | 
 7 | This repository uses [Git Flow](https://github.com/nvie/gitflow) to manage development and release activity. All submissions _must_ be on a feature branch based on the _develop_ branch to ease staging and integration.
 8 | 
 9 | * create or respond to an issue on the [Github Repository](https://github.com/ruby-rdf/rdf-rdfa/issues)
10 | * Fork and clone the repo:
11 |   `git clone git@github.com:your-username/rdf-rdfa.git`
12 | * Install bundle:
13 |   `bundle install`
14 | * Create tests in RSpec and make sure you achieve at least 90% code coverage for the feature your adding or behavior being modified.
15 | * Push to your fork and [submit a pull request][pr].
16 | 
17 | ## Do's and Dont's
18 | * Do your best to adhere to the existing coding conventions and idioms.
19 | * Don't use hard tabs, and don't leave trailing whitespace on any line.
20 |   Before committing, run `git diff --check` to make sure of this.
21 | * Do document every method you add using [YARD][] annotations. Read the
22 |   [tutorial][YARD-GS] or just look at the existing code for examples.
23 | * Don't touch the `.gemspec` or `VERSION` files. If you need to change them,
24 |   do so on your private branch only.
25 | * Do feel free to add yourself to the `CREDITS` file and the
26 |   corresponding list in the the `README`. Alphabetical order applies.
27 | * Don't touch the `AUTHORS` file. If your contributions are significant
28 |   enough, be assured we will eventually add you in there.
29 | * Do note that in order for us to merge any non-trivial changes (as a rule
30 |   of thumb, additions larger than about 15 lines of code), we need an
31 |   explicit [public domain dedication][PDD] on record from you,
32 |   which you will be asked to agree to on the first commit to a repo within the organization.
33 |   Note that the agreement applies to all repos in the [Ruby RDF](https://github.com/ruby-rdf/) organization.
34 | 
35 | [YARD]:    https://yardoc.org/
36 | [YARD-GS]: https://rubydoc.info/docs/yard/file/docs/GettingStarted.md
37 | [PDD]:              https://unlicense.org/#unlicensing-contributions
38 | [pr]:      https://github.com/ruby-rdf/rdf/compare/
39 | 


--------------------------------------------------------------------------------
/spec/context_spec.rb:
--------------------------------------------------------------------------------
 1 | require_relative 'spec_helper'
 2 | 
 3 | describe RDF::RDFa::Context do
 4 |   describe ".new" do
 5 |     describe "foaf" do
 6 |       subject { RDF::RDFa::Context.new("http://example/") }
 7 | 
 8 |       it "has a URI" do
 9 |         expect(subject.uri).to eq RDF::URI("http://example/")
10 |       end
11 | 
12 |       it "has no terms" do
13 |         expect(subject.terms).to be_empty
14 |       end
15 | 
16 |       it "has no vocabulary" do
17 |         expect(subject.vocabulary).to be_nil
18 |       end
19 | 
20 |       it "has no prefixes" do
21 |         expect(subject.prefixes).to be_empty
22 |       end
23 |     end
24 |   end
25 | 
26 |   describe ".find" do
27 |     describe "rdfa-1.1" do
28 |       subject { RDF::RDFa::Context.find("http://www.w3.org/2011/rdfa-context/rdfa-1.1") }
29 | 
30 |       it "has 3 terms" do
31 |         expect(subject.terms.keys.length).to eq 3
32 |       end
33 | 
34 |       it "uses symbols for term lookup" do
35 |         expect(subject.terms.keys).to be_all {|k| k.is_a?(Symbol)}
36 |       end
37 | 
38 |       it "has no vocabulary" do
39 |         expect(subject.vocabulary).to be_nil
40 |       end
41 | 
42 |       it "has at least 10 prefixes" do
43 |         expect(subject.prefixes.keys.length).to be >= 10
44 |       end
45 |     end
46 | 
47 |     describe "html+rdfa-1.1" do
48 |       subject { RDF::RDFa::Context.find("http://www.w3.org/2011/rdfa-context/html-rdfa-1.1") }
49 | 
50 |       it "has 0 terms" do
51 |         expect(subject.terms.keys).to be_empty
52 |       end
53 | 
54 |       it "has no vocabulary" do
55 |         expect(subject.vocabulary).to be_nil
56 |       end
57 | 
58 |       it "has no prefixes" do
59 |         expect(subject.prefixes.keys).to be_empty
60 |       end
61 | 
62 |       it "uses symbols for prefix lookup" do
63 |         expect(subject.prefixes.keys).to be_all {|k| k.is_a?(Symbol)}
64 |       end
65 |     end
66 | 
67 |     describe "xhtml+rdfa-1.1" do
68 |       subject { RDF::RDFa::Context.find("http://www.w3.org/2011/rdfa-context/xhtml-rdfa-1.1") }
69 | 
70 |       it "has 25 terms" do
71 |         expect(subject.terms.keys.length).to eq 25
72 |       end
73 | 
74 |       it "has no vocabulary" do
75 |         expect(subject.vocabulary).to be_nil
76 |       end
77 | 
78 |       it "has no prefixes" do
79 |         expect(subject.prefixes.keys).to be_empty
80 |       end
81 | 
82 |       it "uses symbols for prefix lookup" do
83 |         expect(subject.prefixes.keys).to be_all {|k| k.is_a?(Symbol)}
84 |       end
85 |     end
86 |   end
87 | end
88 | 


--------------------------------------------------------------------------------
/lib/rdf/rdfa/context/xhtml.rb:
--------------------------------------------------------------------------------
 1 | # This file is automatically generated by ./script/intern_context
 2 | # RDFa context for http://www.w3.org/2011/rdfa-context/xhtml-rdfa-1.1
 3 | 
 4 | class RDF::RDFa::Context
 5 |   def self.find_with_xhtml_rdfa_1_1(uri)
 6 |     if uri.to_s == "http://www.w3.org/2011/rdfa-context/xhtml-rdfa-1.1"
 7 |       @_xhtml_rdfa_1_1_prof ||= RDF::RDFa::Context.new(RDF::URI("http://www.w3.org/2011/rdfa-context/xhtml-rdfa-1.1"),
 8 |         terms: {
 9 |           alternate:  "http://www.w3.org/1999/xhtml/vocab#alternate",
10 |           appendix:   "http://www.w3.org/1999/xhtml/vocab#appendix",
11 |           bookmark:   "http://www.w3.org/1999/xhtml/vocab#bookmark",
12 |           chapter:    "http://www.w3.org/1999/xhtml/vocab#chapter",
13 |           cite:       "http://www.w3.org/1999/xhtml/vocab#cite",
14 |           contents:   "http://www.w3.org/1999/xhtml/vocab#contents",
15 |           copyright:  "http://www.w3.org/1999/xhtml/vocab#copyright",
16 |           first:      "http://www.w3.org/1999/xhtml/vocab#first",
17 |           glossary:   "http://www.w3.org/1999/xhtml/vocab#glossary",
18 |           help:       "http://www.w3.org/1999/xhtml/vocab#help",
19 |           icon:       "http://www.w3.org/1999/xhtml/vocab#icon",
20 |           index:      "http://www.w3.org/1999/xhtml/vocab#index",
21 |           last:       "http://www.w3.org/1999/xhtml/vocab#last",
22 |           license:    "http://www.w3.org/1999/xhtml/vocab#license",
23 |           meta:       "http://www.w3.org/1999/xhtml/vocab#meta",
24 |           next:       "http://www.w3.org/1999/xhtml/vocab#next",
25 |           p3pv1:      "http://www.w3.org/1999/xhtml/vocab#p3pv1",
26 |           prev:       "http://www.w3.org/1999/xhtml/vocab#prev",
27 |           previous:   "http://www.w3.org/1999/xhtml/vocab#previous",
28 |           section:    "http://www.w3.org/1999/xhtml/vocab#section",
29 |           start:      "http://www.w3.org/1999/xhtml/vocab#start",
30 |           stylesheet: "http://www.w3.org/1999/xhtml/vocab#stylesheet",
31 |           subsection: "http://www.w3.org/1999/xhtml/vocab#subsection",
32 |           top:        "http://www.w3.org/1999/xhtml/vocab#top",
33 |           up:         "http://www.w3.org/1999/xhtml/vocab#up",
34 |         },
35 |       )
36 |     else
37 |       find_without_xhtml_rdfa_1_1(uri)
38 |     end
39 |   end
40 | 
41 |   class << self
42 |     ##
43 |     # Override find to return this context, if matched
44 |     alias_method :find_without_xhtml_rdfa_1_1, :find
45 |     alias_method :find, :find_with_xhtml_rdfa_1_1
46 |   end
47 | end
48 | 


--------------------------------------------------------------------------------
/rdf-rdfa.gemspec:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env ruby -rubygems
 2 | # -*- encoding: utf-8 -*-
 3 | 
 4 | Gem::Specification.new do |gem|
 5 |   gem.version               = File.read('VERSION').chomp
 6 |   gem.date                  = File.mtime('VERSION').strftime('%Y-%m-%d')
 7 | 
 8 |   gem.name                  = %q{rdf-rdfa}
 9 |   gem.homepage              = "https://github.com/ruby-rdf/rdf-rdfa"
10 |   gem.license               = 'Unlicense'
11 |   gem.summary               = "RDFa reader/writer for RDF.rb."
12 |   gem.description           = "RDF::RDFa is an RDFa reader/writer for Ruby using the RDF.rb library suite."
13 |   gem.metadata           = {
14 |     "documentation_uri" => "https://ruby-rdf.github.io/rdf-rdfa",
15 |     "bug_tracker_uri"   => "https://github.com/ruby-rdf/rdf-rdfa/issues",
16 |     "homepage_uri"      => "https://github.com/ruby-rdf/rdf-rdfa",
17 |     "mailing_list_uri"  => "https://lists.w3.org/Archives/Public/public-rdf-ruby/",
18 |     "source_code_uri"   => "https://github.com/ruby-rdf/rdf-rdfa",
19 |   }
20 | 
21 |   gem.authors               = %w(Gregg Kellogg)
22 |   gem.email                 = 'public-rdf-ruby@w3.org'
23 | 
24 |   gem.platform              = Gem::Platform::RUBY
25 |   gem.files                 = %w(AUTHORS README.md UNLICENSE VERSION) + Dir.glob('lib/**/*.rb')
26 |   gem.require_paths         = %w(lib)
27 | 
28 |   gem.required_ruby_version = '>= 3.0'
29 |   gem.requirements          = []
30 | 
31 |   gem.add_runtime_dependency     'rdf',                 '~> 3.3'
32 |   gem.add_runtime_dependency     'rdf-vocab',           '~> 3.3'
33 |   gem.add_runtime_dependency     'haml',                '~> 6.1'
34 |   gem.add_runtime_dependency     'rdf-xsd',             '~> 3.3'
35 |   gem.add_runtime_dependency     'rdf-aggregate-repo',  '~> 3.3'
36 |   gem.add_runtime_dependency     'htmlentities',        '~> 4.3'
37 | 
38 |   gem.add_development_dependency 'getoptlong',          '~> 0.2'
39 |   gem.add_development_dependency 'json-ld',             '~> 3.3'
40 |   gem.add_development_dependency 'rspec',               '~> 3.12'
41 |   gem.add_development_dependency 'rspec-its',           '~> 1.3'
42 |   gem.add_development_dependency 'rdf-spec',            '~> 3.3'
43 |   gem.add_development_dependency 'rdf-turtle',          '~> 3.3'
44 |   gem.add_development_dependency 'rdf-isomorphic',      '~> 3.3'
45 |   gem.add_development_dependency 'rdf-tabular',         '~> 3.3'
46 |   gem.add_development_dependency 'rdf-rdfxml',          '~> 3.3'
47 |   gem.add_development_dependency 'sparql',              '~> 3.3'
48 |   gem.add_development_dependency 'yard' ,               '~> 0.9'
49 | 
50 |   gem.post_install_message  = nil
51 | end
52 | 
53 | 


--------------------------------------------------------------------------------
/spec/format_spec.rb:
--------------------------------------------------------------------------------
 1 | require_relative 'spec_helper'
 2 | require 'rdf/spec/format'
 3 | 
 4 | describe RDF::RDFa::Format do
 5 |   it_behaves_like 'an RDF::Format' do
 6 |     let(:format_class) {RDF::RDFa::Format}
 7 |   end
 8 | 
 9 |   describe ".for" do
10 |     formats = [
11 |       :rdfa, :lite, :html, :xhtml, :svg,
12 |       'etc/doap.html',
13 |       {file_name:      'etc/doap.html'},
14 |       {file_extension: 'html'},
15 |       {content_type:   'text/html'},
16 |     ].each do |arg|
17 |       it "discovers with #{arg.inspect}" do
18 |         expect(RDF::Format.for(arg)).to eq RDF::RDFa::Format
19 |       end
20 |     end
21 | 
22 |     {
23 |       rdfa:   '<div about="foo"></div>',
24 |     }.each do |sym, str|
25 |       it "detects #{sym}" do
26 |         expect(RDF::RDFa::Format.for {str}).to eq RDF::RDFa::Format
27 |       end
28 |     end
29 | 
30 |     it "uses text/html as first content type" do
31 |       expect(RDF::Format.for(:rdfa).content_type.first).to eq "text/html"
32 |     end
33 |   end
34 | 
35 |   describe "#to_sym" do
36 |     specify {expect(RDF::RDFa::Format.to_sym).to eq :rdfa}
37 |   end
38 | 
39 |   describe "#to_uri" do
40 |     specify {expect(described_class.to_uri).to eq RDF::URI('http://www.w3.org/ns/formats/RDFa')}
41 |   end
42 | 
43 |   describe ".detect" do
44 |     {
45 |       about:    '<div about="foo"></div>',
46 |       typeof:   '<div typeof="foo"></div>',
47 |       resource: '<div resource="foo"></div>',
48 |       vocab:    '<div vocab="foo"></div>',
49 |       prefix:   '<div prefix="foo"></div>',
50 |       property: '<div property="foo"></div>',
51 |     }.each do |sym, str|
52 |       it "detects #{sym}" do
53 |         expect(RDF::RDFa::Format.detect(str)).to be_truthy
54 |       end
55 |     end
56 | 
57 |     {
58 |       n3:                   "@prefix foo: <bar> .\nfoo:bar = {<a> <b> <c>} .",
59 |       nquads:               "<a> <b> <c> <d> . ",
60 |       rdfxml:               '<rdf:RDF about="foo"></rdf:RDF>',
61 |       jsonld:               '{"@context" => "foo"}',
62 |       ntriples:             "<a> <b> <c> .",
63 |       itemprop:  '<div itemprop="bar"></div>',
64 |       itemtype:  '<div itemtype="bar"></div>',
65 |       itemref:   '<div itemref="bar"></div>',
66 |       itemscope: '<div itemscope=""></div>',
67 |       itemid:    '<div itemid="bar"></div>',
68 |       multi_line:           '<a>\n  <b>\n  "literal"\n .',
69 |       turtle:               "@prefix foo: <bar> .\n foo:a foo:b <c> .",
70 |       STRING_LITERAL1:      %(<a> <b> 'literal' .),
71 |       STRING_LITERAL2:      %(<a> <b> "literal" .),
72 |       STRING_LITERAL_LONG1: %(<a> <b> '''\nliteral\n''' .),
73 |       STRING_LITERAL_LONG2: %(<a> <b> """\nliteral\n""" .),
74 |     }.each do |sym, str|
75 |       it "does not detect #{sym}" do
76 |         expect(RDF::RDFa::Format.detect(str)).to be_falsey
77 |       end
78 |     end
79 |   end
80 | end
81 | 


--------------------------------------------------------------------------------
/etc/doap.nt:
--------------------------------------------------------------------------------
 1 | <https://rubygems.org/gems/rdf-rdfa> <http://www.w3.org/ns/rdfa#usesVocabulary> <http://usefulinc.com/ns/doap#> .
 2 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#shortdesc> "RDFa reader/writer for Ruby."@en .
 3 | <https://rubygems.org/gems/rdf-rdfa> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://usefulinc.com/ns/doap#Project> .
 4 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#name> "RDF::RDFa" .
 5 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#description> "\n      RDF::RDFa is an RDFa reader/writer for Ruby using the RDF.rb library suite.\n    "@en .
 6 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#implements> <http://www.w3.org/TR/rdfa-syntax/> .
 7 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#implements> <http://www.w3.org/TR/rdfa-core/> .
 8 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#implements> <http://www.w3.org/TR/xhtml-rdfa/> .
 9 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#implements> <http://www.w3.org/TR/rdfa-in-html/> .
10 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#implements> <http://www.w3.org/TR/rdfa-lite/> .
11 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#implements> <http://www.w3.org/TR/role-attribute/> .
12 | <https://rubygems.org/gems/rdf-rdfa> <http://purl.org/dc/terms/creator> <http://greggkellogg.net/foaf#me> .
13 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#developer> <http://greggkellogg.net/foaf#me> .
14 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#documenter> <http://greggkellogg.net/foaf#me> .
15 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#maintainer> <http://greggkellogg.net/foaf#me> .
16 | <https://rubygems.org/gems/rdf-rdfa> <http://xmlns.com/foaf/0.1/maker> <http://greggkellogg.net/foaf#me> .
17 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#helper> <http://njh.me/> .
18 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#created> "2011-08-29"^^<http://www.w3.org/2001/XMLSchema#date> .
19 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#blog> <http://greggkellogg.net/> .
20 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#bug-database> <https://github.com/ruby-rdf/rdf-rdfa/issues> .
21 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#programming-language> "Ruby" .
22 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#category> <http://dbpedia.org/resource/Resource_Description_Framework> .
23 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#category> <http://dbpedia.org/resource/Ruby_(programming_language)> .
24 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#download-page> <https://rubygems.org/gems/rdf-rdfa> .
25 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#homepage> <https://github.com/ruby-rdf/rdf-rdfa> .
26 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#license> <https://unlicense.org/1.0/> .
27 | <https://rubygems.org/gems/rdf-rdfa> <http://usefulinc.com/ns/doap#mailing-list> <http://lists.w3.org/Archives/Public/public-rdf-ruby/> .
28 | 


--------------------------------------------------------------------------------
/script/intern_context:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env ruby
  2 | #
  3 | # Generate a Ruby version of an RDFa vocabulary to be directly accessible from RDF::RDFa::Context
  4 | require 'rubygems'
  5 | $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
  6 | require 'rdf/turtle'
  7 | require 'rdf/rdfa'
  8 | require 'rdf/rdfxml'
  9 | require 'getoptlong'
 10 | require 'open-uri'
 11 | 
 12 | def help
 13 |   puts "Usage: #{$0} [options] file-or-uri ..."
 14 |   puts "Options:"
 15 |   puts "      --dump:               Dump raw output, otherwise serialize to Ruby"
 16 |   puts "      --debug:              Display detailed debug output"
 17 |   puts "      --verbose:            Verbose processing"
 18 |   puts "      --output:             Write to file"
 19 |   puts "      --help,-?:            This message"
 20 |   exit(0)
 21 | end
 22 | 
 23 | dump = false
 24 | output = STDOUT
 25 | 
 26 | opts = GetoptLong.new(
 27 |   ["--debug", GetoptLong::NO_ARGUMENT],
 28 |   ["--dump", GetoptLong::NO_ARGUMENT],
 29 |   ["--output", "-o", GetoptLong::REQUIRED_ARGUMENT],
 30 |   ["--verbose", GetoptLong::NO_ARGUMENT],
 31 |   ["--help", "-?", GetoptLong::NO_ARGUMENT]
 32 | )
 33 | opts.each do |opt, arg|
 34 |   case opt
 35 |   when '--verbose'  then $verbose = true
 36 |   when '--debug'    then ::RDF::RDFa::debug = true
 37 |   when '--dump'     then dump = true
 38 |   when '--output'   then output = File.open(arg, "w")
 39 |   when '--help'     then help
 40 |   end
 41 | end
 42 | 
 43 | help if ARGV.empty?
 44 | 
 45 | ARGV.each do |file|
 46 |   uri = RDF::URI(file)
 47 |   if RDF::RDFa::Context.cache[uri]
 48 |     STDERR.puts "Remove cached entry for #{uri} before attempting to parse"
 49 |     exit(1)
 50 |   end
 51 |   
 52 |   context = RDF::RDFa::Context.find(uri)
 53 |   if dump
 54 |     puts context.inspect
 55 |   else
 56 |     context_short = uri.to_s.split("/").last.gsub(/[^\w]/, '_')
 57 |     preceeding = '        '
 58 |     output.puts  <<START
 59 | # This file is automatically generated by #{__FILE__}
 60 | # RDFa context for #{file}
 61 | 
 62 | class RDF::RDFa::Context
 63 |   def self.find_with_#{context_short}(uri)
 64 |     if uri.to_s == "#{file}"
 65 |       @_#{context_short}_prof ||= RDF::RDFa::Context.new(RDF::URI("#{file}"),
 66 | START
 67 | 
 68 |     output.puts %{#{preceeding}vocabulary: "#{context.vocabulary},"} if context.vocabulary
 69 |     
 70 |     [:prefixes, :terms].each do |t|
 71 |       hash = context.send(t)
 72 |       key_width = hash.keys.inject(0) {|width, k| k.inspect.length > width ? k.inspect.length : width}
 73 |       unless hash.empty?
 74 |         output.puts %(#{preceeding}#{t}: {)
 75 |           hash.keys.map(&:to_s).sort.each do |k|
 76 |             v = hash[k.to_sym]
 77 |             output.printf(%(#{preceeding}  %s:%*s%s,\n), k, -key_width + k.length, "", v.inspect)
 78 |           end
 79 |         output.puts %(#{preceeding}},)
 80 |       end
 81 |     end
 82 |     
 83 |     output.puts <<END
 84 |       )
 85 |     else
 86 |       find_without_#{context_short}(uri)
 87 |     end
 88 |   end
 89 | 
 90 |   class << self
 91 |     ##
 92 |     # Override find to return this context, if matched
 93 |     alias_method :find_without_#{context_short}, :find
 94 |     alias_method :find, :find_with_#{context_short}
 95 |   end
 96 | end
 97 | END
 98 | 
 99 |   end
100 | end
101 | 


--------------------------------------------------------------------------------
/etc/doap.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html xmlns="http://www.w3.org/1999/xhtml" prefix="
 3 |   dc:   http://purl.org/dc/terms/
 4 |   doap: http://usefulinc.com/ns/doap#
 5 |   foaf: http://xmlns.com/foaf/0.1/
 6 |   rdf:  http://www.w3.org/1999/02/22-rdf-syntax-ns#"
 7 |   vocab="http://usefulinc.com/ns/doap#">
 8 |   <head>
 9 |     <title lang="en" property="shortdesc">RDFa reader/writer for Ruby.</title>
10 |     <base href="https://rubygems.org/gems/rdf-rdfa" />
11 |     <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
12 |   </head>
13 |   <body about="" typeof="Project">
14 |     <p>Project description for <span property="name">RDF::RDFa</span>.</p>
15 |     <p lang="en" property="description">
16 |       RDF::RDFa is an RDFa reader/writer for Ruby using the RDF.rb library suite.
17 |     </p>
18 |     <dl>
19 |       <dt>Implemented Specifications</dt><dd>
20 |         <ul rel="doap:implements">
21 |           <li><a href="http://www.w3.org/TR/rdfa-syntax/">RDFa in XHTML (RDFa Core 1.0)</a></li>
22 |           <li><a href="http://www.w3.org/TR/rdfa-core/">RDFa Core 1.1</a></li>
23 |           <li><a href="http://www.w3.org/TR/xhtml-rdfa/">XHTML+RDFa 1.1</a></li>
24 |           <li><a href="http://www.w3.org/TR/rdfa-in-html/">HTML+RDFa 1.1</a></li>
25 |           <li><a href="http://www.w3.org/TR/rdfa-lite/">RDFa Lite 1.1</a></li>
26 |           <li><a href="http://www.w3.org/TR/role-attribute/">Role Attribute</a></li>
27 |         </ul>
28 |       </dd>
29 |       <dt>Creator</dt><dd>
30 |         <a href="http://greggkellogg.net/foaf#me"
31 |            property="dc:creator developer documenter maintainer foaf:maker">
32 |            Gregg Kellogg
33 |         </a>
34 |       </dd>
35 |       <dt>Contributors</dt><dd>
36 |         <ul rel="helper">
37 |           <li><a href="http://njh.me/">Nicholas Humfrey</a></li>
38 |         </ul>
39 |       </dd>
40 |       <dt>Created</dt><dd property="created" datatype="xsd:date">2011-08-29</dd>
41 |       <dt>Blog</dt><dd><a href="http://greggkellogg.net/" property="blog">http://greggkellogg.net/</a></dd>
42 |       <dt>Bug DB</dt><dd>
43 |         <a href="https://github.com/ruby-rdf/rdf-rdfa/issues" property="bug-database">
44 |           https://github.com/ruby-rdf/rdf-rdfa/issues
45 |         </a>
46 |       </dd>
47 |       <dt>Programming Language</dt><dd property="doap:programming-language">Ruby</dd>
48 |       <dt>Category</dt><dd rel="doap:category">
49 |         <a href="http://dbpedia.org/resource/Resource_Description_Framework">Resource Description Framework</a>
50 |         for
51 |         <a href="http://dbpedia.org/resource/Ruby_(programming_language)">Ruby</a>
52 |       </dd>
53 |       <dt>Download</dt><dd><a href="https://rubygems.org/gems/rdf-rdfa" property="download-page">
54 |         https://rubygems.org/gems/rdf-rdfa
55 |       </a></dd>
56 |       <dt>Home Page</dt><dd><a href="https://github.com/ruby-rdf/rdf-rdfa" property="homepage">
57 |         https://github.com/ruby-rdf/rdf-rdfa
58 |       </a></dd>
59 |       <dt>License</dt><dd>
60 |         <a href="https://unlicense.org/1.0/" property="license">Public Domain</a>
61 |       </dd>
62 |       <dt>Mailing List</dt><dd><a href="http://lists.w3.org/Archives/Public/public-rdf-ruby/" property="mailing-list">
63 |         http://lists.w3.org/Archives/Public/public-rdf-ruby/
64 |       </a></dd>
65 |     </dl>
66 |   </body>
67 | </html>
68 | 


--------------------------------------------------------------------------------
/spec/suite_spec.rb:
--------------------------------------------------------------------------------
 1 | require_relative 'spec_helper'
 2 | require 'rdf/spec/reader'
 3 | 
 4 | unless ENV['CI']  # Skip for continuous integration
 5 |   describe "RDF::RDFa::Reader" do
 6 |     # W3C Test suite from http://www.w3.org/2006/07/SWD/RDFa/testsuite/
 7 |     describe "w3c test cases" do
 8 |       require 'suite_helper'
 9 | 
10 |       Fixtures::TestCase::HOST_LANGUAGE_VERSION_SETS.each do |(host_language, version)|
11 |         describe "for #{host_language} #{version}" do
12 |           %w(required optional buggy).each do |classification|
13 |             describe "that are #{classification}" do
14 |               Fixtures::TestCase.for_specific(host_language, version, Fixtures::TestCase::Test.send(classification)) do |t|
15 |                 specify "test #{t.num}: #{t.description}#{",  (negative test)" if t.expectedResults.false?}" do
16 |                   skip "CDN messes up email addresses" if %w(0065 0176).include?(t.num)
17 |                   skip "XMLLiteral" if %w(0198 0212).include?(t.num)
18 |                   begin
19 |                     t.logger = RDF::Spec.logger
20 |                     t.logger.info t.inspect
21 |                     t.logger.info "source:\n#{RDF::Util::File.open_file(t.input(host_language, version)).read}"
22 |                     options = {
23 |                       base_uri: t.input(host_language, version),
24 |                       logger: t.logger,
25 |                       format: :rdfa
26 |                     }
27 |                     if t.queryParam
28 |                       opt, arg = t.queryParam.split('=').map(&:to_sym)
29 |                       options[opt] = arg
30 |                     end
31 | 
32 |                     validate = %w(0239 0279 0295 0284).none? {|n| t.input(host_language, version).to_s.include?(n)}
33 |                     graph = RDF::Repository.new
34 |                     RDF::Reader.open(t.input(host_language, version), **options.merge(validate: validate)) do |reader|
35 |                       expect(reader).to be_a RDF::RDFa::Reader
36 | 
37 |                       # Some allowances for REXML
38 |                       if reader.instance_variable_get(:@library) == :rexml && %w(0198 0212 0256).any? {|n| t.num == n}
39 |                         pending "REXML issues"
40 |                       end
41 | 
42 |                       # Make sure auto-detect works
43 |                       unless host_language =~ /svg/ || t.num == "0216" # due to http-equiv
44 |                         expect(reader.host_language).to produce(host_language.to_sym, t.debug)
45 |                         expect(reader.version).to produce(version.sub(/-.*$/, '').to_sym, t.debug)
46 |                       end
47 | 
48 |                       expect {graph << reader}.not_to raise_error, t.logger.to_s
49 |                     end
50 | 
51 |                     RDF::Util::File.open_file(t.results(host_language, version)) do |query|
52 |                       expect(graph).to pass_query(query, t)
53 |                     end
54 |                   rescue RSpec::Expectations::ExpectationNotMetError => e
55 |                     if classification != "required"
56 |                       pending("#{classification} test") {  raise }
57 |                     else
58 |                       raise
59 |                     end
60 |                   end
61 |                 end
62 |               end
63 |             end
64 |           end
65 |         end
66 |       end
67 |     end
68 |   end
69 | end
70 | 


--------------------------------------------------------------------------------
/lib/rdf/rdfa/context/xml.rb:
--------------------------------------------------------------------------------
 1 | # This file is automatically generated by ./script/intern_context
 2 | # RDFa context for http://www.w3.org/2011/rdfa-context/rdfa-1.1
 3 | 
 4 | class RDF::RDFa::Context
 5 |   def self.find_with_rdfa_1_1(uri)
 6 |     if uri.to_s == "http://www.w3.org/2011/rdfa-context/rdfa-1.1"
 7 |       @_rdfa_1_1_prof ||= RDF::RDFa::Context.new(RDF::URI("http://www.w3.org/2011/rdfa-context/rdfa-1.1"),
 8 |         prefixes: {
 9 |           as:      "https://www.w3.org/ns/activitystreams#",
10 |           cc:      "http://creativecommons.org/ns#",
11 |           csvw:    "http://www.w3.org/ns/csvw#",
12 |           ctag:    "http://commontag.org/ns#",
13 |           dc:      "http://purl.org/dc/terms/",
14 |           dc11:    "http://purl.org/dc/elements/1.1/",
15 |           dcat:    "http://www.w3.org/ns/dcat#",
16 |           dcterms: "http://purl.org/dc/terms/",
17 |           dqv:     "http://www.w3.org/ns/dqv#",
18 |           duv:     "https://www.w3.org/ns/duv#",
19 |           foaf:    "http://xmlns.com/foaf/0.1/",
20 |           gr:      "http://purl.org/goodrelations/v1#",
21 |           grddl:   "http://www.w3.org/2003/g/data-view#",
22 |           ical:    "http://www.w3.org/2002/12/cal/icaltzd#",
23 |           jsonld:  "http://www.w3.org/ns/json-ld#",
24 |           ldp:     "http://www.w3.org/ns/ldp#",
25 |           ma:      "http://www.w3.org/ns/ma-ont#",
26 |           oa:      "http://www.w3.org/ns/oa#",
27 |           odrl:    "http://www.w3.org/ns/odrl/2/",
28 |           og:      "http://ogp.me/ns#",
29 |           org:     "http://www.w3.org/ns/org#",
30 |           owl:     "http://www.w3.org/2002/07/owl#",
31 |           prov:    "http://www.w3.org/ns/prov#",
32 |           qb:      "http://purl.org/linked-data/cube#",
33 |           rdf:     "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
34 |           rdfa:    "http://www.w3.org/ns/rdfa#",
35 |           rdfs:    "http://www.w3.org/2000/01/rdf-schema#",
36 |           rev:     "http://purl.org/stuff/rev#",
37 |           rif:     "http://www.w3.org/2007/rif#",
38 |           rr:      "http://www.w3.org/ns/r2rml#",
39 |           schema:  "http://schema.org/",
40 |           sd:      "http://www.w3.org/ns/sparql-service-description#",
41 |           sioc:    "http://rdfs.org/sioc/ns#",
42 |           skos:    "http://www.w3.org/2004/02/skos/core#",
43 |           skosxl:  "http://www.w3.org/2008/05/skos-xl#",
44 |           sosa:    "http://www.w3.org/ns/sosa/",
45 |           ssn:     "http://www.w3.org/ns/ssn/",
46 |           time:    "http://www.w3.org/2006/time#",
47 |           v:       "http://rdf.data-vocabulary.org/#",
48 |           vcard:   "http://www.w3.org/2006/vcard/ns#",
49 |           void:    "http://rdfs.org/ns/void#",
50 |           wdr:     "http://www.w3.org/2007/05/powder#",
51 |           wdrs:    "http://www.w3.org/2007/05/powder-s#",
52 |           xhv:     "http://www.w3.org/1999/xhtml/vocab#",
53 |           xml:     "http://www.w3.org/XML/1998/namespace",
54 |           xsd:     "http://www.w3.org/2001/XMLSchema#",
55 |         },
56 |         terms: {
57 |           describedby: "http://www.w3.org/2007/05/powder-s#describedby",
58 |           license:     "http://www.w3.org/1999/xhtml/vocab#license",
59 |           role:        "http://www.w3.org/1999/xhtml/vocab#role",
60 |         },
61 |       )
62 |     else
63 |       find_without_rdfa_1_1(uri)
64 |     end
65 |   end
66 | 
67 |   class << self
68 |     ##
69 |     # Override find to return this context, if matched
70 |     alias_method :find_without_rdfa_1_1, :find
71 |     alias_method :find, :find_with_rdfa_1_1
72 |   end
73 | end
74 | 


--------------------------------------------------------------------------------
/spec/matchers.rb:
--------------------------------------------------------------------------------
  1 | require 'rspec/matchers'
  2 | 
  3 | RSpec::Matchers.define :have_xpath do |path, value, logger|
  4 |   match do |actual|
  5 |     root = RDF::RDFa::Reader.new(actual).root
  6 |     return false unless root
  7 |     namespaces = root.namespaces.inject({}) {|memo, (k,v)| memo[k.to_s.sub(/xmlns:?/, '')] = v; memo}.
  8 |       merge("xhtml" => "http://www.w3.org/1999/xhtml", "xml" => "http://www.w3.org/XML/1998/namespace")
  9 |     @result = root.at_xpath(path, namespaces) rescue false
 10 |     case value
 11 |     when false
 12 |       @result.nil?
 13 |     when true
 14 |       !@result.nil?
 15 |     when Array
 16 |       @result.to_s.split(" ").include?(*value)
 17 |     when Regexp
 18 |       @result.to_s =~ value
 19 |     else
 20 |       @result.to_s == value
 21 |     end
 22 |   end
 23 | 
 24 |   failure_message do |actual|
 25 |     msg = "expected that #{path.inspect}\nwould be: #{value.inspect}"
 26 |     msg += "\n     was: #{@result}"
 27 |     msg += "\nsource:" + actual
 28 |     msg +=  "\nDebug:#{logger}"
 29 |     msg
 30 |   end
 31 | 
 32 |   failure_message_when_negated do |actual|
 33 |     msg = "expected that #{path.inspect}\nwould not be #{value.inspect}"
 34 |     msg += "\nsource:" + actual
 35 |     msg +=  "\nDebug:#{logger}"
 36 |     msg
 37 |   end
 38 | end
 39 | 
 40 | Info = Struct.new(:id, :logger, :compare, :inputDocument, :outputDocument, :expectedResults, :format, :title)
 41 | 
 42 | RSpec::Matchers.define :pass_query do |expected, info|
 43 |   match do |actual|
 44 |     if info.respond_to?(:id)
 45 |       @info = info
 46 |     elsif info.is_a?(Logger)
 47 |       Info.new("", info)
 48 |     elsif info.is_a?(Hash)
 49 |       @info =  Info.new(info[:id], info[:logger], info[:compare])
 50 |       @info[:expectedResults] = info[:expectedResults] || RDF::Literal::Boolean.new(true)
 51 |     else
 52 |       @info = Info.new()
 53 |       @info[:expectedResults] = RDF::Literal::Boolean.new(true)
 54 |     end
 55 | 
 56 |     @expected = expected.respond_to?(:read) ? expected.read : expected
 57 |     @expected = @expected.force_encoding("utf-8") if @expected.respond_to?(:force_encoding)
 58 | 
 59 |     require 'sparql'
 60 |     query = SPARQL.parse(@expected)
 61 |     actual = actual.force_encoding("utf-8") if actual.respond_to?(:force_encoding)
 62 |     @results = query.execute(actual)
 63 | 
 64 |     @results == @info.expectedResults
 65 |   end
 66 | 
 67 |   failure_message do |actual|
 68 |     trace = case @info.logger
 69 |     when Logger then @info.logger.to_s
 70 |     when Array then @info.logger.join("\n")
 71 |     end
 72 |     "#{@info.inspect + "\n"}" +
 73 |     if @results.nil?
 74 |       "Query failed to return results"
 75 |     elsif !@results.is_a?(RDF::Literal::Boolean)
 76 |       "Query returned non-boolean results"
 77 |     elsif @info.expectedResults != @results
 78 |       "Query returned false (expected #{@info.expectedResults})"
 79 |     else
 80 |       "Query returned true (expected #{@info.expectedResults})"
 81 |     end +
 82 |     "\n#{@expected}" +
 83 |     "\nResults:\n#{@actual.dump(:ttl, standard_prefixes: true)}" +
 84 |     "\nDebug:\n#{trace}"
 85 |   end
 86 | 
 87 |   failure_message_when_negated do |actual|
 88 |     trace = case @info.logger
 89 |     when Logger then @info.logger.to_s
 90 |     when Array then @info.logger.join("\n")
 91 |     end
 92 |     "#{@info.inspect + "\n"}" +
 93 |     if @results.nil?
 94 |       "Query failed to return results"
 95 |     elsif !@results.is_a?(RDF::Literal::Boolean)
 96 |       "Query returned non-boolean results"
 97 |     elsif @info.expectedResults != @results
 98 |       "Query returned false (expected #{@info.expectedResults})"
 99 |     else
100 |       "Query returned true (expected #{@info.expectedResults})"
101 |     end +
102 |     "\n#{@expected}" +
103 |     "\nResults:\n#{@actual.dump(:ttl, standard_prefixes: true)}" +
104 |     "\nDebug:\n#{trace}"
105 |   end
106 | end
107 | 


--------------------------------------------------------------------------------
/example-files/payswarm.n3:
--------------------------------------------------------------------------------
 1 | @base <http://recipes.payswarm.com/?p=10185> .
 2 | @prefix bibo: <http://purl.org/ontology/bibo/> .
 3 | @prefix cal: <http://www.w3.org/2002/12/cal/ical#> .
 4 | @prefix cc: <http://creativecommons.org/ns#> .
 5 | @prefix com: <http://purl.org/commerce#> .
 6 | @prefix dbp: <http://dbpedia.org/property/> .
 7 | @prefix dbp-owl: <http://dbpedia.org/ontology/> .
 8 | @prefix dbr: <http://dbpedia.org/resource/> .
 9 | @prefix dc: <http://purl.org/dc/terms/> .
10 | @prefix dcterms: <http://purl.org/dc/terms/> .
11 | @prefix doap: <http://usefulinc.com/ns/doap#> .
12 | @prefix foaf: <http://xmlns.com/foaf/0.1/> .
13 | @prefix geo: <http://www.w3.org/2003/01/geo/wgs84_pos#> .
14 | @prefix gr: <http://purl.org/goodrelations/v1#> .
15 | @prefix grddl: <http://www.w3.org/2003/g/data-view#> .
16 | @prefix og: <http://ogp.me/ns#> .
17 | @prefix owl: <http://www.w3.org/2002/07/owl#> .
18 | @prefix ps: <http://purl.org/payswarm#> .
19 | @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
20 | @prefix rdfa: <http://www.w3.org/ns/rdfa#> .
21 | @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
22 | @prefix rif: <http://www.w3.org/2007/rif#> .
23 | @prefix rss: <http://purl.org/rss/1.0/> .
24 | @prefix sd: <http://www.w3.org/ns/sparql-service-description#> .
25 | @prefix sig: <http://purl.org/signature#> .
26 | @prefix sioc: <http://rdfs.org/sioc/ns#> .
27 | @prefix skos: <http://www.w3.org/2004/02/skos/core#> .
28 | @prefix skosxl: <http://www.w3.org/2008/05/skos-xl#> .
29 | @prefix v: <http://rdf.data-vocabulary.org/#> .
30 | @prefix vcard: <http://www.w3.org/2006/vcard/ns#> .
31 | @prefix void: <http://rdfs.org/ns/void#> .
32 | @prefix wdr: <http://www.w3.org/2007/05/powder#> .
33 | @prefix wdrs: <http://www.w3.org/2007/05/powder-s#> .
34 | @prefix xhv: <http://www.w3.org/1999/xhtml/vocab#> .
35 | @prefix xml: <http://www.w3.org/XML/1998/namespace> .
36 | @prefix xmlns: <http://www.w3.org/2000/xmlns/> .
37 | @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
38 | 
39 | <#listing> com:payee <#listing-payee>;
40 |    com:payeeRule [ com:destinationOwnerType ps:Authority;
41 |      com:maximumRate "11.45"@en-US;
42 |      com:rateContext com:Inclusive,
43 |      com:Tax,
44 |      com:TaxExempt;
45 |      com:rateType com:Percentage;
46 |      a com:PayeeRule];
47 |    ps:asset <#asset>;
48 |    ps:assetHash "025b9b9f1eea31a9431f0c181a22df8a8257fc49"@en-US;
49 |    ps:license <http://purl.org/payswarm/licenses/blogging>;
50 |    ps:licenseHash "b94ba441c42432e82b6e3a076f4c614f83cac6ef"@en-US;
51 |    ps:validFrom "2011-04-18T00:00:00+0000"^^xsd:dateTime;
52 |    ps:validUntil "2011-04-19T00:00:00+0000"^^xsd:dateTime;
53 |    sig:signature [ dc:created "2011-04-18T00:00:00Z"^^xsd:dateTime;
54 |      dc:creator <https://payswarm.com/i/devuser/keys/4>;
55 |      sig:signatureValue "MqF1r37JSev+2uUKdr1ZOWVfNbTx8YdBZUMW4hlgeQyIiYxfbHF+eYhU+NLFrclTjj3i7qnwREIIBP0O0BFk72JIBl3JcCDKpfbA7pqiFuaGvxr9+Ba7o0pYojo0A6Mc/+0UD5rjdJc+qAH9hnMOzKpjyeMxUcR1Z6w0XXKXc8A="@en-US;
56 |      a sig:JsonldSignature];
57 |    a gr:Offering,
58 |    ps:Listing .
59 | <> xhv:alternate <https://recipes.payswarm.com/?feed=comments-rss2>,
60 |    <https://recipes.payswarm.com/?feed=rss2>,
61 |    <https://recipes.payswarm.com/?feed=rss2&p=10185>;
62 |    xhv:bookmark <https://recipes.payswarm.com/?p=10185>;
63 |    xhv:index <https://recipes.payswarm.com>;
64 |    xhv:next <https://recipes.payswarm.com/?p=10186>;
65 |    xhv:prev <https://recipes.payswarm.com/?p=10184>;
66 |    xhv:start <https://recipes.payswarm.com/?p=1>;
67 |    xhv:stylesheet <https://recipes.payswarm.com/wp-content/plugins/payswarm/payswarm.css?ver=3.1>,
68 |    <https://recipes.payswarm.com/wp-content/themes/twentyten/style.css> .
69 | <#asset> dc:creator [ foaf:name "chef"@en-US];
70 |    dc:title "Soft Breadsticks"@en-US;
71 |    ps:assetProvider <https://dev.payswarm.com:19100/i/devuser>;
72 |    ps:authority <https://payswarm.dev:19100/client-config>;
73 |    ps:contentUrl <>;
74 |    sig:signature [ dc:created "2011-04-18T00:00:00Z"^^xsd:dateTime;
75 |      dc:creator <https://payswarm.com/i/devuser/keys/4>;
76 |      sig:signatureValue "GYQHOxTJeyfky4NkxTm/IEcVGKYq7omDXPwdX+CYlJD9ur6RX35jM/RS3SeB7teGlJs1KtAx+l4ZUsAZa4sINYkr9fKh0k0K7TCbXp2X5sJ4ZCE3AvxZfc4IQEMuiiq+C8LHJv6g6tVmdl25UIbfroEBd/Hv+ID995VgapsSmQo="@en-US;
77 |      a sig:JsonldSignature];
78 |    a ps:Asset,
79 |    ps:WebPage .
80 | <#listing-payee> com:currency "USD"@en-US;
81 |    com:destination <https://dev.payswarm.com:19100/i/devuser/accounts/primary>;
82 |    com:payeePosition "0"^^xsd:integer;
83 |    com:rate "0.04597"@en-US;
84 |    com:rateType com:FlatAmount;
85 |    a com:Payee;
86 |    rdfs:comment "Payment for Soft Breadsticks by chef."@en-US .
87 | 


--------------------------------------------------------------------------------
/script/parse:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env ruby
  2 | require 'rubygems'
  3 | $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
  4 | require 'logger'
  5 | require 'rdf/rdfa'
  6 | %w(linkeddata rdf/turtle json/ld rdf/rdfxml).each do |f|
  7 |   begin
  8 |     require f
  9 |   rescue LoadError => e
 10 |   end
 11 | end
 12 | 
 13 | require 'getoptlong'
 14 | require 'open-uri'
 15 | 
 16 | def run(input, **options)
 17 |   reader_class = RDF::Reader.for(options[:input_format].to_sym)
 18 |   raise "Reader not found for #{$input_format}" unless reader_class
 19 |   
 20 |   # If :rdfagraph is set to any of :output, :processor or both 
 21 |   options[:rdfagraph] ||= [:output]
 22 |   processor_graph = RDF::Graph.new if options[:rdfagraph].include?(:processor)
 23 | 
 24 |   start = Time.new
 25 |   num = 0
 26 | 
 27 |   if options[:output_format] == :ntriples || options[:quiet]
 28 |     reader_class.new(input, **options).each do |statement|
 29 |       num += 1
 30 |       if options[:quiet]
 31 |         #print "."
 32 |       elsif options[:rdfagraph]
 33 |         options[:output].puts statement.to_ntriples
 34 |       end
 35 |     end
 36 |   elsif options[:output_format] == :inspect
 37 |     reader_class.new(input, **options).each do |statement|
 38 |       num += 1
 39 |       options[:output].puts statement.inspect
 40 |     end
 41 |   else
 42 |     r = reader_class.new(input, **options)
 43 |     g = RDF::Repository.new << r
 44 |     num = g.count
 45 |     STDERR.puts "graph: #{g.dump(:ttl)}" if options[:verbose]
 46 |     options[:output].puts g.dump(options[:output_format], options.merge(prefixes: r.prefixes, standard_prefixes: true))
 47 |   end
 48 |   STDERR.puts
 49 |   secs = Time.new - start
 50 |   STDERR.puts "Parsed #{num} statements in #{secs} seconds @ #{num/secs} statements/second."
 51 | rescue
 52 |   fname = input.respond_to?(:path) ? input.path : "-stdin-"
 53 |   STDERR.puts("Error in #{fname}")
 54 |   raise
 55 | end
 56 | 
 57 | logger = Logger.new(STDERR)
 58 | logger.level = Logger::WARN
 59 | logger.formatter = lambda {|severity, datetime, progname, msg| "#{severity}: #{msg}\n"}
 60 | 
 61 | options = {
 62 |   host_language: nil,
 63 |   input_format:  :rdfa,
 64 |   output:        STDOUT,
 65 |   output_format: :ntriples,
 66 |   strict:        true,
 67 |   validate:      false,
 68 |   verbose:       false,
 69 |   version:       nil,
 70 |   logger: logger
 71 | }
 72 | input = nil
 73 | 
 74 | opts = GetoptLong.new(
 75 |   ["--dbg", GetoptLong::NO_ARGUMENT],
 76 |   ["--execute", "-e", GetoptLong::REQUIRED_ARGUMENT],
 77 |   ["--expand", GetoptLong::NO_ARGUMENT],
 78 |   ["--format", GetoptLong::REQUIRED_ARGUMENT],
 79 |   ["--input-format", GetoptLong::REQUIRED_ARGUMENT],
 80 |   ["--output", "-o", GetoptLong::REQUIRED_ARGUMENT],
 81 |   ["--quiet", GetoptLong::NO_ARGUMENT],
 82 |   ["--template", GetoptLong::REQUIRED_ARGUMENT],
 83 |   ["--rdfagraph", GetoptLong::REQUIRED_ARGUMENT],
 84 |   ["--uri", GetoptLong::REQUIRED_ARGUMENT],
 85 |   ["--validate", GetoptLong::NO_ARGUMENT],
 86 |   ["--host-language", "-h", GetoptLong::OPTIONAL_ARGUMENT],
 87 |   ["--verbose", GetoptLong::NO_ARGUMENT],
 88 |   ["--version", "-v", GetoptLong::OPTIONAL_ARGUMENT]
 89 | )
 90 | opts.each do |opt, arg|
 91 |   case opt
 92 |   when '--dbg'            then logger.level = Logger::DEBUG
 93 |   when '--execute'        then input = arg
 94 |   when '--expand'         then options[:vocab_expansion] = true
 95 |   when '--format'         then options[:output_format] = arg.to_sym
 96 |   when '--host-language'  then options[:host_language] = arg
 97 |   when '--input-format'   then options[:input_format] = arg.to_sym
 98 |   when '--output'         then options[:output] = File.open(arg, "w")
 99 |   when '--quiet'
100 |     options[:quiet] = true
101 |     logger.level = Logger::FATAL
102 |   when '--rdfagraph'      then options[:rdfagraph] = arg.split(',').map(&:to_sym)
103 |   when '--template'       then options[:haml] = arg.to_sym
104 |   when '--uri'            then options[:base_uri] = arg
105 |   when '--validate'       then options[:validate] = true
106 |   when '--verbose'        then options[:verbose] = true
107 |   when '--version'        then options[:version] = arg
108 |   end
109 | end
110 | 
111 | if ARGV.empty?
112 |   s = input ? input : $stdin.read
113 |   options[:base_uri] ||= "http://example.com/"
114 |   run(StringIO.new(s), **options)
115 | else
116 |   ARGV.each do |test_file|
117 |     tf_opt = options.dup
118 |     uri = RDF::URI(test_file)
119 |     uri = RDF::URI("file://#{File.expand_path(test_file)}") if uri.relative?
120 |     tf_opt[:base_uri] ||= uri
121 |     run(Kernel.open(test_file), tf_opt)
122 |   end
123 | end
124 | 


--------------------------------------------------------------------------------
/spec/suite_helper.rb:
--------------------------------------------------------------------------------
  1 | # Spira class for manipulating test-manifest style test suites.
  2 | # Used for SWAP tests
  3 | require 'rdf/turtle'
  4 | require 'json/ld'
  5 | 
  6 | # For now, override RDF::Utils::File.open_file to look for the file locally before attempting to retrieve it
  7 | module RDF::Util
  8 |   module File
  9 |     REMOTE_PATH = "http://rdfa.info/test-suite/"
 10 |     LOCAL_PATH = ::File.expand_path("../test-suite", __FILE__) + '/'
 11 | 
 12 |     class << self
 13 |       alias_method :original_open_file, :open_file
 14 |     end
 15 | 
 16 |     ##
 17 |     # Override to use Patron for http and https, Kernel.open otherwise.
 18 |     #
 19 |     # @param [String] filename_or_url to open
 20 |     # @param  [Hash{Symbol => Object}] options
 21 |     # @option options [Array, String] :headers
 22 |     #   HTTP Request headers.
 23 |     # @return [IO] File stream
 24 |     # @yield [IO] File stream
 25 |     def self.open_file(filename_or_url, **options, &block)
 26 |       case
 27 |       when filename_or_url.to_s =~ /^file:/
 28 |         path = filename_or_url[5..-1]
 29 |         Kernel.open(path.to_s, options, &block)
 30 |       when (filename_or_url.to_s =~ %r{^#{REMOTE_PATH}} && Dir.exist?(LOCAL_PATH))
 31 |         #puts "attempt to open #{filename_or_url} locally"
 32 |         localpath = filename_or_url.to_s.sub(REMOTE_PATH, LOCAL_PATH)
 33 |         response = begin
 34 |           ::File.open(localpath)
 35 |         rescue Errno::ENOENT => e
 36 |           raise IOError, e.message
 37 |         end
 38 |         document_options = {
 39 |           base_uri:     RDF::URI(filename_or_url),
 40 |           charset:      Encoding::UTF_8,
 41 |           code:         200,
 42 |           headers:      {}
 43 |         }
 44 |         #puts "use #{filename_or_url} locally"
 45 |         document_options[:headers][:content_type] = case filename_or_url.to_s
 46 |         when /\.html$/    then 'text/html'
 47 |         when /\.xhtml$/   then 'application/xhtml+xml'
 48 |         when /\.xml$/     then 'application/xml'
 49 |         when /\.svg$/     then 'image/svg+xml'
 50 |         when /\.ttl$/     then 'text/turtle'
 51 |         when /\.ttl$/     then 'text/turtle'
 52 |         when /\.jsonld$/  then 'application/ld+json'
 53 |         else                   'unknown'
 54 |         end
 55 | 
 56 |         document_options[:headers][:content_type] = response.content_type if response.respond_to?(:content_type)
 57 |         # For overriding content type from test data
 58 |         document_options[:headers][:content_type] = options[:contentType] if options[:contentType]
 59 | 
 60 |         remote_document = RDF::Util::File::RemoteDocument.new(response.read, **document_options)
 61 |         if block_given?
 62 |           yield remote_document
 63 |         else
 64 |           remote_document
 65 |         end
 66 |       else
 67 |         original_open_file(filename_or_url, **options, &block)
 68 |       end
 69 |     end
 70 |   end
 71 | end
 72 | 
 73 | module Fixtures
 74 |   RDFA_INFO = RDF::URI("http://rdfa.info/test-suite/")
 75 | 
 76 |   class TestCase < JSON::LD::Resource
 77 |     HOST_LANGUAGE_VERSION_SETS = [
 78 |       ["xhtml1",      "rdfa1.1"],
 79 |       ["xml1",        "rdfa1.1"],
 80 |       ["html5",       "rdfa1.1"],
 81 |       ["xhtml5",      "rdfa1.1"],
 82 |       ["xhtml5",      "rdfa1.1-role"],
 83 |       ["xhtml5",      "rdfa1.1-proc"],
 84 |       ["xhtml5",      "rdfa1.1-vocab"],
 85 |       ["xhtml1",      "rdfa1.0"],
 86 |       ["svgtiny1.2",  "rdfa1.0"],
 87 |       ["svg",         "rdfa1.1"],
 88 |     ]
 89 | 
 90 |     class Test < RDF::Vocabulary("http://www.w3.org/2006/03/test-description#"); end
 91 | 
 92 |     attr_accessor :logger
 93 | 
 94 |     # @param [Hash] json framed JSON-LD`
 95 |     # @return [Array<TestCase>]
 96 |     def self.from_jsonld(json)
 97 |       @@test_cases ||= json['@graph'].map {|e| TestCase.new(e)}
 98 |     end
 99 | 
100 |     def self.for_specific(host_language, version, classification = nil)
101 |       @@test_cases.each do |tc|
102 |         yield(tc) if tc.hostLanguages.include?(host_language) &&
103 |                      tc.versions.include?(version) &&
104 |                      (classification.nil? || tc.classification == classification)
105 |       end
106 |     end
107 | 
108 |     def expectedResults
109 |       RDF::Literal::Boolean.new(property('expectedResults'))
110 |     end
111 | 
112 |     def input(host_language, version)
113 |       base = self.property('input').to_s.
114 |         sub('test-cases/', "test-cases/#{version}/#{host_language}/")
115 |       case host_language
116 |       when /^xml/   then RDF::URI(base.sub(".html", ".xml"))
117 |       when /^xhtml/ then RDF::URI(base.sub(".html", ".xhtml"))
118 |       when /^svg/   then RDF::URI(base.sub(".html", ".svg"))
119 |       else               RDF::URI(base)
120 |       end
121 |     end
122 | 
123 |     def results(host_language, version)
124 |       RDF::URI(self.property('results').to_s.
125 |         sub('test-cases/', "test-cases/#{version}/#{host_language}/"))
126 |     end
127 |   end
128 | 
129 |   manifest = RDFA_INFO.join("manifest.jsonld")
130 |   TestCase.from_jsonld(RDF::Util::File.open_file(manifest) {|f| JSON.load(f.read)})
131 | end
132 | 


--------------------------------------------------------------------------------
/script/tc:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env ruby
  2 | require 'rubygems'
  3 | $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
  4 | require "bundler/setup"
  5 | require 'rdf/rdfa'
  6 | require 'sparql/grammar'
  7 | require File.expand_path(File.join(File.dirname(__FILE__), "..", 'spec', 'spec_helper'))
  8 | require File.expand_path(File.join(File.dirname(__FILE__), "..", 'spec', 'suite_helper'))
  9 | require 'getoptlong'
 10 | 
 11 | def run_tc(tc, **options)
 12 |   input_uri = tc.input(options[:host_language], options[:version])
 13 |   results_uri = tc.results(options[:host_language], options[:version])
 14 |   res = nil
 15 | 
 16 |   STDOUT.write "run #{tc.num}"
 17 | 
 18 |   if options[:verbose]
 19 |     puts("\nTestCase: #{tc.inspect}") 
 20 |     puts("\nInput:\n" + RDF::Util::File.open_file(input_uri) {|f| f.read}) 
 21 |     puts("\nQuery:\n" + RDF::Util::File.open_file(results_uri) {|f| f.read})
 22 |   end
 23 | 
 24 |   pg = RDF::Graph.new if options[:processor_graph]
 25 | 
 26 |   begin
 27 |     puts "open #{input_uri}" if options[:verbose]
 28 |     options = {
 29 |       base_uri: input_uri,
 30 |       processor_graph: pg,
 31 |       format: :rdfa,
 32 |     }.merge(options)
 33 | 
 34 |     if tc.queryParam
 35 |       opt, arg = tc.queryParam.split('=').map(&:to_sym)
 36 |       options[opt] = arg
 37 |     end
 38 | 
 39 |     reader = RDF::RDFa::Reader.open(input_uri, **options)
 40 | 
 41 |     graph = RDF::Repository.new << reader
 42 |   rescue Exception => e
 43 |     options[:result_count]["exception"] ||= 0
 44 |     options[:result_count]["exception"] += 1
 45 |     puts "#{"exception:" unless options[:quiet]}: #{e}"
 46 |     if options[:quiet]
 47 |       return
 48 |     else
 49 |       raise
 50 |     end
 51 |   end
 52 |   
 53 |   puts("\nResult:\n" + graph.dump(options[:format], validate: false)) unless options[:quiet]
 54 |   
 55 |   begin
 56 |     result = SPARQL::Grammar.open(results_uri).execute(graph)
 57 |   rescue Exception => e
 58 |     options[:result_count]["exception"] ||= 0
 59 |     options[:result_count]["exception"] += 1
 60 |     puts "#{"exception:" unless options[:quiet]}: #{e}"
 61 |     return
 62 |   end
 63 |   res = (result == (tc.expectedResults || true)) ? 'pass' : 'fail'
 64 |   puts "#{"test result:" unless options[:quiet]} #{res}"
 65 |   options[:result_count][res] ||= 0
 66 |   options[:result_count][res] += 1
 67 | 
 68 |   if pg && !options[:quiet]
 69 |     puts "\nProcessor Graph:\n"
 70 |     puts pg.inspect
 71 |     RDF::Writer.for(options[:format]).new do |writer|
 72 |       writer << pg
 73 |     end
 74 |   end
 75 | end
 76 | 
 77 | logger = Logger.new(STDERR)
 78 | logger.level = Logger::WARN
 79 | logger.formatter = lambda {|severity, datetime, progname, msg| "#{severity}: #{msg}\n"}
 80 | 
 81 | options = {
 82 |   verbose:         false,
 83 |   quite:           false,
 84 |   validate:        false,
 85 |   format:          :ntriples,
 86 |   library:         nil,
 87 |   processor_graph: nil,
 88 |   host_language:   "xhtml1",
 89 |   version:         "rdfa1.1",
 90 |   logger:          logger
 91 | }
 92 | 
 93 | opts = GetoptLong.new(
 94 |   ["--help", "-?", GetoptLong::NO_ARGUMENT],
 95 |   ["--debug", GetoptLong::NO_ARGUMENT],
 96 |   ["--format", GetoptLong::REQUIRED_ARGUMENT],
 97 |   ["--host-language", "-h", GetoptLong::REQUIRED_ARGUMENT],
 98 |   ["--library", GetoptLong::REQUIRED_ARGUMENT],
 99 |   ["--processor-graph", GetoptLong::NO_ARGUMENT],
100 |   ["--quiet", GetoptLong::NO_ARGUMENT],
101 |   ["--validate", GetoptLong::NO_ARGUMENT],
102 |   ["--verbose", GetoptLong::NO_ARGUMENT],
103 |   ["--version", "-v", GetoptLong::OPTIONAL_ARGUMENT]
104 | )
105 | 
106 | def help(options)
107 |   puts "Usage: #{$0} [options] [test-number ...]"
108 |   puts "Options:"
109 |   puts "      --dump:               Dump raw output, otherwise serialize to Ruby"
110 |   puts "      --debug:              Display detailed debug output"
111 |   puts "      --expand              Expand graph with vocab_expansion option"
112 |   puts "      --format:             Format for output, defaults to #{options[:format].inspect}"
113 |   puts "      --host-language:      Run for specified host language, defaults to #{options[:host_language]}"
114 |   puts "      --library:            XML parsing library, defaults to :nokogiri if available, otherwise :rexml"
115 |   puts "      --rdfagraph:          output, processor or output,processor"
116 |   puts "      --quiet:              Minimal output"
117 |   puts "      --validate:           Validate input"
118 |   puts "      --verbose:            Verbose processing"
119 |   puts "      --version:            Version of processor to use (rdfa1.0, rdfa1.1). Defaults to #{options[:version]}"
120 |   puts "      --help,-?:            This message"
121 |   exit(0)
122 | end
123 | 
124 | opts.each do |opt, arg|
125 |   case opt
126 |   when '--help'             then help(options)
127 |   when '--debug'            then logger.level = Logger::DEBUG
128 |   when '--format'           then options[:format] = arg.to_sym
129 |   when '--host-language'    then options[:host_language] = arg
130 |   when '--library'          then options[:library] = arg.to_sym
131 |   when '--quiet'
132 |     options[:quiet] = true
133 |     logger.level = Logger::FATAL
134 |   when '--validate'         then options[:validate] = true
135 |   when '--verbose'          then options[:verbose] = true
136 |   when '--version'          then options[:version] = arg
137 |   end
138 | end
139 | 
140 | result_count = {}
141 | 
142 | Fixtures::TestCase.for_specific(options[:host_language], options[:version]) do |tc|
143 |   next unless ARGV.empty? || ARGV.any? {|n| tc.num.match(/#{n}/)}
144 |   next if tc.classification.to_s =~ /deprecated/
145 |   run_tc(tc, **options.merge(result_count: result_count))
146 | end
147 | 
148 | result_count.each do |result, count|
149 |   puts "#{result}: #{count}"
150 | end
151 | 


--------------------------------------------------------------------------------
/example-files/erdf_profile.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  2 |     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  3 | <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  4 | <head profile="http://www.w3.org/2003/g/data-view">
  5 |     <meta content="HTML Tidy for Windows (vers 1st February 2003), see www.w3.org" name="generator" />
  6 |     <meta http-equiv="Content-Type" content="text/html; charset=us-ascii" />
  7 |     <title>
  8 |      Embedded RDF HTML Profile
  9 |     </title>
 10 |     <style type="text/css">
 11 |     /*<![CDATA[*/
 12 |       @import url(/styles/undohtml.css);
 13 |       @import url(/styles/screen-default.css);
 14 | 
 15 |     /*]]>*/
 16 |     </style>
 17 |      <link rel="transformation"
 18 |        href="http://www.w3.org/2003/g/glean-profile" />
 19 | 
 20 |   </head>
 21 |   <body>
 22 |     <div id="container" class="specification">
 23 |       <div id="header">
 24 |         <div id="logo">
 25 |           <a href="http://www.talis.com/home/index.shtml"><img src="/images/logo.gif" alt="Talis Home Page" width="144" height="49" border="0" /></a>
 26 |         </div>
 27 |         <form name="topsearch" method="get" action="http://www.talis.com/cgi-bin/search.cgi">
 28 |           <ul id="quicklinks">
 29 |             <li>
 30 |               <a href="http://www.talis.com/home/index.shtml"><img src="/images/home.gif" alt="Home" width="16" height="16" border="0" /></a>
 31 |               <a href="http://www.talis.com/home/index.shtml">Home</a>
 32 |             </li>
 33 |             <li>
 34 |               <a href="http://www.talis.com/services/support.shtml"><img src="/images/login.gif" alt="Access the support area" width="16" height="16"
 35 |               border="0" /></a> <a href="http://www.talis.com/services/support.shtml">Support</a>
 36 |             </li>
 37 |             <li>
 38 |               <a href="http://blogs.talis.com/panlibus" target="_blank"><img src="/images/BLOG.png" alt="blogs" width="16" height="16" border="0" /></a>
 39 |               <a href="http://www.talis.com/community/Talisblogs.shtml" target="_blank">Blogs</a>
 40 |             </li>
 41 |             <li>
 42 |               <a href="http://www.talis.com/community/talis_forums.shtml" target="_blank"><img src="/images/FORUMS.png" alt="Forums" width="16" height="16"
 43 |               border="0" /></a> <a href="http://www.talis.com/community/talis_forums.shtml" target="_self">Forums</a>
 44 |             </li>
 45 |             <li>
 46 |               <a href="http://www.talis.com/community/rss_help.shtml"><img src="/images/rss_feed.gif" alt="RSS" width="32" height="16" border="0" /></a>
 47 |             </li>
 48 |             <li>
 49 |               <a href="http://www.talis.com/cgi-bin/search.cgi" class="menu03Txt"><img src="/images/search.gif" alt="Search the Knowledgebase" width="16"
 50 |               height="16" border="0" class="c1" /></a>&#160; <input type="text" class="search" name="q" value="Search..." size="12" /> <input type="submit"
 51 |               class="search" value="Go" /> <input type="hidden" name="t" value="documentation" /> <input type="hidden" name="t" value="all" />
 52 |               <input type="hidden" name="t" value="forum" /> <input type="hidden" name="t" value="solutions" /> <input type="hidden" name="t" value="defect" />
 53 |               <input type="hidden" name="t" value="blog" />
 54 |             </li>
 55 |           </ul>
 56 |         </form>
 57 |         <ul id="menubar">
 58 |           <li>
 59 |             <a href="http://www.talis.com/about_talis/corporate.shtml">About</a>
 60 |           </li>
 61 |           <li>
 62 |             <a href="http://www.talis.com/news/press/press_releases.shtml">News &amp; Events</a>
 63 |           </li>
 64 |           <li>
 65 |             <a href="http://www.talis.com/solutions/academic.shtml">Solutions</a>
 66 |           </li>
 67 |           <li>
 68 |             <a href="http://www.talis.com/products/product_select.shtml">Products</a>
 69 |           </li>
 70 |           <li>
 71 |             <a href="http://www.talis.com/services/service_select.shtml">Services</a>
 72 |           </li>
 73 |           <li>
 74 |             <a href="http://www.talis.com/partners/partners.shtml">Partners</a>
 75 |           </li>
 76 |           <li>
 77 |             <a href="http://www.talis.com/tdn/index.shtml">Developers</a>
 78 |           </li>
 79 |           <li>
 80 |             <a href="http://www.talis.com/community/community.shtml">Community</a>
 81 |           </li>
 82 |           <li>
 83 |             <a href="http://research.talis.com/" class="selected">Research</a>
 84 |           </li>
 85 |         </ul>
 86 |       </div>
 87 |       <div id="breadcrumb">
 88 |          <a href="/">Home</a> &#8594; <a href="/2005/erdf">Embedded RDF</a>
 89 |       </div>
 90 |       <div id="content">
 91 |         <h1>
 92 |           Embedded RDF HTML Profile
 93 |         </h1>
 94 | 
 95 |         <p>A GRDDL-capable client tool, when visiting a page which contains the profile reference <code>http://purl.org/NET/erdf/profile</code>
 96 |         will first visit this profile document and apply the transformation declared here. The results of that transformation will
 97 | contain a statement identifying the transformation that should be applied to
 98 | convert the originating document into RDF/XML. The GRDDL client has everything it
 99 | needs to get RDF/XML from the original XHTML document, while the author of
100 | the originating document need not concern themselves with the details of the
101 | profile, merely including the reference to its URI is enough. </p>
102 |         <p>This following link provides the statement : <a
103 |         rel="profileTransformation"
104 |         href="http://purl.org/NET/erdf/extract-rdf.xsl">extract-rdf.xsl</a>, <a
105 |         rel="profile" href="http://purl.org/NET/erdf/profile">profile</a></p>
106 |       </div>
107 |       <div id="footer">
108 |         <a href="https://mail.talis.com/exchange">Webmail</a> <a href="http://www.talis.com/about_talis/contact_us.shtml"></a>|
109 |         <a href="http://www.talis.com/legal/site_map.shtml">Site Map</a> <a href="http://www.talis.com/about_talis/contact_us.shtml"></a>|
110 |         <a href="http://www.talis.com/about_talis/contact_us.shtml">Contact Us</a> | <a href="http://www.talis.com/legal/copyright.shtml">&#169;2005 Talis
111 |         Information Ltd</a> | <a href="http://www.talis.com/legal/legal.shtml">Legal Notice</a> |
112 |         <a href="http://www.talis.com/legal/privacy.shtml">Privacy</a> | <a href="mailto:webmaster@talis.com">Contact Webmaster</a>
113 |       </div>
114 |     </div>
115 |   </body>
116 | </html>
117 | 


--------------------------------------------------------------------------------
/lib/rdf/rdfa/vocab.rb:
--------------------------------------------------------------------------------
  1 | # -*- encoding: utf-8 -*-
  2 | # frozen_string_literal: true
  3 | # This file generated automatically using rdf vocabulary format from http://www.w3.org/ns/rdfa#
  4 | require 'rdf'
  5 | module RDF
  6 |   # @!parse
  7 |   #   # Vocabulary for <http://www.w3.org/ns/rdfa#>
  8 |   #   #
  9 |   #   # RDFa Vocabulary for Term and Prefix Assignment, and for Processor Graph Reporting
 10 |   #   #
 11 |   #   # This document describes the RDFa Vocabulary for Term and Prefix Assignment. The Vocabulary is used to modify RDFa 1.1 processing behavior.
 12 |   #   # @version $Date: 2013-03-11 07:54:23 $
 13 |   #   class RDFA < RDF::Vocabulary
 14 |   #     # @return [RDF::Vocabulary::Term]
 15 |   #     attr_reader :PGClass
 16 |   #
 17 |   #     # @return [RDF::Vocabulary::Term]
 18 |   #     attr_reader :Pattern
 19 |   #
 20 |   #     # @return [RDF::Vocabulary::Term]
 21 |   #     attr_reader :PrefixOrTermMapping
 22 |   #
 23 |   #     # @return [RDF::Vocabulary::Term]
 24 |   #     attr_reader :context
 25 |   #
 26 |   #     # @return [RDF::Vocabulary::Term]
 27 |   #     attr_reader :copy
 28 |   #
 29 |   #     # @return [RDF::Vocabulary::Term]
 30 |   #     attr_reader :prefix
 31 |   #
 32 |   #     # @return [RDF::Vocabulary::Term]
 33 |   #     attr_reader :term
 34 |   #
 35 |   #     # @return [RDF::Vocabulary::Term]
 36 |   #     attr_reader :uri
 37 |   #
 38 |   #     # @return [RDF::Vocabulary::Term]
 39 |   #     attr_reader :usesVocabulary
 40 |   #
 41 |   #     # @return [RDF::Vocabulary::Term]
 42 |   #     attr_reader :vocabulary
 43 |   #
 44 |   #     # @return [RDF::Vocabulary::Term]
 45 |   #     attr_reader :DocumentError
 46 |   #
 47 |   #     # @return [RDF::Vocabulary::Term]
 48 |   #     attr_reader :Error
 49 |   #
 50 |   #     # @return [RDF::Vocabulary::Term]
 51 |   #     attr_reader :Info
 52 |   #
 53 |   #     # @return [RDF::Vocabulary::Term]
 54 |   #     attr_reader :PrefixMapping
 55 |   #
 56 |   #     # @return [RDF::Vocabulary::Term]
 57 |   #     attr_reader :PrefixRedefinition
 58 |   #
 59 |   #     # @return [RDF::Vocabulary::Term]
 60 |   #     attr_reader :TermMapping
 61 |   #
 62 |   #     # @return [RDF::Vocabulary::Term]
 63 |   #     attr_reader :UnresolvedCURIE
 64 |   #
 65 |   #     # @return [RDF::Vocabulary::Term]
 66 |   #     attr_reader :UnresolvedTerm
 67 |   #
 68 |   #     # @return [RDF::Vocabulary::Term]
 69 |   #     attr_reader :VocabReferenceError
 70 |   #
 71 |   #     # @return [RDF::Vocabulary::Term]
 72 |   #     attr_reader :Warning
 73 |   #
 74 |   #   end
 75 |   RDFA = Class.new(RDF::Vocabulary("http://www.w3.org/ns/rdfa#")) do
 76 | 
 77 |     # Ontology definition
 78 |     ontology :"http://www.w3.org/ns/rdfa#",
 79 |       "dc:creator": "http://www.ivan-herman.net/foaf#me".freeze,
 80 |       "dc:date": "2013-01-18".freeze,
 81 |       "dc:description": "This document describes the RDFa Vocabulary for Term and Prefix Assignment. The Vocabulary is used to modify RDFa 1.1 processing behavior.".freeze,
 82 |       "dc:publisher": "http://www.w3.org/data#W3C".freeze,
 83 |       "dc:title": "RDFa Vocabulary for Term and Prefix Assignment, and for Processor Graph Reporting".freeze,
 84 |       isDefinedBy: "http://www.w3.org/TR/rdfa-core/#s_initialcontexts".freeze,
 85 |       "owl:versionInfo": "$Date: 2013-03-11 07:54:23 $".freeze,
 86 |       type: "owl:Ontology".freeze
 87 | 
 88 |     # Class definitions
 89 |     term :PGClass,
 90 |       "dc:description": "is the top level class of the hierarchy".freeze,
 91 |       type: ["owl:Class".freeze, "rdfs:Class".freeze]
 92 |     term :Pattern,
 93 |       "dc:description": "Class to identify an (RDF) resource whose properties are to be copied to another resource".freeze,
 94 |       type: ["owl:Class".freeze, "rdfs:Class".freeze]
 95 |     term :PrefixOrTermMapping,
 96 |       "dc:description": "is the top level class for prefix or term mappings".freeze,
 97 |       type: ["owl:Class".freeze, "rdfs:Class".freeze]
 98 | 
 99 |     # Property definitions
100 |     property :context,
101 |       "dc:description": "provides extra context for the error, eg, http response, an XPointer/XPath information, or simply the URI that created the error".freeze,
102 |       domain: "rdfa:PGClass".freeze,
103 |       type: ["owl:ObjectProperty".freeze, "rdf:Property".freeze]
104 |     property :copy,
105 |       "dc:description": "identifies the resource (i.e., pattern) whose properties and values should be copied to replace the current triple (retaining the subject of the triple).".freeze,
106 |       type: ["owl:ObjectProperty".freeze, "rdf:Property".freeze]
107 |     property :prefix,
108 |       "dc:description": "defines a prefix mapping for a URI; the value is supposed to be a NMTOKEN".freeze,
109 |       domain: "rdfa:PrefixMapping".freeze,
110 |       type: ["owl:DatatypeProperty".freeze, "rdf:Property".freeze]
111 |     property :term,
112 |       "dc:description": "defines a term mapping for a URI; the value is supposed to be a NMTOKEN".freeze,
113 |       domain: "rdfa:TermMapping".freeze,
114 |       type: ["owl:DatatypeProperty".freeze, "rdf:Property".freeze]
115 |     property :uri,
116 |       "dc:description": "defines the URI for either a prefix or a term mapping; the value is supposed to be an absolute URI".freeze,
117 |       domain: "rdfa:PrefixOrTermMapping".freeze,
118 |       type: ["owl:DatatypeProperty".freeze, "rdf:Property".freeze]
119 |     property :usesVocabulary,
120 |       "dc:description": "provides a relationship between the host document and a vocabulary\n\tdefined using the @vocab facility of RDFa1.1".freeze,
121 |       type: ["owl:ObjectProperty".freeze, "rdf:Property".freeze]
122 |     property :vocabulary,
123 |       "dc:description": "defines an absolute URI to be used as a default vocabulary; the value is can be any string; for documentation purposes it is advised to use the string 'true' or 'True'.".freeze,
124 |       type: ["owl:DatatypeProperty".freeze, "rdf:Property".freeze]
125 | 
126 |     # Extra definitions
127 |     term :DocumentError,
128 |       "dc:description": "error condition; to be used when the document fails to be fully processed as a result of non-conformant host language markup".freeze,
129 |       subClassOf: "rdfa:Error".freeze
130 |     term :Error,
131 |       "dc:description": "is the class for all error conditions".freeze,
132 |       subClassOf: "rdfa:PGClass".freeze
133 |     term :Info,
134 |       "dc:description": "is the class for all informations".freeze,
135 |       subClassOf: "rdfa:PGClass".freeze
136 |     term :PrefixMapping,
137 |       "dc:description": "is the class for prefix mappings".freeze,
138 |       subClassOf: "rdfa:PrefixOrTermMapping".freeze
139 |     term :PrefixRedefinition,
140 |       "dc:description": "warning; to be used when a prefix, either from the initial context or inherited from an ancestor node, is redefined in an element".freeze,
141 |       subClassOf: "rdfa:Warning".freeze
142 |     term :TermMapping,
143 |       "dc:description": "is the class for term mappings".freeze,
144 |       subClassOf: "rdfa:PrefixOrTermMapping".freeze
145 |     term :UnresolvedCURIE,
146 |       "dc:description": "warning; to be used when a CURIE prefix fails to be resolved".freeze,
147 |       subClassOf: "rdfa:Warning".freeze
148 |     term :UnresolvedTerm,
149 |       "dc:description": "warning; to be used when a Term fails to be resolved".freeze,
150 |       subClassOf: "rdfa:Warning".freeze
151 |     term :VocabReferenceError,
152 |       "dc:description": "warning; to be used when the value of a @vocab attribute cannot be dereferenced, hence the vocabulary expansion cannot be completed".freeze,
153 |       subClassOf: "rdfa:Warning".freeze
154 |     term :Warning,
155 |       "dc:description": "is the class for all warnings".freeze,
156 |       subClassOf: "rdfa:PGClass".freeze
157 |   end
158 | end
159 | 


--------------------------------------------------------------------------------
/lib/rdf/rdfa/context.rb:
--------------------------------------------------------------------------------
  1 | module RDF::RDFa
  2 |   ##
  3 |   # Context representation existing of a hash of terms, prefixes, a default vocabulary and a URI.
  4 |   #
  5 |   # Contexts are used for storing RDFa context representations. A representation is created
  6 |   # by serializing a context graph (typically also in RDFa, but may be in other representations).
  7 |   #
  8 |   # The class may be backed by an RDF::Repository, which will be used to retrieve a context graph
  9 |   # or to load into, if no such graph exists
 10 |   class Context
 11 |     include RDF::Util::Logger
 12 | 
 13 |     # Prefix mappings defined in this context
 14 |     # @!attribute [r] prefixes
 15 |     # @return  [Hash{Symbol => RDF::URI}]
 16 |     attr_reader :prefixes
 17 | 
 18 |     # Term mappings defined in this context
 19 |     # @!attribute [r] terms
 20 |     # @return [Hash{Symbol => RDF::URI}]
 21 |     attr_reader :terms
 22 | 
 23 |     # Default URI defined for this vocabulary
 24 |     # @!attribute [r] vocabulary
 25 |     # @return [RDF::URI]
 26 |     attr_reader :vocabulary
 27 | 
 28 |     # URI defining this context
 29 |     # @!attribute [r] uri
 30 |     # @return [RDF::URI]
 31 |     attr_reader :uri
 32 | 
 33 |     ##
 34 |     # Initialize a new context from the given URI.
 35 |     #
 36 |     # Parses the context and places it in the repository and cache
 37 |     #
 38 |     # @param [RDF::URI, #to_s] uri URI of context to be represented
 39 |     # @yield [context]
 40 |     # @yieldparam [RDF::RDFa::Context] context
 41 |     # @yieldreturn [void] ignored
 42 |     # @return [RDF::RDFa::Context]
 43 |     def initialize(uri, **options, &block)
 44 |       @uri = RDF::URI.intern(uri)
 45 |       @prefixes = options.fetch(:prefixes, {})
 46 |       @terms = options.fetch(:terms, {})
 47 |       @vocabulary = options[:vocabulary]
 48 |       @options = options.dup
 49 | 
 50 |       yield(self) if block_given?
 51 |       self
 52 |     end
 53 | 
 54 |     ##
 55 |     # @return [RDF::Util::Cache]
 56 |     # @private
 57 |     def self.cache
 58 |       require 'rdf/util/cache' unless defined?(::RDF::Util::Cache)
 59 |       @cache ||= begin
 60 |         RDF::Util::Cache.new(-1)
 61 |       end
 62 |     end
 63 | 
 64 |     ##
 65 |     # Repository used for saving contexts
 66 |     # @return [RDF::Repository]
 67 |     def self.repository
 68 |       @repository ||= RDF::Repository.new(title: "RDFa Contexts")
 69 |     end
 70 | 
 71 |     ##
 72 |     # Set repository used for saving contexts
 73 |     # @param [RDF::Repository] repo
 74 |     # @return [RDF::Repository]
 75 |     def self.repository=(repo)
 76 |       unless repo.supports?(:graph_name)
 77 |         if respond_to?(:log_fatal)
 78 |           log_fatal("Context Repository must support graph_name", exception: ContextError)
 79 |         else
 80 |           abort("Context Repository must support graph_name")
 81 |         end
 82 |       end
 83 |       @repository = repo
 84 |     end
 85 | 
 86 |     # Return a context faulting through the cache
 87 |     # @return [RDF::RDFa::Context]
 88 |     def self.find(uri)
 89 |       uri = RDF::URI.intern(uri)
 90 | 
 91 |       return cache[uri] unless cache[uri].nil?
 92 | 
 93 |       # Two part creation to prevent re-entrancy problems if p1 => p2 and p2 => p1
 94 |       # Return something to make the caller happy if we're re-entered
 95 |       cache[uri] = Struct.new(:prefixes, :terms, :vocabulary).new({}, {}, nil)
 96 |       # Now do the actual load
 97 |       cache[uri] = new(uri) do |context|
 98 |         log_debug("process_context: retrieve context <#{uri}>") if respond_to?(:log_debug)
 99 |         Context.load(uri)
100 |         context.parse(repository.query({graph_name: uri}))
101 |       end
102 |     rescue Exception => e
103 |       if respond_to?(:log_fatal)
104 |         log_error("Context #{uri}: #{e.message}")
105 |       else
106 |         abort("Context #{uri}: #{e.message}")
107 |       end
108 |     end
109 | 
110 |     # Load context into repository
111 |     def self.load(uri)
112 |       uri = RDF::URI.intern(uri)
113 |       repository.load(uri.to_s, base_uri: uri, graph_name: uri) unless repository.has_graph?(uri)
114 |     end
115 | 
116 |     # @return [RDF::Repository]
117 |     def repository
118 |       Context.repository
119 |     end
120 | 
121 |     ##
122 |     # Defines the given named URI prefix for this context.
123 |     #
124 |     # @example Defining a URI prefix
125 |     #   context.prefix :dc, RDF::URI('http://purl.org/dc/terms/')
126 |     #
127 |     # @example Returning a URI prefix
128 |     #   context.prefix(:dc)    #=> RDF::URI('http://purl.org/dc/terms/')
129 |     #
130 |     # @param  [Symbol, #to_s]   name
131 |     # @param  [RDF::URI, #to_s] uri
132 |     # @return [RDF::URI]
133 |     def prefix(name, uri = nil)
134 |       name = name.to_s.empty? ? nil : (name.respond_to?(:to_sym) ? name.to_sym : name.to_s.to_sym)
135 |       uri.nil? ? prefixes[name] : prefixes[name] = uri
136 |     end
137 | 
138 |     ##
139 |     # Defines the given named URI term for this context.
140 |     #
141 |     # @example Defining a URI term
142 |     #   context.term :title, RDF::URI('http://purl.org/dc/terms/title')
143 |     #
144 |     # @example Returning a URI context
145 |     #   context.term(:title)    #=> RDF::URI('http://purl.org/dc/terms/TITLE')
146 |     #
147 |     # @param  [Symbol, #to_s]   name
148 |     # @param  [RDF::URI, #to_s] uri
149 |     # @return [RDF::URI]
150 |     def term(name, uri = nil)
151 |       name = name.to_s.empty? ? nil : (name.respond_to?(:to_sym) ? name.to_sym : name.to_s.to_sym)
152 |       uri.nil? ? terms[name] : terms[name] = uri
153 |     end
154 | 
155 |     ##
156 |     # Extract vocabulary, prefix mappings and terms from a enumerable object into an instance
157 |     #
158 |     # @param [RDF::Enumerable, Enumerator] enumerable
159 |     # @return [void] ignored
160 |     def parse(enumerable)
161 |       log_debug("process_context: parse context <#{uri}>") if respond_to?(:log_debug)
162 |       resource_info = {}
163 |       enumerable.each do |statement|
164 |         res = resource_info[statement.subject] ||= {}
165 |         next unless statement.object.is_a?(RDF::Literal)
166 |         log_debug("process_context: statement=#{statement.inspect}") if respond_to?(:log_debug)
167 |         %w(uri term prefix vocabulary).each do |term|
168 |           res[term] ||= statement.object.value if statement.predicate == RDF::RDFA[term]
169 |         end
170 |       end
171 | 
172 |       resource_info.values.each do |res|
173 |         # If one of the objects is not a Literal or if there are additional rdfa:uri or rdfa:term
174 |         # predicates sharing the same subject, no mapping is created.
175 |         uri = res["uri"]
176 |         term = res["term"]
177 |         prefix = res["prefix"]
178 |         vocab = res["vocabulary"]
179 |         log_debug("process_context: uri=#{uri.inspect}, term=#{term.inspect}, prefix=#{prefix.inspect}, vocabulary=#{vocab.inspect}") if respond_to?(:log_debug)
180 | 
181 |         @vocabulary = vocab if vocab
182 | 
183 |         # For every extracted triple that is the common subject of an rdfa:prefix and an rdfa:uri
184 |         # predicate, create a mapping from the object literal of the rdfa:prefix predicate to the
185 |         # object literal of the rdfa:uri predicate. Add or update this mapping in the local list of
186 |         # URI mappings after transforming the 'prefix' component to lower-case.
187 |         # For every extracted
188 |         prefix(prefix.downcase, uri) if uri && prefix && prefix != "_"
189 | 
190 |         # triple that is the common subject of an rdfa:term and an rdfa:uri predicate, create a
191 |         # mapping from the object literal of the rdfa:term predicate to the object literal of the
192 |         # rdfa:uri predicate. Add or update this mapping in the local term mappings.
193 |         term(term, uri) if term && uri
194 |       end
195 |     end
196 |   end
197 | 
198 |   ##
199 |   # The base class for RDF context errors.
200 |   class ContextError < IOError; end
201 | end
202 | 
203 | # Load cooked contexts
204 | Dir.glob(File.join(File.expand_path(File.dirname(__FILE__)), 'context', '*')).each {|f| load f}
205 | 


--------------------------------------------------------------------------------
/lib/rdf/rdfa/expansion.rb:
--------------------------------------------------------------------------------
  1 | require 'rdf/aggregate_repo'
  2 | 
  3 | module RDF::RDFa
  4 |   ##
  5 |   # The Expansion module performs a subset of OWL entailment rules on the base class,
  6 |   # which implementes RDF::Readable.
  7 |   module Expansion
  8 | 
  9 |     ##
 10 |     # Perform vocabulary expansion on the resulting default graph.
 11 |     #
 12 |     #   Vocabulary expansion uses the built-in reasoner using included vocabularies from RDF.rb.
 13 |     #
 14 |     # @param [RDF::Repository] repository
 15 |     # @see [OWL2 PROFILES](https://www.w3.org/TR/2009/REC-owl2-profiles-20091027/#Reasoning_in_OWL_2_RL_and_RDF_Graphs_using_Rules)
 16 |     def expand(repository)
 17 |       add_debug("expand") {"Repository has #{repository.count} statements"}
 18 | 
 19 |       # Load missing vocabularies
 20 |       vocabs = repository.query({predicate: RDF::RDFA.usesVocabulary}).to_a.map(&:object)
 21 |       vocabs.map! do |vocab|
 22 |         begin
 23 |           # Create the name with a predictable name so that it is enumerated and can be found
 24 |           v = RDF::Vocabulary.find(vocab) || begin
 25 |             vg = RDF::Graph.load(vocab)
 26 |             RDF::Vocabulary.from_graph(vg, url: vocab, class_name: "D#{Digest::MD5.hexdigest vocab}") unless vg.empty?
 27 |           end
 28 |         rescue Exception => e
 29 |           # indicate the warning if the vocabulary fails to laod
 30 |           add_warning("expand", "Error loading vocabulary #{vocab}: #{e.message}", RDF::RDFA.UnresolvedVocabulary)
 31 |           nil
 32 |         end
 33 |       end.compact
 34 | 
 35 |       entailment(repository, vocabs)
 36 |       add_debug("expand") {"Repository now has #{repository.count} statements"}
 37 | 
 38 |     end
 39 | 
 40 |     ##
 41 |     # Perform property copying on the resulting default graph.
 42 |     #
 43 |     # For all objects of type rdfa:Pattern that are the target of an rdfa:copy property, load the IRI into a repository.
 44 |     #
 45 |     # Subsequently, remove reference rdfa:Pattern objects.
 46 |     #
 47 |     # @param [RDF::Repository] repository
 48 |     # @see [HTML+RDFa](https://www.w3.org/TR/rdfa-in-html/#rdfa-reference-folding)
 49 |     def copy_properties(repository)
 50 |       add_debug("expand") {"Repository has #{repository.size} statements"}
 51 |       fold(repository)
 52 |     end
 53 | 
 54 |     def rule(name, &block)
 55 |       Rule.new(name, block)
 56 |     end
 57 | 
 58 |     ##
 59 |     # An entailment rule
 60 |     #
 61 |     # Takes a list of antecedent patterns used to find solutions against a queryable
 62 |     # object. Yields each consequent with bindings from the solution
 63 |     class Rule
 64 |       # @!attribute [r] antecedents
 65 |       # @return [Array<RDF::Query::Pattern>]
 66 |       attr_reader :antecedents
 67 | 
 68 |       # @!attribute [r] consequents
 69 |       # @return [Array<RDF::Query::Pattern>]
 70 |       attr_reader :consequents
 71 | 
 72 |       # @!attribute [r] deletions
 73 |       # @return [Array<RDF::Query::Pattern>]
 74 |       attr_reader :deletions
 75 | 
 76 |       # @!attribute [r] name
 77 |       # @return [String]
 78 |       attr_reader :name
 79 | 
 80 |       ##
 81 |       # @example
 82 |       #   r = Rule.new("scm-spo") do
 83 |       #     antecedent :p1, RDF::RDFS.subPropertyOf, :p2
 84 |       #     antecedent :p2, RDF::RDFS.subPropertyOf, :p3
 85 |       #     consequent :p1, RDF::RDFS.subPropertyOf, :p3, "t-box"
 86 |       #   end
 87 |       #
 88 |       #   r.execute(queryable) {|statement| puts statement.inspect}
 89 |       #
 90 |       # @param [String] name
 91 |       def initialize(name, &block)
 92 |         @antecedents = []
 93 |         @consequents = []
 94 |         @name = name
 95 | 
 96 |         if block_given?
 97 |           case block.arity
 98 |             when 1 then block.call(self)
 99 |             else instance_eval(&block)
100 |           end
101 |         end
102 |       end
103 | 
104 |       def antecedent(subject, prediate, object)
105 |         antecedents << RDF::Query::Pattern.new(subject, prediate, object)
106 |       end
107 | 
108 |       def consequent(subject, prediate, object)
109 |         consequents << RDF::Query::Pattern.new(subject, prediate, object)
110 |       end
111 | 
112 |       ##
113 |       # Execute the rule against queryable, yielding each consequent with bindings
114 |       #
115 |       # @param [RDF::Queryable] queryable
116 |       # @yield [statement]
117 |       # @yieldparam [RDF::Statement] statement
118 |       def execute(queryable)
119 |         RDF::Query.new(antecedents).execute(queryable).each do |solution|
120 |           nodes = {}
121 |           consequents.each do |consequent|
122 |             terms = {}
123 |             [:subject, :predicate, :object].each do |r|
124 |               terms[r] = case o = consequent.send(r)
125 |               when RDF::Node            then nodes[o] ||= RDF::Node.new
126 |               when RDF::Query::Variable then solution[o]
127 |               else                           o
128 |               end
129 |             end
130 | 
131 |             yield RDF::Statement.from(terms)
132 |           end
133 |         end
134 |       end
135 |     end
136 | 
137 |   private
138 | 
139 |     RULES = [
140 |       Rule.new("prp-spo1") do
141 |         antecedent :p1, RDF::RDFS.subPropertyOf, :p2
142 |         antecedent :x, :p1, :y
143 |         consequent :x, :p2, :y
144 |       end,
145 |       Rule.new("prp-eqp1") do
146 |         antecedent :p1, RDF::OWL.equivalentProperty, :p2
147 |         antecedent :x, :p1, :y
148 |         consequent :x, :p2, :y
149 |       end,
150 |       Rule.new("prp-eqp2") do
151 |         antecedent :p1, RDF::OWL.equivalentProperty, :p2
152 |         antecedent :x, :p2, :y
153 |         consequent :x, :p1, :y
154 |       end,
155 |       Rule.new("cax-sco") do
156 |         antecedent :c1, RDF::RDFS.subClassOf, :c2
157 |         antecedent :x, RDF.type, :c1
158 |         consequent :x, RDF.type, :c2
159 |       end,
160 |       Rule.new("cax-eqc1") do
161 |         antecedent :c1, RDF::OWL.equivalentClass, :c2
162 |         antecedent :x, RDF.type, :c1
163 |         consequent :x, RDF.type, :c2
164 |       end,
165 |       Rule.new("cax-eqc2") do
166 |         antecedent :c1, RDF::OWL.equivalentClass, :c2
167 |         antecedent :x, RDF.type, :c2
168 |         consequent :x, RDF.type, :c1
169 |       end,
170 |     ]
171 | 
172 |     FOLDING_RULES = [
173 |       Rule.new("rdfa-ref") do
174 |         antecedent :x, RDF::RDFA.copy, :PR
175 |         antecedent :PR, RDF.type, RDF::RDFA.Pattern
176 |         antecedent :PR, :p, :y
177 |         consequent :x, :p, :y
178 |       end,
179 |     ]
180 | 
181 |     REMOVAL_RULES = [
182 |       Rule.new("rdfa-ref-remove") do
183 |         antecedent :x, RDF::RDFA.copy, :PR
184 |         antecedent :PR, RDF.type, RDF::RDFA.Pattern
185 |         antecedent :PR, :p, :y
186 |         consequent :x, RDF::RDFA.copy, :PR
187 |         consequent :x, RDF.type, RDF::RDFA.Pattern
188 |         consequent :PR, :p, :y
189 |       end,
190 |     ]
191 | 
192 |     ##
193 |     # Perform OWL entailment rules on repository
194 |     # @param [RDF::Repository] repository
195 |     # @return [RDF::Repository]
196 |     def entailment(repository, vocabs)
197 |       old_count = 0
198 | 
199 |       # Create an aggregate repo containing base repository and relevant entailment rules from the included vocabularies
200 |       v_repo = RDF::Repository.new do |r|
201 |         vocabs.each do |v|
202 |           v.each_statement do |statement|
203 |             r << statement if [
204 |               RDF::OWL.equivalentProperty,
205 |               RDF::OWL.equivalentClass,
206 |               RDF::RDFS.subPropertyOf,
207 |               RDF::RDFS.subClassOf
208 |             ].include?(statement.predicate)
209 |           end
210 |         end
211 |       end
212 | 
213 |       ag_repo = RDF::MergeGraph.new do
214 |         source repository, false
215 |         source v_repo, false
216 |       end
217 | 
218 |       # Continue as long as new statements are added to repository
219 |       while old_count < (count = repository.count)
220 |         #add_debug("entailment") {"old: #{old_count} count: #{count}"}
221 |         old_count = count
222 |         to_add = []
223 | 
224 |         RULES.each do |rule|
225 |           rule.execute(ag_repo) do |statement|
226 |             #add_debug("entailment(#{rule.name})") {statement.inspect}
227 |             to_add << statement
228 |           end
229 |         end
230 | 
231 |         repository.insert(*to_add)
232 |       end
233 |     end
234 | 
235 |     ##
236 |     # Perform RDFa folding rules on repository
237 |     # @param [RDF::Repository] repository
238 |     def fold(repository)
239 |       old_count = 0
240 | 
241 |       # Continue as long as new statements are added to repository
242 |       while old_count < (count = repository.count)
243 |         #add_debug("fold") {"old: #{old_count} count: #{count}"}
244 |         old_count = count
245 |         to_add = []
246 | 
247 |         FOLDING_RULES.each do |rule|
248 |           rule.execute(repository) do |statement|
249 |             #add_debug("fold(#{rule.name})") {statement.inspect}
250 |             to_add << statement
251 |           end
252 |         end
253 | 
254 |         repository.insert(*to_add)
255 |       end
256 | 
257 |       # Remove statements matched by removal rules
258 |       to_remove = []
259 |       REMOVAL_RULES.each do |rule|
260 |         rule.execute(repository) do |statement|
261 |           #add_debug("removal(#{rule.name})") {statement.inspect}
262 |           to_remove << statement
263 |         end
264 |       end
265 |       repository.delete(*to_remove)
266 | 
267 |       add_debug("fold", "final count: #{count}")
268 |     end
269 |   end
270 | end
271 | 


--------------------------------------------------------------------------------
/example-files/webid.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" dir="ltr"
  3 |   xmlns:content="http://purl.org/rss/1.0/modules/content/"
  4 |   xmlns:dc="http://purl.org/dc/terms/"
  5 |   xmlns:foaf="http://xmlns.com/foaf/0.1/"
  6 |   xmlns:og="http://ogp.me/ns#"
  7 |   xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
  8 |   xmlns:sioc="http://rdfs.org/sioc/ns#"
  9 |   xmlns:sioct="http://rdfs.org/sioc/types#"
 10 |   xmlns:skos="http://www.w3.org/2004/02/skos/core#"
 11 |   xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
 12 |   xmlns:cert="http://www.w3.org/ns/auth/cert#"
 13 |   xmlns:schema="http://schema.org/">
 14 | 
 15 | <head profile="http://www.w3.org/1999/xhtml/vocab">
 16 |   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 17 | <link rel="shortcut icon" href="http://dev.openspring.net/misc/favicon.ico" type="image/vnd.microsoft.icon" />
 18 | <meta about="/tmp/webid/3.html" property="foaf:name" content="test3" />
 19 | <meta about="/tmp/webid/3.html#me" typeof="foaf:Person" rel="foaf:account" resource="/tmp/webid/3.html" />
 20 | <meta name="Generator" content="Drupal 7 (http://drupal.org)" />
 21 |   <title>test3 | Site-Install</title>
 22 |   <style type="text/css" media="all">@import url("http://dev.openspring.net/modules/system/system.base.css?lyzso4");
 23 | @import url("http://dev.openspring.net/modules/system/system.menus.css?lyzso4");
 24 | @import url("http://dev.openspring.net/modules/system/system.messages.css?lyzso4");
 25 | @import url("http://dev.openspring.net/modules/system/system.theme.css?lyzso4");</style>
 26 | <style type="text/css" media="all">@import url("http://dev.openspring.net/modules/comment/comment.css?lyzso4");
 27 | @import url("http://dev.openspring.net/modules/field/theme/field.css?lyzso4");
 28 | @import url("http://dev.openspring.net/modules/node/node.css?lyzso4");
 29 | @import url("http://dev.openspring.net/modules/search/search.css?lyzso4");
 30 | @import url("http://dev.openspring.net/modules/user/user.css?lyzso4");</style>
 31 | <style type="text/css" media="all">@import url("http://dev.openspring.net/themes/bartik/css/layout.css?lyzso4");
 32 | @import url("http://dev.openspring.net/themes/bartik/css/style.css?lyzso4");
 33 | @import url("http://dev.openspring.net/themes/bartik/css/colors.css?lyzso4");</style>
 34 | <style type="text/css" media="print">@import url("http://dev.openspring.net/themes/bartik/css/print.css?lyzso4");</style>
 35 | 
 36 | <!--[if lte IE 7]>
 37 | <link type="text/css" rel="stylesheet" href="http://dev.openspring.net/themes/bartik/css/ie.css?lyzso4" media="all" />
 38 | <![endif]-->
 39 | 
 40 | <!--[if IE 6]>
 41 | <link type="text/css" rel="stylesheet" href="http://dev.openspring.net/themes/bartik/css/ie6.css?lyzso4" media="all" />
 42 | <![endif]-->
 43 |   <script type="text/javascript" src="http://dev.openspring.net/misc/jquery.js?v=1.4.4"></script>
 44 | <script type="text/javascript" src="http://dev.openspring.net/misc/jquery.once.js?v=1.2"></script>
 45 | <script type="text/javascript" src="http://dev.openspring.net/misc/drupal.js?lyzso4"></script>
 46 | <script type="text/javascript">
 47 | <!--//--><![CDATA[//><!--
 48 | jQuery.extend(Drupal.settings, {"basePath":"\/","pathPrefix":"","ajaxPageState":{"theme":"bartik","theme_token":"3UNp6NwamBgE5rmBjI8nf5ehqHNLiRr8zsvA4lQMTVM","js":{"misc\/jquery.js":1,"misc\/jquery.once.js":1,"misc\/drupal.js":1},"css":{"modules\/system\/system.base.css":1,"modules\/system\/system.menus.css":1,"modules\/system\/system.messages.css":1,"modules\/system\/system.theme.css":1,"modules\/comment\/comment.css":1,"modules\/field\/theme\/field.css":1,"modules\/node\/node.css":1,"modules\/search\/search.css":1,"modules\/user\/user.css":1,"themes\/bartik\/css\/layout.css":1,"themes\/bartik\/css\/style.css":1,"themes\/bartik\/css\/colors.css":1,"themes\/bartik\/css\/print.css":1,"themes\/bartik\/css\/ie.css":1,"themes\/bartik\/css\/ie6.css":1}}});
 49 | //--><!]]>
 50 | </script>
 51 | </head>
 52 | <body class="html not-front not-logged-in one-sidebar sidebar-first page-user page-user- page-user-3" >
 53 |   <div id="skip-link">
 54 |     <a href="#main-content" class="element-invisible element-focusable">Skip to main content</a>
 55 |   </div>
 56 |     <div id="page-wrapper"><div id="page">
 57 | 
 58 |   <div id="header" class="without-secondary-menu"><div class="section clearfix">
 59 | 
 60 |           <a href="/" title="Home" rel="home" id="logo">
 61 |         <img src="http://dev.openspring.net/themes/bartik/logo.png" alt="Home" />
 62 |       </a>
 63 |     
 64 |           <div id="name-and-slogan">
 65 | 
 66 |                               <div id="site-name">
 67 |               <strong>
 68 |                 <a href="/" title="Home" rel="home"><span>Site-Install</span></a>
 69 |               </strong>
 70 |             </div>
 71 |                   
 72 |         
 73 |       </div> <!-- /#name-and-slogan -->
 74 |     
 75 |     
 76 |           <div id="main-menu" class="navigation">
 77 |         <h2 class="element-invisible">Main menu</h2><ul id="main-menu-links" class="links clearfix"><li class="menu-239 first last"><a href="/">Home</a></li>
 78 | </ul>      </div> <!-- /#main-menu -->
 79 |     
 80 |     
 81 |   </div></div> <!-- /.section, /#header -->
 82 | 
 83 |   
 84 |   
 85 |   <div id="main-wrapper" class="clearfix"><div id="main" class="clearfix">
 86 | 
 87 |           <div id="breadcrumb"><h2 class="element-invisible">You are here</h2><div class="breadcrumb"><a href="/">Home</a></div></div>
 88 |     
 89 |           <div id="sidebar-first" class="column sidebar"><div class="section">
 90 |           <div class="region region-sidebar-first">
 91 |     <div id="block-user-login" class="block block-user">
 92 | 
 93 |     <h2>User login</h2>
 94 |   
 95 |   <div class="content">
 96 |     <form action="/tmp/webid/3.html?destination=user/3" method="post" id="user-login-form" accept-charset="UTF-8"><div><div class="form-item form-type-textfield form-item-name">
 97 |   <label for="edit-name">Username <span class="form-required" title="This field is required.">*</span></label>
 98 |  <input type="text" id="edit-name" name="name" value="" size="15" maxlength="60" class="form-text required" />
 99 | </div>
100 | <div class="form-item form-type-password form-item-pass">
101 |   <label for="edit-pass">Password <span class="form-required" title="This field is required.">*</span></label>
102 |  <input type="password" id="edit-pass" name="pass" size="15" maxlength="60" class="form-text required" />
103 | </div>
104 | <div class="item-list"><ul><li class="first"><a href="/user/register" title="Create a new user account.">Create new account</a></li>
105 | <li class="last"><a href="/user/password" title="Request new password via e-mail.">Request new password</a></li>
106 | </ul></div><input type="hidden" name="form_build_id" value="form-2ttAqAGgw_aZSlcZPw6mhX1268cxCyfFRUIpRdA_2t4" />
107 | <input type="hidden" name="form_id" value="user_login_block" />
108 | <div class="form-actions form-wrapper" id="edit-actions"><input type="submit" id="edit-submit" name="op" value="Log in" class="form-submit" /></div></div></form>  </div>
109 | </div>
110 |   </div>
111 |       </div></div> <!-- /.section, /#sidebar-first -->
112 |     
113 |     <div id="content" class="column"><div class="section">
114 |             <a id="main-content"></a>
115 |                     <h1 class="title" id="page-title">
116 |           test3        </h1>
117 |                           <div class="tabs">
118 |                   </div>
119 |                           <div class="region region-content">
120 |     <div id="block-system-main" class="block block-system">
121 | 
122 |     
123 |   <div class="content">
124 |     <div class="profile" typeof="sioc:UserAccount" about="/tmp/webid/3.html">
125 |   <div class="field field-name-field-key field-type-rsapublickey field-label-above"><div class="field-label">key:&nbsp;</div><div class="field-items"><div class="field-item even" property=""><div about="/tmp/webid/3.html#me">  <div rel="cert:key">    <div typeof="cert:RSAPublicKey">      <dl>        <dt>Modulus (hexadecimal)</dt>        <dd property="cert:modulus" datatype="xsd:hexBinary">c3 4d eb 69 94 cf b1 1f 50 12 b2 df c7 6c a6 99 de 5e 49 b5 66 62 ea 3a 6e d6 00 12 eb ed 7c cd 96 9b cd d1 8b 73 59 5d a5 4b 88 d0 1a 1f c4 6d 08 fe 6c 80 51 15 05 ff d7 9e 24 67 7c 6b 47 77 f4 82 46 c4 0a 10 c2 24 bc 12 5a 45 b1 bb 92 b6 c8 4b 0d cc 5a ad 4c 31 eb 1a 22 2f d6 df 7c 0d 92 45 1f f3 e5 d2 70 0f c8 3b 15 b9 a7 ac 4c d3 ca 20 b9 d2 18 ab 52 04 e2 79 cd 3a a1 d7 57 bc 66 23 14 5a 08 cc 99 3b bc bf f6 6a a5 cd f2 12 80 b6 c0 a0 bc 44 51 9b 08 09 53 6e c6 83 c5 8b 9a 88 1c e2 b5 29 8d 6f c0 04 ae bf a8 d6 64 a4 05 79 51 e7 83 db d7 dd 61 61 1a 84 19 28 28 f5 6d c3 25 fe 4b 12 b3 56 2d b2 1e 4c 22 51 d3 2e b3 14 25 2a 09 59 25 bb 10 ed 12 2b a4 d1 1d de 68 1b 22 d2 85 16 c6 58 7b a3 2d e6 e0 7c 44 12 e9 e6 d0 0b 5a 0b 22 f6 f4 0d 09 f5 1c 67 85 8b 
126 | </dd>        <dt>Exponent (decimal)</dt>        <dd property="cert:exponent" datatype="xsd:integer">65537</dd>      </dl>    </div>  </div></div></div></div></div>  <h3>History</h3>
127 | 
128 | <dl>
129 |   <dt>Member for</dt>
130 | <dd>10 min 43 sec</dd>
131 | </dl>
132 | <span property="foaf:name" content="test3" class="rdf-meta"></span></div>
133 |   </div>
134 | </div>
135 |   </div>
136 |       
137 |     </div></div> <!-- /.section, /#content -->
138 | 
139 |     
140 |   </div></div> <!-- /#main, /#main-wrapper -->
141 | 
142 |   
143 |   <div id="footer-wrapper"><div class="section">
144 | 
145 |     
146 |           <div id="footer" class="clearfix">
147 |           <div class="region region-footer">
148 |     <div id="block-system-powered-by" class="block block-system">
149 | 
150 |     
151 |   <div class="content">
152 |     <span>Powered by <a href="http://drupal.org">Drupal</a></span>  </div>
153 | </div>
154 |   </div>
155 |       </div> <!-- /#footer -->
156 |     
157 |   </div></div> <!-- /.section, /#footer-wrapper -->
158 | 
159 | </div></div> <!-- /#page, /#page-wrapper -->
160 |   </body>
161 | </html>
162 | 


--------------------------------------------------------------------------------
/History.md:
--------------------------------------------------------------------------------
  1 | ### 1.0.1
  2 | * LC version of HTML+RDFa
  3 |   * Remove support for @value
  4 |   * Prefer @content to @datetime
  5 | 
  6 | ### 1.0.0
  7 | * 1.0 release!
  8 | 
  9 | ### 0.3.20
 10 | * Change rdfa:Prototype/rdfa:ref to rdfa:Pattern/rdfa:copy. Feature now called Property Copying instead of Reference Folding.
 11 | ### 0.3.19
 12 | * Generate UnresolvedTerm and UnresolvedCURIE as indicated. UnresolvedCURIE only generated for SafeCURIEs.
 13 | * Perform basic sanity checking before emitting triples. Validation is too strict for most usage.
 14 | * Add HTML5 logic to remove unwanted @rel and @rev items.
 15 | * Make reference folding standard, under option control.
 16 | 
 17 | ### 0.3.18
 18 | * Fixed additional incomplete-triples bug with typed resource
 19 | * Added experimental support for rdfa:copy
 20 | 
 21 | ### 0.3.17
 22 | * Added rdfa:PrefixReDefinition warning.
 23 | 
 24 | ### 0.3.16
 25 | * Fix step 11 when there is @resource, @href and @src but not @rel or @rev to not also depend on the state of incomplete triples. This addresses an odd Drupal case.
 26 | * respec shared examples updates to match rdf-spec 0.3.11
 27 | ### 0.3.15
 28 | * Add support for `@role` attribute.
 29 | * Processing defaults to HTML, rather than XML, unless XML is explicitly detected.
 30 | * Process embedded RDF:XML, if RDF::RDFXML is loaded, and a RDF/XML is detected.
 31 | * Process alternate readers where content is contained within a &lt;script&gt; tag, based on the @type attribute. This is commonly used for N-Triples and Turtle embedded in HTML.
 32 | * If @itemscope detected, and RDF::Microdata is loaded, process embedded microdata.
 33 | 
 34 | ### 0.3.14
 35 | * Support for rdf:HTML literal.
 36 | 
 37 | ### 0.3.13
 38 | * Parse any include RDF/XML if RDF::RDFXML is available.
 39 | * Add support for extracting RDF from &lt;script&gt; elements.
 40 | * Places triples in a named graph if the script has an @id attribute.
 41 | 
 42 | ### 0.3.11
 43 | * Up to date with RDFa Proposed Recomendation versions of specs.
 44 | * Fix problems with @resource=\[\] or @about=\[\], which should be ignored and use the next most appropriate attribute.
 45 | * Remove support for @data, which was previously a synonym for @src in HTML5.
 46 | * More robust detection of XHTML1 if version is rdfa1.0
 47 | * Support change to remove @rel/@rev elements that aren't CURIES or IRIs when in the presense of @property
 48 | 
 49 | ### 0.3.10.1
 50 | * Fix case where @datatype and @property are present, but @datatype is empty. (TC 290)
 51 | 
 52 | ### 0.3.10
 53 | * Updated to Candidate Recommendation of drafts:
 54 |   * [RDFa 1.1 Core](http://www.w3.org/TR/2012/CR-rdfa-core-20120313/)
 55 |   * [RDFa Lite 1.1](http://www.w3.org/TR/2012/CR-rdfa-lite-20120313/)
 56 |   * [XHTML+RDFa 1.1](http://www.w3.org/TR/2012/CR-xhtml-rdfa-20120313/)
 57 |   * [HTML+RDFa 1.1](http://dev.w3.org/html5/rdfa/)
 58 | * change profile to context to conform with change in use in RDFa 1.1.
 59 | * Change `:expand\_reader` option to `:vocab\_expansion`, to conform with RDFa Core 1.1 definition.
 60 | * Changed `:processor\_graph` to `:processor\_callback` and added `:rdfagraph` option, taking either or both of `:output` and `:processor`.
 61 | * Better error recovery is there is no document root.
 62 | * Updates to CURIE definition, Term resolution (use @vocab first), and Error/Warning generation in the processor graph.
 63 | * `rdfa:usesVocabulary` changed to `rdfa:hasVocabulary`.
 64 | * Tolerate errors in vocabulary download when missing.
 65 | * Change `SafeCURIEorCURIEorIRI` to not include term.
 66 | * Remove `TERMorCURIEorAbsIRIprop`, as it doesn't seem necessary.
 67 | 
 68 | ### 0.3.9
 69 | * Updated to latest working drafts:
 70 |   * [RDFa 1.1 Core](http://www.w3.org/TR/2011/WD-rdfa-core-20110331/)
 71 |   * [RDFa Lite 1.1](http://www.w3.org/2010/02/rdfa/drafts/2011/ED-rdfa-lite-20111030/)
 72 |   * [XHTML+RDFa 1.1](http://www.w3.org/TR/2011/WD-xhtml-rdfa-20110331/)
 73 |   * [HTML+RDFa 1.1](http://www.w3.org/TR/2011/WD-rdfa-in-html-20110525/)
 74 | * In reader:
 75 |   * Don't default xhtml1 and rdfa1.1 in parser; depend on host_detect.
 76 |   * Use separate context documents for XML, XHTML and HTML.
 77 |   * Remove Facet gem, which was causing problems with Active Record.
 78 |   * Added full support for HTML5 &lt;time&gt; element.
 79 |   * Added support for HTML5 &lt;data&gt; element with @value attribute to create a plain literal with possible language.
 80 |   * Change vocabulary expansion rules to use OWL 2 RL entailment.
 81 |   * Terms can now include a '/', to allow for use with @vocab where the class/property is a relative IRI.
 82 | * In writer:
 83 |   * Don't serialize using XHTML initial context, as it is not used universally.
 84 |   * Simplify Haml templates using latest RDFa attribute semantics
 85 | 
 86 | ### 0.3.8
 87 | * Remove hard dependency on Nokogiri. Use it if it is available, otherwise fallback to REXML.
 88 |   * JRuby uses REXML due to some implementation issues with the pure-java implementation of Nokogiri.
 89 | * Support for RDF Lite 1.1
 90 | * Add support for @property doing object references if used with @href/@src/@resource (but no @rel)
 91 | * Add support for @property chaining if used with @typeof.
 92 | * Change @typeof behavior to add type to object, not subject, unless used with @about.
 93 | 
 94 | ### 0.3.7
 95 | * RDF.rb 0.3.4 compatibility.
 96 | * Changed @member to @inlist.
 97 | * Added format detection.
 98 | * Serialize lists.
 99 | * Change @src to be like @resource for RDFa 1.1 (still like @about for RDFa 1.0).
100 | * Fix writer template issues with muti-valued properties
101 | 
102 | ### 0.3.6
103 | * Sync with changes to RDFa 1.1 spec:
104 |   * Deprecate explicit use of @profile
105 |   * Add rdfa:hasVocabulary when encountering @vocab
106 |   * Implemented Reader#expand to perform vocabulary expansion using RDFS rules 5, 7, 9 and 11.
107 |   * Support for RDF collections (rdf:List) using @member attribute.
108 |   * Implemented :expand option to reader, which allows normal use of reader interface without requiring the use of the #expand method.
109 |   * Add caches for popular vocabularies to speed load time.
110 |   * Add :vocabulary_profile as Reader option to allow for use of persistent vocabulary caches.
111 |   * Performance improvements by evaluating debug statements in block only when debug enabled.
112 |   
113 | ### 0.3.5
114 | * Updates to writer necessary for structure-data.org linter.
115 |   * Support for type-specific templates and types matching a regular expression.
116 |   * Allow #find-template to be overridden in subclasses.
117 | * In reader
118 |   * Fix initialization bugs when passed an Nokogiri::XML::Document or Nokogiri::HTML::Document.
119 |   * Fixed bug where @typeof was ignored in the root element.
120 | 
121 | ### 0.3.4.2
122 | * Fix Writer output for multi-valued properties when there is no :property\_values Haml template.
123 | * Simplify templates by using pre-rendered CURIEs.
124 | 
125 | ### 0.3.4.1
126 | * Change built-in profiles to use alias\_method\_chain, as they were being removed from the cache.
127 | * Fixes to Writer template detection with type.
128 | 
129 | ### 0.3.4
130 | * Add writer support for template selection based on subject type.
131 | 
132 | ### 0.3.3.3
133 | * Minor update to rdfa-1-1 profile
134 | 
135 | ### 0.3.3.2
136 | * In Reader:
137 |   * Ensure that encoding is set to utf-8 if not specified.
138 |   * Look for encoding from input and HTML meta tags.
139 |   * Look for content-type from input and HTML meta tags.
140 |   * Retrieve @xmlns, @xml:lang and @lang as attributes when doing HTML parsing.
141 | 
142 | ### 0.3.3.1
143 | * Improve format detection.
144 | * Use HTML parser instead of XML if format is determined to be html4 or html5.
145 | 
146 | ### 0.3.3
147 | * Major update to writer using Haml templates, rather than Nokogiri node creation.
148 | 
149 | ### 0.3.2
150 | * Added RDFa Writer, to perform templated serialization of RDF content to RDFa.
151 |   * Uses Haml to define default and minimal templates for RDFa serialization.
152 |   * Allows templates to be specified on invocation, for arbitrary RDFa serialization.
153 | * Update to pre-LC2 drafts of RDFa
154 | * Add support for cached profiles, and include cached profiles for XML+RDFa and XHTML+RDFa.
155 |   * Profiles are processed left to right
156 |   * Detect 1.0 using @version
157 |   * Automatically load profiles based on host language
158 | 
159 | ### 0.3.1.2
160 | * Assert :html and xhtml as a format types (by creating RDF::RDFa::HTML/XHTML as a sub-class of Format that uses RDFa::Reader/Writer)
161 | * Added :svg format, image/svg+xml and .svg as looks for RDFa parser as well.
162 | 
163 | ### 0.3.1
164 | * Bug fix relating to datatypes in literals being ignored.
165 | * Bug fix parsing non-RDFa profiles to ensure they don't cause processing to terminate (or recurse).
166 | 
167 | ### 0.3.0
168 | * RDF.rb 0.3.0 compatibility updates
169 |   * Remove literal_normalization and qname_hacks, add back uri_hacks (until 0.3.0)
170 |   * URI canonicalization and validation.
171 |   * Added :canonicalize, and :intern options.
172 |   * Change :strict option to :validate.
173 |   * Add check to ensure that predicates are not literals, it's not legal in any RDF variant.
174 |   * Collect prefixes when extracting mappings.
175 | * Added :profile_repository option to RDF::RDFa::Reader.initialize. This MUST be an RDF::Repository and will be used to save profiles that are encountered.
176 |   * Fixme, for now, retrieval should include HTTP headers and perform appropriate HTTP cache control and check for potential updates.
177 | * Update to 2010-10-26 LC version of RDFa Core 1.1
178 |   * Deep processing of XMLLiterals
179 |   * Case sensitive Terms
180 |   * Updated processor graph vocabulary
181 |   * Upgrade for changes to RDFa 1.1 test suite
182 |   * Allow use of xml:base for non-HTML languages
183 |   * XHTML has no default vocabulary.
184 |   * No longer pass vocabularies, prefixes or terms when creating XMLLiterals. Only namespaces derived via xmlns are passed to Literal#typed.
185 | * Literal::XML
186 |   * Add all in-scope namespaces, not just those that seem to be used.
187 | * RSpec 2 compatibility.
188 | 
189 | ### 0.2.2
190 | * Ruby 1.9.2 compatibility
191 | * Added script/parse as command-line option for parsing files.
192 | * Add back support for RDFa 1.0 as well as RDFa 1.1. Parser checks @version to determine which
193 | * Update RDFa processing to WD-rdfa-core-20100803 semantics
194 |   * Added Processor Graph and required output
195 |   * Reverse order of processing profiles
196 |   * Don't process element if any profile fails
197 |   * XMLLiterals must be explicitly specified as @datatype
198 |   * TERMorCURIEorAbsURI requires an absolute URI, not document relative
199 |   * Extract a new default vocabulary from @profile.
200 | 
201 | ### 0.2.1
202 | * Update for RDF 0.2.1
203 | 
204 | ### 0.2.0
205 | * Updates for RDF 0.2.0
206 |   * Use URI#intern instead of URI#new
207 |   * Change use of Graph#predicates and Graph#objects to use as enumerables
208 | 
209 | ### 0.0.3
210 | * Removed internal graph in Reader and implement each_triple & each_statement to perform parsing
211 | 
212 | ### 0.0.2
213 | * Remove dependency on Namespace
214 | * Changed to RDF::RDFa, and moved files accordingly.
215 | * Added vocab definitions for RDA, XHV, XML, XSI and OWL
216 | 
217 | ### 0.0.1
218 | * First port from RdfContext version 0.5.4
219 | 


--------------------------------------------------------------------------------
/lib/rdf/rdfa/reader/nokogiri.rb:
--------------------------------------------------------------------------------
  1 | module RDF::RDFa
  2 |   class Reader < RDF::Reader
  3 |     ##
  4 |     # Nokogiri implementation of an XML parser.
  5 |     #
  6 |     # @see https://nokogiri.org/
  7 |     module Nokogiri
  8 |       ##
  9 |       # Returns the name of the underlying XML library.
 10 |       #
 11 |       # @return [Symbol]
 12 |       def self.library
 13 |         :nokogiri
 14 |       end
 15 | 
 16 |       # Proxy class to implement uniform element accessors
 17 |       class NodeProxy
 18 |         attr_reader :node
 19 |         attr_reader :parent
 20 | 
 21 |         def initialize(node, parent = nil)
 22 |           @node = node
 23 |           @parent = parent
 24 |         end
 25 | 
 26 |         ##
 27 |         # Element language
 28 |         #
 29 |         # From HTML5 3.2.3.3
 30 |         #   If both the lang attribute in no namespace and the lang attribute in the XML namespace are set
 31 |         #   on an element, user agents must use the lang attribute in the XML namespace, and the lang
 32 |         #   attribute in no namespace must be ignored for the purposes of determining the element's
 33 |         #   language.
 34 |         #
 35 |         # @return [String]
 36 |         def language
 37 |           case
 38 |           when @node.attribute_with_ns("lang", "http://www.w3.org/XML/1998/namespace")
 39 |             @node.attribute_with_ns("lang", "http://www.w3.org/XML/1998/namespace")
 40 |           when @node.attribute("xml:lang")
 41 |             @node.attribute("xml:lang").to_s
 42 |           when @node.attribute("lang")
 43 |             @node.attribute("lang").to_s
 44 |           end
 45 |         end
 46 | 
 47 |         ##
 48 |         # Return xml:base on element, if defined
 49 |         #
 50 |         # @return [String]
 51 |         def base
 52 |           @node.attribute_with_ns("base", "http://www.w3.org/XML/1998/namespace") || @node.attribute('xml:base')
 53 |         end
 54 | 
 55 |         def display_path
 56 |           @display_path ||= begin
 57 |             path = []
 58 |             path << parent.display_path if parent
 59 |             path << @node.name
 60 |             case @node
 61 |             when ::Nokogiri::XML::Element then path.join("/")
 62 |             when ::Nokogiri::XML::Attr    then path.join("@")
 63 |             else path.join("?")
 64 |             end
 65 |           end
 66 |         end
 67 | 
 68 |         ##
 69 |         # Return true of all child elements are text
 70 |         #
 71 |         # @return [Array<:text, :element, :attribute>]
 72 |         def text_content?
 73 |           @node.children.all? {|c| c.text?}
 74 |         end
 75 | 
 76 |         ##
 77 |         # Retrieve XMLNS definitions for this element
 78 |         #
 79 |         # @return [Hash{String => String}]
 80 |         def namespaces
 81 |           @node.namespace_definitions.inject({}) {|memo, ns| memo[ns.prefix] = ns.href.to_s; memo }
 82 |         end
 83 | 
 84 |         ##
 85 |         # Children of this node
 86 |         #
 87 |         # @return [NodeSetProxy]
 88 |         def children
 89 |           NodeSetProxy.new(@node.children, self)
 90 |         end
 91 | 
 92 |         # Ancestors of this element, in order
 93 |         def ancestors
 94 |           @ancestors ||= parent ? parent.ancestors + [parent] : []
 95 |         end
 96 | 
 97 |         ##
 98 |         # Inner text of an element. Decode Entities
 99 |         #
100 |         # @return [String]
101 |         #def inner_text
102 |         #  coder = HTMLEntities.new
103 |         #  coder.decode(@node.inner_text)
104 |         #end
105 | 
106 |         def attribute_nodes
107 |           @attribute_nodes ||= NodeSetProxy.new(@node.attribute_nodes, self)
108 |         end
109 | 
110 |         def xpath(*args)
111 |           @node.xpath(*args).map do |n|
112 |             # Get node ancestors
113 |             parent = n.ancestors.reverse.inject(nil) do |p,node|
114 |               NodeProxy.new(node, p)
115 |             end
116 |             NodeProxy.new(n, parent)
117 |           end
118 |         end
119 | 
120 |         ##
121 |         # Proxy for everything else to @node
122 |         def method_missing(method, *args)
123 |           @node.send(method, *args)
124 |         end
125 |       end
126 | 
127 |       ##
128 |       # NodeSet proxy
129 |       class NodeSetProxy
130 |         attr_reader :node_set
131 |         attr_reader :parent
132 | 
133 |         def initialize(node_set, parent)
134 |           @node_set = node_set
135 |           @parent = parent
136 |         end
137 | 
138 |         ##
139 |         # Return a proxy for each child
140 |         #
141 |         # @yield child
142 |         # @yieldparam [NodeProxy]
143 |         def each
144 |           @node_set.each do |c|
145 |             yield NodeProxy.new(c, parent)
146 |           end
147 |         end
148 | 
149 |         ##
150 |         # Proxy for everything else to @node_set
151 |         def method_missing(method, *args)
152 |           @node_set.send(method, *args)
153 |         end
154 |       end
155 | 
156 |       ##
157 |       # Initializes the underlying XML library.
158 |       #
159 |       # @param  [Hash{Symbol => Object}] options
160 |       # @return [void]
161 |       def initialize_xml(input, **options)
162 |         require 'nokogiri' unless defined?(::Nokogiri)
163 |         @doc = case input
164 |         when ::Nokogiri::HTML::Document, ::Nokogiri::XML::Document
165 |           input
166 |         else
167 |           # Try to detect charset from input
168 |           options[:encoding] ||= input.charset if input.respond_to?(:charset)
169 | 
170 |           # Otherwise, default is utf-8
171 |           options[:encoding] ||= 'utf-8'
172 |           options[:encoding] = options[:encoding].to_s if options[:encoding]
173 | 
174 |           case @host_language
175 |           when :html4
176 |             ::Nokogiri::HTML.parse(input, base_uri.to_s, options[:encoding])
177 |           when :html5
178 |             begin
179 |               input = input.read if input.respond_to?(:read)
180 |               ::Nokogiri::HTML5(input.force_encoding(options[:encoding]), max_parse_errors: 1000)
181 |             rescue LoadError, NoMethodError
182 |               ::Nokogiri::HTML.parse(input, base_uri.to_s, options[:encoding])
183 |             end
184 |           else
185 |             ::Nokogiri::XML.parse(input, base_uri.to_s, options[:encoding])
186 |           end
187 |         end
188 |       end
189 | 
190 |       # Determine the host language and/or version from options and the input document
191 |       def detect_host_language_version(input, **options)
192 |         @host_language = options[:host_language] ? options[:host_language].to_sym : nil
193 |         @version = options[:version] ? options[:version].to_sym : nil
194 |         return if @host_language && @version
195 | 
196 |         # Snif version based on input
197 |         case input
198 |         when ::Nokogiri::XML::Document, ::Nokogiri::HTML::Document
199 |           doc_type_string = input.children.detect {|c| c.is_a?(::Nokogiri::XML::DTD)}
200 |           version_attr = input.root && input.root.attribute("version").to_s
201 |           root_element = input.root.name.downcase
202 |           content_type = case
203 |           when root_element == "html" && input.is_a?(::Nokogiri::HTML::Document)
204 |             "text/html"
205 |           when root_element == "html" && input.is_a?(::Nokogiri::XML::Document)
206 |             "application/xhtml+html"
207 |           end
208 |         else
209 |           content_type = input.content_type if input.respond_to?(:content_type)
210 | 
211 |           # Determine from head of document
212 |           head = if input.respond_to?(:read)
213 |             input.rewind
214 |             string = input.read(1000)
215 |             input.rewind
216 |             string.to_s
217 |           else
218 |             input.to_s[0..1000]
219 |           end
220 | 
221 |           doc_type_string = head.match(%r(<!DOCTYPE[^>]*>)m).to_s
222 |           root = head.match(%r(<[^!\?>]*>)m).to_s
223 |           root_element = root.match(%r(^<(\S+)[ >])) ? $1 : ""
224 |           version_attr = root.match(/version\s*=\s*"([^"]+)"/m) ? $1 : ""
225 |           head_element = head.match(%r(<head.*<\/head>)mi)
226 |           head_doc = ::Nokogiri::HTML.parse(head_element.to_s)
227 | 
228 |           # May determine content-type and/or charset from meta
229 |           # Easist way is to parse head into a document and iterate
230 |           # of CSS matches
231 |           head_doc.css("meta").each do |e|
232 |             if e.attr("http-equiv").to_s.downcase == 'content-type'
233 |               content_type, e = e.attr("content").to_s.downcase.split(";")
234 |               options[:encoding] = $1.downcase if e.to_s =~ /charset=([^\s]*)$/i
235 |             elsif e.attr("charset")
236 |               options[:encoding] = e.attr("charset").to_s.downcase
237 |             end
238 |           end
239 |         end
240 | 
241 |         # Already using XML parser, determine from DOCTYPE and/or root element
242 |         @version ||= :"rdfa1.0" if doc_type_string =~ /RDFa 1\.0/
243 |         @version ||= :"rdfa1.0" if version_attr =~ /RDFa 1\.0/
244 |         @version ||= :"rdfa1.1" if version_attr =~ /RDFa 1\.1/
245 |         @version ||= :"rdfa1.1"
246 | 
247 |         @host_language ||= :xhtml1 if @version == :"rdfa1.0" && doc_type_string =~ /html/i
248 | 
249 |         @host_language ||= case content_type
250 |         when "application/xml"  then :xml
251 |         when "image/svg+xml"    then :svg
252 |         when "text/html"
253 |           case doc_type_string
254 |           when /html 4/i        then :html4
255 |           when /xhtml/i         then :xhtml1
256 |           when /html/i          then :html5
257 |           else                       :html5
258 |           end
259 |         when "application/xhtml+xml"
260 |           case doc_type_string
261 |           when /html 4/i        then :html4
262 |           when /xhtml/i         then :xhtml1
263 |           when /html/i          then :xhtml5
264 |           else                       :xhtml5
265 |           end
266 |         else
267 |           case root_element
268 |           when /svg/i           then :svg
269 |           else                       :html5
270 |           end
271 |         end
272 |       end
273 | 
274 |       # Accessor methods to mask native elements & attributes
275 | 
276 |       ##
277 |       # Return proxy for document root
278 |       def root
279 |         @root ||= NodeProxy.new(@doc.root) if @doc && @doc.root
280 |       end
281 | 
282 |       ##
283 |       # Document errors
284 |       def doc_errors
285 |         if @host_language == :html5
286 |           @doc.errors.reject do |e|
287 |             e.to_s =~ %r{(The doctype must be the first token in the document)|(Expected a doctype token)|(Unexpected '\?' where start tag name is expected)}
288 |           end
289 |         else
290 |           @doc.errors.reject {|e| e.to_s =~ /(?:Tag \w+ invalid)|(?:Missing attribute name)/}
291 |         end
292 |       end
293 | 
294 |       ##
295 |       # Find value of document base
296 |       #
297 |       # @param [String] base Existing base from URI or :base_uri
298 |       # @return [String]
299 |       def doc_base(base)
300 |         # find if the document has a base element
301 |         case @host_language
302 |         when :xhtml1, :xhtml5, :html4, :html5
303 |           base_el = @doc.at_css("html>head>base")
304 |           base = base.join(base_el.attribute("href").to_s.split("#").first) if base_el
305 |         else
306 |           xml_base = root.attribute_with_ns("base", "http://www.w3.org/XML/1998/namespace") || root.attribute('xml:base') if root
307 |           base = base.join(xml_base) if xml_base
308 |         end
309 | 
310 |         base
311 |       end
312 |     end
313 |   end
314 | end
315 | 


--------------------------------------------------------------------------------
/lib/rdf/rdfa/reader/rexml.rb:
--------------------------------------------------------------------------------
  1 | require 'htmlentities'
  2 | 
  3 | module RDF::RDFa
  4 |   class Reader < RDF::Reader
  5 |     ##
  6 |     # REXML implementation of an XML parser.
  7 |     #
  8 |     # @see https://www.germane-software.com/software/rexml/
  9 |     module REXML
 10 |       ##
 11 |       # Returns the name of the underlying XML library.
 12 |       #
 13 |       # @return [Symbol]
 14 |       def self.library
 15 |         :rexml
 16 |       end
 17 | 
 18 |       # Proxy class to implement uniform element accessors
 19 |       class NodeProxy
 20 |         attr_reader :node
 21 |         attr_reader :parent
 22 | 
 23 |         def initialize(node, parent = nil)
 24 |           @node = node
 25 |           @parent = parent
 26 |         end
 27 | 
 28 |         ##
 29 |         # Element language
 30 |         #
 31 |         # From HTML5 3.2.3.3
 32 |         #   If both the lang attribute in no namespace and the lang attribute in the XML namespace are set
 33 |         #   on an element, user agents must use the lang attribute in the XML namespace, and the lang
 34 |         #   attribute in no namespace must be ignored for the purposes of determining the element's
 35 |         #   language.
 36 |         #
 37 |         # @return [String]
 38 |         def language
 39 |           case
 40 |           when @node.attribute("lang", "http://www.w3.org/XML/1998/namespace")
 41 |             @node.attribute("lang", "http://www.w3.org/XML/1998/namespace")
 42 |           when @node.attribute("xml:lang")
 43 |             @node.attribute("xml:lang").to_s
 44 |           when @node.attribute("lang")
 45 |             @node.attribute("lang").to_s
 46 |           end
 47 |         end
 48 | 
 49 |         ##
 50 |         # Return xml:base on element, if defined
 51 |         #
 52 |         # @return [String]
 53 |         def base
 54 |           @node.attribute("base", "http://www.w3.org/XML/1998/namespace") || @node.attribute('xml:base')
 55 |         end
 56 | 
 57 |         def display_path
 58 |           @display_path ||= begin
 59 |             path = []
 60 |             path << parent.display_path if parent
 61 |             path << @node.name
 62 |             case @node
 63 |             when ::REXML::Element   then path.join("/")
 64 |             when ::REXML::Attribute then path.join("@")
 65 |             else path.join("?")
 66 |             end
 67 |           end
 68 |         end
 69 | 
 70 |         ##
 71 |         # Return true of all child elements are text
 72 |         #
 73 |         # @return [Array<:text, :element, :attribute>]
 74 |         def text_content?
 75 |           @node.children.all? {|c| c.is_a?(::REXML::Text)}
 76 |         end
 77 | 
 78 |         ##
 79 |         # Retrieve XMLNS definitions for this element
 80 |         #
 81 |         # @return [Hash{String => String}]
 82 |         def namespaces
 83 |           ns_decls = {}
 84 |           @node.attributes.each do |name, attr|
 85 |             next unless name =~ /^xmlns(?:\:(.+))?/
 86 |             ns_decls[$1] = attr
 87 |           end
 88 |           ns_decls
 89 |         end
 90 | 
 91 |         ##
 92 |         # Children of this node
 93 |         #
 94 |         # @return [NodeSetProxy]
 95 |         def children
 96 |           NodeSetProxy.new(@node.children, self)
 97 |         end
 98 | 
 99 |         # Ancestors of this element, in order
100 |         def ancestors
101 |           @ancestors ||= parent ? parent.ancestors + [parent] : []
102 |         end
103 | 
104 |         ##
105 |         # Inner text of an element
106 |         #
107 |         # @see https://apidock.com/ruby/REXML/Element/get_text#743-Get-all-inner-texts
108 |         # @return [String]
109 |         def inner_text
110 |           coder = HTMLEntities.new
111 |           ::REXML::XPath.match(@node,'.//text()').map { |e|
112 |             coder.decode(e)
113 |           }.join
114 |         end
115 | 
116 |         ##
117 |         # Inner text of an element
118 |         #
119 |         # @see https://apidock.com/ruby/REXML/Element/get_text#743-Get-all-inner-texts
120 |         # @return [String]
121 |         def inner_html
122 |           @node.children.map(&:to_s).join
123 |         end
124 | 
125 |         def attribute_nodes
126 |           attrs = @node.attributes.dup.keep_if do |name, attr|
127 |             !name.start_with?('xmlns')
128 |           end
129 |           @attribute_nodes ||= (attrs.empty? ? attrs : NodeSetProxy.new(attrs, self))
130 |         end
131 | 
132 |         ##
133 |         # Node type accessors
134 |         #
135 |         # @return [Boolean]
136 |         def text?
137 |           @node.is_a?(::REXML::Text)
138 |         end
139 | 
140 |         def element?
141 |           @node.is_a?(::REXML::Element)
142 |         end
143 | 
144 |         def blank?
145 |           @node.is_a?(::REXML::Text) && @node.empty?
146 |         end
147 | 
148 |         def to_s; @node.to_s; end
149 | 
150 |         def xpath(*args)
151 |           ::REXML::XPath.match(@node, *args).map do |n|
152 |             NodeProxy.new(n, parent)
153 |           end
154 |         end
155 | 
156 |         def at_xpath(*args)
157 |           xpath(*args).first
158 |         end
159 | 
160 |         # Simple case for &lt;script&gt;
161 |         def css(path)
162 |           xpath("//script[@type]")
163 |         end
164 | 
165 |         ##
166 |         # Proxy for everything else to @node
167 |         def method_missing(method, *args)
168 |           @node.send(method, *args)
169 |         end
170 |       end
171 | 
172 |       ##
173 |       # NodeSet proxy
174 |       class NodeSetProxy
175 |         attr_reader :node_set
176 |         attr_reader :parent
177 | 
178 |         def initialize(node_set, parent)
179 |           @node_set = node_set
180 |           @parent = parent
181 |         end
182 | 
183 |         ##
184 |         # Return a proxy for each child
185 |         #
186 |         # @yield child
187 |         # @yieldparam [NodeProxy]
188 |         def each
189 |           @node_set.each do |c|
190 |             yield NodeProxy.new(c, parent)
191 |           end
192 |         end
193 | 
194 |         ##
195 |         def to_html
196 |           node_set.map(&:to_s).join("")
197 |         end
198 | 
199 |         ##
200 |         # Proxy for everything else to @node_set
201 |         def method_missing(method, *args)
202 |           @node_set.send(method, *args)
203 |         end
204 |       end
205 | 
206 |       ##
207 |       # Initializes the underlying XML library.
208 |       #
209 |       # @param  [Hash{Symbol => Object}] options
210 |       # @return [void]
211 |       def initialize_xml(input, **options)
212 |         require 'rexml/document' unless defined?(::REXML)
213 |         @doc = case input
214 |         when ::REXML::Document
215 |           input
216 |         else
217 |           # Try to detect charset from input
218 |           options[:encoding] ||= input.charset if input.respond_to?(:charset)
219 | 
220 |           # Otherwise, default is utf-8
221 |           options[:encoding] ||= 'utf-8'
222 | 
223 |           # Set xml:base for the document element, if defined
224 |           @base_uri = base_uri ? base_uri.to_s : nil
225 | 
226 |           # Only parse as XML, no HTML mode
227 |           ::REXML::Document.new(input.respond_to?(:read) ? input.read : input.to_s)
228 |         end
229 |       end
230 | 
231 |       # Determine the host language and/or version from options and the input document
232 |       def detect_host_language_version(input, **options)
233 |         @host_language = options[:host_language] ? options[:host_language].to_sym : nil
234 |         @version = options[:version] ? options[:version].to_sym : nil
235 |         return if @host_language && @version
236 | 
237 |         # Snif version based on input
238 |         case input
239 |         when ::REXML::Document
240 |           doc_type_string = input.doctype.to_s
241 |           version_attr = input.root && input.root.attribute("version").to_s
242 |           root_element = input.root.name.downcase
243 |           content_type = "application/xhtml+html" # FIXME: what about other possible XML types?
244 |         else
245 |           content_type = input.content_type if input.respond_to?(:content_type)
246 | 
247 |           # Determine from head of document
248 |           head = if input.respond_to?(:read)
249 |             input.rewind
250 |             string = input.read(1000)
251 |             input.rewind
252 |             string.to_s
253 |           else
254 |             input.to_s[0..1000]
255 |           end
256 | 
257 |           doc_type_string = head.match(%r(<!DOCTYPE[^>]*>)m).to_s
258 |           root = head.match(%r(<[^!\?>]*>)m).to_s
259 |           root_element = root.match(%r(^<(\S+)[ >])) ? $1 : ""
260 |           version_attr = root.match(/version\s*=\s*"([^"]+)"/m) ? $1 : ""
261 |           head_element = head.match(%r(<head.*<\/head>)mi)
262 |           head_doc = ::REXML::Document.new(head_element.to_s)
263 | 
264 |           # May determine content-type and/or charset from meta
265 |           # Easist way is to parse head into a document and iterate
266 |           # of CSS matches
267 |           ::REXML::XPath.each(head_doc, "//meta") do |e|
268 |             if e.attribute("http-equiv").to_s.downcase == 'content-type'
269 |               content_type, e = e.attribute("content").to_s.downcase.split(";")
270 |               options[:encoding] = $1.downcase if e.to_s =~ /charset=([^\s]*)$/i
271 |             elsif e.attribute("charset")
272 |               options[:encoding] = e.attr("charset").to_s.downcase
273 |             end
274 |           end
275 |         end
276 | 
277 |         # Already using XML parser, determine from DOCTYPE and/or root element
278 |         @version ||= :"rdfa1.0" if doc_type_string =~ /RDFa 1\.0/
279 |         @version ||= :"rdfa1.0" if version_attr =~ /RDFa 1\.0/
280 |         @version ||= :"rdfa1.1" if version_attr =~ /RDFa 1\.1/
281 |         @version ||= :"rdfa1.1"
282 | 
283 |         @host_language ||= case content_type
284 |         when "application/xml"  then :xml
285 |         when "image/svg+xml"    then :svg
286 |         when "text/html"
287 |           case doc_type_string
288 |           when /html 4/i        then :html4
289 |           when /xhtml/i         then :xhtml1
290 |           when /html/i          then :html5
291 |           else                       :html5
292 |           end
293 |         when "application/xhtml+xml"
294 |           case doc_type_string
295 |           when /html 4/i        then :html4
296 |           when /xhtml/i         then :xhtml1
297 |           when /html/i          then :xhtml5
298 |           else                       :xhtml5
299 |           end
300 |         else
301 |           case root_element
302 |           when /svg/i           then :svg
303 |           else                       :html5
304 |           end
305 |         end
306 |       end
307 | 
308 |       # Accessor methods to mask native elements & attributes
309 | 
310 |       ##
311 |       # Return proxy for document root
312 |       def root
313 |         @root ||= NodeProxy.new(@doc.root) if @doc && @doc.root
314 |       end
315 | 
316 |       ##
317 |       # Document errors
318 |       def doc_errors
319 |         []
320 |       end
321 | 
322 |       ##
323 |       # Find value of document base
324 |       #
325 |       # @param [String] base Existing base from URI or :base_uri
326 |       # @return [String]
327 |       def doc_base(base)
328 |         # find if the document has a base element
329 |         case @host_language
330 |         when :xhtml1, :xhtml5, :html4, :html5
331 |           base_el = ::REXML::XPath.first(@doc, "/html/head/base") rescue nil
332 |           base = base.join(base_el.attribute("href").to_s.split("#").first) if base_el
333 |         else
334 |           xml_base = root.attribute("base", "http://www.w3.org/XML/1998/namespace") || root.attribute('xml:base') if root
335 |           base = base.join(xml_base) if xml_base
336 |         end
337 | 
338 |         base || @base_uri
339 |       end
340 |     end
341 |   end
342 | end
343 | 


--------------------------------------------------------------------------------
/lib/rdf/rdfa/writer/haml_templates.rb:
--------------------------------------------------------------------------------
  1 | # Default HAML templates used for generating output from the writer
  2 | module RDF::RDFa
  3 |   class Writer
  4 |     # The default set of HAML templates used for RDFa code generation
  5 |    BASE_HAML = {
  6 |      identifier: "base",
  7 |       # Document
  8 |       # Locals: language, title, prefix, base, subjects
  9 |       # Yield: subjects.each
 10 |       doc: %q(
 11 |         !!! XML
 12 |         !!! 5
 13 |         %html{**{xmlns: "http://www.w3.org/1999/xhtml", lang: lang, prefix: prefix}.compact}
 14 |           - if base || title
 15 |             %head
 16 |               - if base
 17 |                 %base{**{href: base}.compact}
 18 |               - if title
 19 |                 %title= title
 20 |           %body
 21 |             - subjects.map do |subject|
 22 |               != yield(subject)
 23 |       ),
 24 | 
 25 |       # Output for non-leaf resources
 26 |       # Note that @about may be omitted for Nodes that are not referenced
 27 |       #
 28 |       # If _rel_ and _resource_ are not nil, the tag will be written relative
 29 |       # to a previous subject. If _element_ is :li, the tag will be written
 30 |       # with <li> instead of <div>.
 31 |       #
 32 |       # Locals: subject, typeof, predicates, rel, element, inlist
 33 |       # Yield: predicates.each
 34 |       subject: %q(
 35 |         - if element == :li
 36 |           %li{**{rel: rel, resource: (about || resource), typeof: typeof, inlist: inlist}.compact}
 37 |             - if typeof
 38 |               %span.type!= typeof
 39 |             - predicates.each do |predicate|
 40 |               != yield(predicate)
 41 |         - else
 42 |           %div{**{rel: rel, resource: (about || resource), typeof: typeof, inlist: inlist}.compact}
 43 |             - if typeof
 44 |               %span.type!= typeof
 45 |             - predicates.each do |predicate|
 46 |               != yield(predicate)
 47 |       ),
 48 | 
 49 |       # Output for single-valued properties
 50 |       # Locals: predicate, object, inlist
 51 |       # Yields: object
 52 |       # If nil is returned, render as a leaf
 53 |       # Otherwise, render result
 54 |       property_value: %q(
 55 |         - if heading_predicates.include?(predicate) && object.literal?
 56 |           %h1{**{property: get_curie(predicate), content: get_content(object), lang: get_lang(object), datatype: get_dt_curie(object), inlist: inlist}.compact}= escape_entities(get_value(object))
 57 |         - else
 58 |           %div.property
 59 |             %span.label
 60 |               = get_predicate_name(predicate)
 61 |             - if res = yield(object)
 62 |               != res
 63 |             - elsif get_curie(object) == 'rdf:nil'
 64 |               %span{rel: get_curie(predicate), inlist: ''}
 65 |             - elsif object.node?
 66 |               %span{**{property: get_curie(predicate), resource: get_curie(object), inlist: inlist}.compact}= get_curie(object)
 67 |             - elsif object.uri?
 68 |               %a{**{property: get_curie(predicate), href: object.to_s, inlist: inlist}.compact}= object.to_s
 69 |             - elsif object.datatype == RDF.XMLLiteral
 70 |               %span{**{property: get_curie(predicate), lang: get_lang(object), datatype: get_dt_curie(object), inlist: inlist}.compact}<!= get_value(object)
 71 |             - else
 72 |               %span{**{property: get_curie(predicate), content: get_content(object), lang: get_lang(object), datatype: get_dt_curie(object), inlist: inlist}.compact}= escape_entities(get_value(object))
 73 |       ),
 74 | 
 75 |       # Output for multi-valued properties
 76 |       # Locals: predicate, :objects, :inlist
 77 |       # Yields: object for leaf resource rendering
 78 |       property_values:  %q(
 79 |         %div.property
 80 |           %span.label
 81 |             = get_predicate_name(predicate)
 82 |           %ul
 83 |             - objects.each do |object|
 84 |               - if res = yield(object)
 85 |                 != res
 86 |               - elsif object.node?
 87 |                 %li{**{property: get_curie(predicate), resource: get_curie(object), inlist: inlist}.compact}= get_curie(object)
 88 |               - elsif object.uri?
 89 |                 %li
 90 |                   %a{**{property: get_curie(predicate), href: object.to_s, inlist: inlist}.compact}= object.to_s
 91 |               - elsif object.datatype == RDF.XMLLiteral
 92 |                 %li{**{property: get_curie(predicate), lang: get_lang(object), datatype: get_curie(object.datatype), inlist: inlist}.compact}<!= get_value(object)
 93 |               - else
 94 |                 %li{**{property: get_curie(predicate), content: get_content(object), lang: get_lang(object), datatype: get_dt_curie(object), inlist: inlist}.compact}= escape_entities(get_value(object))
 95 |       ),
 96 |     }
 97 | 
 98 |     # An alternative, minimal HAML template for RDFa code generation.
 99 |     # This version does not perform recursive object generation and does not attempt
100 |     # to create human readable output.
101 |     MIN_HAML = {
102 |       identifier: "min",
103 |       # Document
104 |       # Locals: language, title, prefix, base, subjects
105 |       # Yield: subjects.each
106 |       doc: %q(
107 |         !!! XML
108 |         !!! 5
109 |         %html{**{xmlns: "http://www.w3.org/1999/xhtml", lang: lang, prefix: prefix}.compact}
110 |           - if base
111 |             %head
112 |               %base{*{href: base}.compact}
113 |           %body
114 |             - subjects.each do |subject|
115 |               != yield(subject)
116 |       ),
117 | 
118 |       # Output for non-leaf resources
119 |       # Note that @about may be omitted for Nodes that are not referenced
120 |       #
121 |       # Locals: about, typeof, predicates, :inlist
122 |       # Yield: predicates.each
123 |       subject: %q(
124 |         %div{**{rel: rel, resource: (about || resource), typeof: typeof}.compact}
125 |           - predicates.each do |predicate|
126 |             != yield(predicate)
127 |       ),
128 | 
129 |       # Output for single-valued properties.
130 |       # This version does not perform a recursive call, and renders all objects as leafs.
131 |       # Locals: predicate, object, inlist
132 |       # Yields: object
133 |       # If nil is returned, render as a leaf
134 |       # Otherwise, render result
135 |       property_value: %q(
136 |       - if res = yield(object)
137 |         != res
138 |       - elsif get_curie(object) == 'rdf:nil'
139 |         %span{rel: get_curie(predicate), inlist: ''}
140 |       - elsif object.node?
141 |         %span{**{property: get_curie(predicate), resource: get_curie(object), inlist: inlist}.compact}= get_curie(object)
142 |       - elsif object.uri?
143 |         %a{**{property: get_curie(predicate), href: object.to_s, inlist: inlist}.compact}= object.to_s
144 |       - elsif object.datatype == RDF.XMLLiteral
145 |         %span{**{property: get_curie(predicate), lang: get_lang(object), datatype: get_dt_curie(object), inlist: inlist}.compact}<!= get_value(object)
146 |       - else
147 |         %span{**{property: get_curie(predicate), content: get_content(object), lang: get_lang(object), datatype: get_dt_curie(object), inlist: inlist}.compact}= escape_entities(get_value(object))
148 |       )
149 |     }
150 | 
151 |     DISTILLER_HAML = {
152 |       identifier: "distiller",
153 |       # Document
154 |       # Locals: language, title, prefix, base, subjects
155 |       # Yield: subjects.each
156 |       doc: %q(
157 |         !!! XML
158 |         !!! 5
159 |         %html{**{xmlns: "http://www.w3.org/1999/xhtml", lang: lang, prefix: prefix}.compact}
160 |           - if base || title
161 |             %head
162 |               - if base
163 |                 %base{href: base}
164 |               - if title
165 |                 %title= title
166 |               %link{rel: "stylesheet", href: "http://rdf.greggkellogg.net/css/distiller.css", type: "text/css"}
167 |               %script{src: "https://ajax.googleapis.com/ajax/libs/jquery/1.5.1/jquery.min.js", type: "text/javascript"}
168 |               %script{src: "http://rdf.greggkellogg.net/js/distiller.js", type: "text/javascript"}
169 |           %body
170 |             - if base
171 |               %p= "RDFa serialization URI base: &lt;#{base}&gt;"
172 |             - subjects.each do |subject|
173 |               != yield(subject)
174 |             %footer
175 |               %p= "Written by <a href='https://rubygems.org/gems/rdf-rdfa'>RDF::RDFa</a> version #{RDF::RDFa::VERSION}"
176 |       ),
177 | 
178 |       # Output for non-leaf resources
179 |       # Note that @about may be omitted for Nodes that are not referenced
180 |       #
181 |       # If _rel_ and _resource_ are not nil, the tag will be written relative
182 |       # to a previous subject. If _element_ is :li, the tag will be written
183 |       # with <li> instead of <div>.
184 |       #
185 |       # Note that @rel and @resource can be used together, or @about and @typeof, but
186 |       # not both.
187 |       #
188 |       # Locals: subject, typeof, predicates, rel, element, inlist
189 |       # Yield: predicates.each
190 |       subject: %q(
191 |         - if element == :li
192 |           %li{**{rel: rel, resource: (about || resource), typeof: typeof, inlist: inlist}.compact}
193 |             - if typeof
194 |               %span.type!= typeof
195 |             %table.properties
196 |               - predicates.each do |predicate|
197 |                 != yield(predicate)
198 |         - elsif rel
199 |           %td{**{rel: rel, resource: (about || resource), typeof: typeof, inlist: inlist}.compact}
200 |             - if typeof
201 |               %span.type!= typeof
202 |             %table.properties
203 |               - predicates.each do |predicate|
204 |                 != yield(predicate)
205 |         - else
206 |           %div{**{resource: (about || resource), typeof: typeof, inlist: inlist}.compact}
207 |             - if typeof
208 |               %span.type!= typeof
209 |             %table.properties
210 |               - predicates.each do |predicate|
211 |                 != yield(predicate)
212 |       ),
213 | 
214 |       # Output for single-valued properties
215 |       # Locals: predicate, object, inlist
216 |       # Yields: object
217 |       # If nil is returned, render as a leaf
218 |       # Otherwise, render result
219 |       property_value: %q(
220 |         - if heading_predicates.include?(predicate) && object.literal?
221 |           %h1{**{property: get_curie(predicate), content: get_content(object), lang: get_lang(object), datatype: get_dt_curie(object), inlist: inlist}.compact}= escape_entities(get_value(object))
222 |         - else
223 |           %tr.property
224 |             %td.label
225 |               = get_predicate_name(predicate)
226 |             - if res = yield(object)
227 |               != res
228 |             - elsif get_curie(object) == 'rdf:nil'
229 |               %td{rel: get_curie(predicate), inlist: ''}= "Empty"
230 |             - elsif object.node?
231 |               %td{**{property: get_curie(predicate), resource: get_curie(object), inlist: inlist}.compact}= get_curie(object)
232 |             - elsif object.uri?
233 |               %td
234 |                 %a{**{property: get_curie(predicate), href: object.to_s, inlist: inlist}.compact}= object.to_s
235 |             - elsif object.datatype == RDF.XMLLiteral
236 |               %td{**{property: get_curie(predicate), lang: get_lang(object), datatype: get_dt_curie(object), inlist: inlist}.compact}<!= get_value(object)
237 |             - else
238 |               %td{**{property: get_curie(predicate), content: get_content(object), lang: get_lang(object), datatype: get_dt_curie(object), inlist: inlist}.compact}= escape_entities(get_value(object))
239 |       ),
240 | 
241 |       # Output for multi-valued properties
242 |       # Locals: predicate, objects, inliste
243 |       # Yields: object for leaf resource rendering
244 |       property_values:  %q(
245 |         %tr.property
246 |           %td.label
247 |             = get_predicate_name(predicate)
248 |           %td
249 |             %ul
250 |               - objects.each do |object|
251 |                 - if res = yield(object)
252 |                   != res
253 |                 - elsif object.node?
254 |                   %li{**{property: get_curie(predicate), resource: get_curie(object), inlist: inlist}.compact}= get_curie(object)
255 |                 - elsif object.uri?
256 |                   %li
257 |                     %a{**{property: get_curie(predicate), href: object.to_s, inlist: inlist}.compact}= object.to_s
258 |                 - elsif object.datatype == RDF.XMLLiteral
259 |                   %li{**{property: get_curie(predicate), lang: get_lang(object), datatype: get_curie(object.datatype), inlist: inlist}.compact}<!= get_value(object)
260 |                 - else
261 |                   %li{**{property: get_curie(predicate), content: get_content(object), lang: get_lang(object), datatype: get_dt_curie(object), inlist: inlist}.compact}= escape_entities(get_value(object))
262 |       ),
263 |     }
264 |     HAML_TEMPLATES = {base: BASE_HAML, min: MIN_HAML, distiller: DISTILLER_HAML}
265 |     DEFAULT_HAML = BASE_HAML
266 |   end
267 | end
268 | 


--------------------------------------------------------------------------------
/example-files/data-view.xhtml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0"?><!--*- nxml -*-->
  2 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  3 |     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  4 | <html xmlns="http://www.w3.org/1999/xhtml">
  5 | <head profile=
  6 | "http://www.w3.org/2003/g/data-view http://purl.org/NET/erdf/profile">
  7 | <meta name="generator" content=
  8 | "HTML Tidy for Linux/x86 (vers 12 April 2005), see www.w3.org" />
  9 | 
 10 |   <title>GRDDL Data Views: RDF expressed in XHTML and XML</title>
 11 |   <link rel="stylesheet" href="style" type="text/css" />
 12 |   <link rel="stylesheet" href="/StyleSheets/base" type=
 13 |   "text/css" />
 14 |   <link rel="schema.dc" href="http://purl.org/dc/elements/1.1/" />
 15 |   <link rel="schema.doap" href="http://usefulinc.com/ns/doap#" />
 16 |   <link rel="schema.foaf" href="http://xmlns.com/foaf/0.1/" />
 17 |   <link rel="schema.grddl" href=
 18 |   "http://www.w3.org/2003/g/data-view#" />
 19 |   <link rel="schema.rddl" href="http://www.rddl.org/purposes#" />
 20 |   <link rel="schema.rdfs" href=
 21 |   "http://www.w3.org/2000/01/rdf-schema#" />
 22 |   <link rel="schema.rdf" href=
 23 |   "http://www.w3.org/1999/02/22-rdf-syntax-ns#" />
 24 |   <link rel="schema.owl" href=
 25 |   "http://www.w3.org/2002/07/owl#" />
 26 |   <link rev="doap-homepage" href="#grddlProject" />
 27 |   <link rel="foaf-maker" href="#grddl-wg" />
 28 | 
 29 |   <!-- more local copy of eRDF transformation, while we work out
 30 |        redirect/base details. -->
 31 |   <link rel="transformation" href="http://www.w3.org/2001/sw/grddl-wg/td/extract-rdf.xsl" />
 32 | 
 33 |   <link href="/People/Berners-Lee/general.css" rel="stylesheet"
 34 |   type="text/css" />
 35 |   <!-- base seems to be necessary for embedded RDF rev links -->
 36 |   <base href="http://www.w3.org/2003/g/data-view" />
 37 | </head>
 38 | 
 39 | <body>
 40 |   <div>
 41 |     <a href="/"><img src="../../Icons/w3c_home" alt="W3C" height=
 42 |     "48" width="72" /></a>
 43 |   </div>
 44 | 
 45 |   <div id="grddlProject">
 46 |     <h1>GRDDL Data Views: Getting Started, Learning More</h1>
 47 | 
 48 |     <p class="doap-shortdesc"><abbr title= "Gleaning Resource
 49 |     Descriptions from Dialects of Languages">GRDDL</abbr> is a
 50 |     technique for <dfn><b>g</b>leaning <b>r</b>esource
 51 |     <b>d</b>escriptions from <b>d</b>ialects of
 52 |     <b>l</b>anguages</dfn>. It's a way of extracting Semantic Web data
 53 |     in <a href="/RDF/">RDF</a> from XML formats (especially XHTML
 54 |     dialects or <a href=
 55 |     "http://www.microformats.org/">microformats</a>) via
 56 |     transformations identified by URIs and typically expressed in
 57 |     XSLT. For full details, see the <a href="#grddl_spec">GRDDL
 58 |     specification</a>.</p>
 59 | 
 60 |     <blockquote>
 61 |       <p class="status"><strong>Note:</strong> The <a
 62 |       href="#grddl_spec">GRDDL specification</a> is a <a
 63 |       href="http://www.w3.org/2005/10/Process-20051014/tr.html#RecsPR">W3C
 64 |       Recommendation</a>. W3C welcomes <a
 65 |       href="http://lists.w3.org/Archives/Public/public-grddl-comments/">comments
 66 |       by email</a>, especially comments that reflect implementation
 67 |       experience.</p>
 68 |     </blockquote>
 69 | 
 70 |     <p>To use GRDDL:</p>
 71 | 
 72 |     <ol type="A">
 73 |       <li>If you're using a dialect (<a href=
 74 |       "http://purl.org/stuff/hdoap/profile">hDoap</a>, <a href=
 75 |       "http://www.w3.org/2000/08/w3c-synd/">Site Summaries</a>,
 76 |       <a href="http://purl.org/NET/erdf/profile">Embedded RDF</a>,
 77 |       <a href="#moreDialects">etc.</a>) that already has an
 78 |       established GRDDL-compatible profile:
 79 | 
 80 |         <ol>
 81 |           <li>Add the profile attribute:
 82 |             <pre class="example">
 83 | &lt;html xmlns="http://www.w3.org/1999/xhtml"&gt;
 84 |   &lt;head <span style=
 85 | "font-weight: bold">profile="http://purl.org/stuff/hdoap/profile"</span>&gt;
 86 |     &lt;title&gt;My Project&lt;/title&gt;
 87 |   &lt;/head&gt;
 88 |     ...
 89 | &lt;/html&gt;
 90 | </pre>
 91 |           </li>
 92 | 
 93 |           <li id="check">Look at the data expressed as RDF using
 94 |           the <a href="../11/rdf-in-xhtml-demo">online GRDDL demo
 95 |           service</a>, and if you like, check its output with the
 96 |           <a href="/RDF/Validator/">W3C RDF Validation service</a>,
 97 |           or with a tool more customized for your data, like the
 98 |           <a href="http://xml.mfd-consult.dk/foaf/explorer/">FOAF
 99 |           explorer</a>.</li>
100 | 
101 |           <li>Let the GRDDL Working Group know how you're using GRDDL
102 |           by sending mail to the <a rel="doap.mailing-list" href=
103 |           "http://lists.w3.org/Archives/Public/public-grddl-comments/"
104 |           >public-grddl-comments</a> list.</li>
105 |         </ol>
106 |       </li>
107 | 
108 |       <li>If you're using an XHTML dialect (<a href=
109 |       "http://www.ietf.org/rfc/rfc2731.txt">Dublin Core
110 |       encoding</a>, <a href="http://geourl.org/add.html">GeoURL
111 |       markup</a>, <a href="#moreDialects">etc.</a>) that has an
112 |       existing transformation (<a href=
113 |       "/2000/06/dc-extract/dc-extract.xsl">dc-extract.xsl</a>,
114 |       <a href=
115 |       "../12/rdf-in-xhtml-xslts/grokGeoURL.xsl">grokGeoURL.xsl</a>)
116 |       ...
117 | 
118 |         <ol>
119 |           <li>Make links from your XHTML data to the
120 |           transformation, using the <a href=
121 |           "#transformation">transformation</a> link type:
122 |             <pre class="example">
123 | &lt;html xmlns="http://www.w3.org/1999/xhtml"&gt;
124 |   &lt;head profile="http://www.w3.org/2003/g/data-view"&gt;
125 |     &lt;title&gt;Some Document&lt;/title&gt;
126 |     &lt;link rel="<strong>transformation</strong>"
127 |        href="<strong>http://www.w3.org/2000/06/dc-extract/dc-extract.xsl</strong>" /&gt;
128 |     &lt;meta name="DC.Subject"
129 |        content="ADAM; Simple Search; Index+; prototype" /&gt;
130 |     ...
131 |   &lt;/head&gt;
132 |   ...
133 | &lt;/html&gt;
134 | </pre>
135 |           </li>
136 | 
137 |           <li>Reference the GRDDL profile to make it clear what
138 |           that transformation link type means:
139 |             <pre class="example">
140 | &lt;html xmlns="http://www.w3.org/1999/xhtml"&gt;
141 |   &lt;head <strong>profile="http://www.w3.org/2003/g/data-view"</strong>&gt;
142 |     &lt;title&gt;Some Document&lt;/title&gt;
143 |     ...
144 | </pre>
145 |           </li>
146 | 
147 |           <li>Check your data and let us know how it went as
148 |           <a href="#check">above</a>.</li>
149 |         </ol>
150 |       </li>
151 |     </ol>
152 | 
153 |     <h3>Questions?</h3>
154 | 
155 |     <ul class="q-and-a">
156 |       <li>Q: How about more complete examples?
157 | 
158 |         <p>
159 | 	  The <a href="http://www.w3.org/TR/grddl-primer/">GRDDL primer</a>
160 | 	  gives a number of examples in detail.
161 | 	  Also, a <a href=
162 |         "../12/rdf-in-xhtml-xslts/complete-example.html">home page
163 |         for Joe Lambda</a> shows DC, geoURL, RSS as above plus
164 |         markup for <a href="http://www.foaf-project.org/">FOAF</a>
165 |         (using <a href=
166 |         "../12/rdf-in-xhtml-xslts/grokFOAF.xsl">grokFOAF.xsl</a>)
167 |         and <a href="http://creativecommons.org/licenses/">Creative
168 |         Commons Licenses</a> (using <a href=
169 |         "../12/rdf-in-xhtml-xslts/grokCC.xsl">grokCC.xsl</a>) that
170 |         you can probably figure out if you view source.</p>
171 |       </li>
172 | 
173 |       <li id="moreDialects">Q: Where can I find out about existing
174 |       'ways' rather than duplicate similar work?
175 | 
176 |         <p>A: The <a href=
177 |         "http://esw.w3.org/topic/CustomRdfDialects">CustomRdfDialects</a>
178 |         wiki topic provides an informal directory of existing
179 |         conventions.</p>
180 |       </li>
181 |     </ul>
182 | 
183 |     <p>If you just want to use GRDDL, that's all you need to know.
184 |     If you're curious to learn more, read on...</p>
185 |   </div>
186 | 
187 |   <div>
188 |     <h2 id="vocab_ref">GRDDL Namespace and Metadata Profile Reference</h2>
189 | 
190 | <p>This document, <a rel="ns-claim" href="http://www.w3.org/2003/g/data-view">http://www.w3.org/2003/g/data-view</a>,
191 | is a metadata profile in the sense of the HTML specification, in section 
192 | <a href="/TR/1999/REC-html401-19991224/struct/global.html#h-7.4.4.3">7.4.4.3 Meta data profiles</a>.</p>
193 | 
194 | <p>The following term is introduced here as an XHTML link relationship
195 | name and RDF property name:</p>
196 | 
197 | <ul>
198 |   <li id="transformation" class="-rdf-Property">
199 |     <tt class="rdfs-label">transformation</tt>: <span
200 |     class="rdfs-comment">relates a source document to a
201 |     transformation, usually represented in <a
202 |     href="/TR/xslt">XSLT</a>, that relates the source document syntax
203 |     to the RDF graph syntax</span>.  domain: <a rel="rdfs-domain"
204 |     href="#RootNode">RootNode</a>; range: <a
205 |     rel="rdfs-range" href="#Transformation">Transformation</a>
206 |   </li>
207 | 
208 | </ul>
209 | 
210 | <p>The following terms are introduced here as RDF properties:</p>
211 | 
212 | <ul>
213 |   <li id="namespaceTransformation" class="-rdf-Property">
214 |     <tt class="rdfs-label">namespaceTransformation</tt>: <span
215 |     class="rdfs-comment">relates a namespace to a transformation for
216 |     all documents in that namespace</span>.  range: <a
217 |     rel="rdfs-range" href="#Transformation">Transformation</a>
218 |   </li>
219 | 
220 |   <li id="profileTransformation" class="-rdf-Property">
221 |     <tt class="rdfs-label">profileTransformation</tt>: <span
222 |     class="rdfs-comment">relates a profile document to a
223 |     transformation for all documents bearing that profile</span>.
224 |     range: <a rel="rdfs-range"
225 |     href="#Transformation">Transformation</a>
226 |   </li>
227 | 
228 |   <li id="result" class="-rdf-Property">
229 |     <tt class="rdfs-label">result</tt>: <span class="rdfs-comment">an
230 |     RDF graph obtained from an information resource by directly
231 |     parsing a representation in the standard RDF/XML syntax or
232 |     indirectly by parsing some other dialect using a transformation
233 |     nominated by the document</span>. domain: <a rel="rdfs-domain"
234 |     href="#InformationResource">InformationResource</a>; range: <a
235 |     rel="rdfs-range" href="#RDFGraph">RDFGraph</a>
236 |   </li>
237 | 
238 |   <li id="transformationProperty" class="-owl-FunctionalProperty">
239 |     <tt class="rdfs-label">transformationProperty</tt> <span
240 |     class="rdfs-comment">relates a transformation to the algorithm
241 |     specified by the property that computes an RDF graph from an XML
242 |     document node</span> domain: <a rel="rdfs-domain"
243 |     href="#Transformation">Transformation</a> range: <a
244 |     rel="rdfs-range"
245 |     href="#TransformationProperty">TransformationProperty</a>
246 |   </li>
247 |   <li id="Transformation" class="-rdfs-Class">
248 |     <tt class="rdfs-label">Transformation</tt> <span
249 |     class="rdfs-comment">an <a rel="rdfs-subClassOf"
250 |     href="#InformationResource">InformationResource</a> that specifies
251 |     a transformation from a set of XML documents to RDF graphs</span>
252 |     Each Transformation has at least one <a rel="owl-onProperty"
253 |     href="#transformationProperty">transformationProperty</a> that is
254 |     a <a rel="owl-someValuesFrom"
255 |     href="#TransformationProperty">TransformationProperty</a>.
256 |   </li>
257 | 
258 |   <li id="TransformationProperty" class="-rdfs-Class">
259 |     <tt class="rdfs-label">TransformationProperty</tt>
260 |     <span class="rdfs-comment">a <a rel="rdfs-subClassOf"
261 |     href="http://www.w3.org/2002/07/owl#FunctionalProperty"
262 |     >FunctionalProperty</a> that relates
263 |     <a href="#RootNode">XML document root nodes</a> to
264 |     <a href="#RDFGraph">RDF graphs</a></span>
265 |   </li>
266 | 
267 | </ul>
268 | 
269 | <p>The following terms are bound to concepts from existing standards:</p>
270 | 
271 | <ul>
272 |   <li id="RootNode" class="-rdfs-Class">
273 |     <tt class="rdfs-label">RootNode</tt> <span
274 |     class="rdfs-comment">the root of the tree in the XPath data
275 |     model</span>, per <a rel="rdfs-isDefinedBy"
276 |     href="http://www.w3.org/TR/1999/REC-xpath-19991116#root-node">section
277 |     5.1 Root Node in <cite>XML Path Language (XPath) Version
278 |     1.0</cite></a>
279 |   </li>
280 | 
281 |   <li id="RDFGraph" class="-rdfs-Class">
282 |     <tt class="rdfs-label">RDFGraph</tt> <span class="rdfs-comment">a
283 |     set of RDF triples</span>, per <a rel="rdfs-isDefinedBy"
284 |     href="http://www.w3.org/TR/2004/REC-rdf-concepts-20040210/#dfn-rdf-graph">definition
285 |     in <cite>Resource Description Framework (RDF): Concepts and
286 |     Abstract Syntax</cite></a>
287 | 
288 |   </li>
289 | 
290 |   <li id="InformationResource" class="-rdfs-Class">
291 |     <tt class="rdfs-label">InformationResource</tt>
292 |     <span class="rdfs-comment">A resource which has the property that all of its essential characteristics can be conveyed in a message</span>, per <a rel="rdfs-isDefinedBy" href="http://www.w3.org/TR/2004/REC-webarch-20041215/#def-information-resource">definition in <cite>Architecture of the World Wide Web, Volume One</cite></a>
293 |   </li>
294 | 
295 | </ul>
296 | 
297 |     <p>We provide a <a href="../11/rdf-in-xhtml-processor">sample
298 |     GRDDL/XHTML implementation</a>, and a more complete <a href=
299 |     "rdf-in-xml-processor">sample GRDDL implementation</a> and a
300 |     technical specification, <a href=
301 |     "http://www.w3.org/TR/grddl/">Gleaning Resource Descriptions
302 |     from Dialects of Languages (GRDDL)</a>, as a specification.</p>
303 | 
304 |     <h2>References</h2>
305 | 
306 |     <ul>
307 |       <li id="grddl_spec">
308 |         <a href="http://www.w3.org/TR/grddl/" rel=
309 |         "rddl.normative-reference"><cite class="dc-title">Gleaning
310 |         Resource Descriptions from Dialects of Languages
311 |         (GRDDL)</cite>, W3C Recommendation <abbr
312 |         title="2007-09-11" class="dc.date">11 September 2007</abbr></a>
313 |       </li>
314 | 
315 |       <li><a href="/TR/xslt" rel= "rddl.normative-reference"><cite
316 |       class="dc-title">XSL Transformations (XSLT) Version
317 |       1.0</cite> W3C Recommendation <abbr title="1999-11-16"
318 |       class="dc.date">16 November 1999</abbr></a>
319 |       </li>
320 | 
321 |       <li><a href="http://www.w3.org/TR/rdf-concepts/" rel=
322 |       "rddl.normative-reference"><cite class="dc.title">Resource
323 |       Description Framework (RDF): Concepts and Abstract
324 |       Syntax</cite>, W3C Recommendation <abbr title="2004-02-10"
325 |       class="dc.date">10 February 2004</abbr></a></li>
326 | 
327 |       <li id="WEBARCH">
328 | 	<a href= "http://www.w3.org/TR/webarch/" ><cite
329 | 	class="dc.title">Architecture of the World Wide Web, Volume
330 | 	One</cite>, W3C Recommendation, <abbr class="dc.date"
331 | 	title="2004-12-15">15 December 2004</abbr></a>
332 |       </li>
333 | 
334 |     </ul>
335 | 
336 |     <div>
337 |       <h2>Acknowledgements and Colophon</h2>
338 | 
339 |       <p>This document uses <a href=
340 |       "http://purl.org/NET/erdf/profile">Embedded RDF</a> to encode
341 |       <a href="http://usefulinc.com/doap">Description of a Project
342 |       (DOAP)</a> data as well as RDF Schema data and one or two
343 |       <a href="http://www.tbray.org/tag/rddl4.html">RDDL</a>
344 |       properties. We have moved away from the RDDL syntax
345 |       itself.</p>
346 | 
347 |       <p>This document was inspired by the <a href=
348 |       "http://gmpg.org/xfn/join">XFN getting started page</a>.
349 |       Previous versions used <a href= "http://gmpg.org/xmdp/">XMDP</a>
350 |       (with <a href=
351 |       "http://www.w3.org/2003/12/rdf-in-xhtml-xslts/grokXMDP.xsl"
352 |       >grokXMDP.xsl</a>), but in documenting domains and ranges of
353 |       properties, maintaining the XMDP convention of ids on the
354 |       <tt>dt</tt> rather than the <tt>dd</tt> element were too awkward
355 |       to maintain.</p>
356 | 
357 |     </div>
358 |   </div>
359 |   <hr />
360 | 
361 |   <address>
362 |     <span id="danc"><a rel="foaf-homepage" class="foaf-name" href=
363 |     "/People/Connolly/">Dan Connolly</a></span>
364 |     for <span id="grddl-wg"><a rel="foaf-homepage" href="http://www.w3.org/2001/sw-grddl-wg/">the GRDDL Working Group</a></span><br />
365 |     <small>$Revision: 1.47 $ of $Date: 2007/10/31 02:59:16 $ <!-- -->
366 |      by $Author: connolly $</small>
367 |   </address>
368 | </body>
369 | </html>
370 | 


--------------------------------------------------------------------------------
/spec/expansion_spec.rb:
--------------------------------------------------------------------------------
  1 | require_relative 'spec_helper'
  2 | 
  3 | class EXP < RDF::Vocabulary("http://example.org/vocab#")
  4 |   property :name, subPropertyOf: "foaf:name", type: "rdf:Property"
  5 |   property :namee, "owl:equivalentProperty" => "foaf:name", type: "rdf:Property"
  6 |   term     :Person, subClassOf: "foaf:Person", type: "rdfs:Class"
  7 |   term     :Persone, "owl:equivalentClass" => "foaf:Person", type: "rdfs:Class"
  8 | end
  9 | 
 10 | # Class for abstract testing of module
 11 | class ExpansionTester
 12 |   include RDF::RDFa::Expansion
 13 |   include RDF::Enumerable
 14 |   include RDF::Util::Logger
 15 | 
 16 |   attr_reader :id, :repo, :inputDocument, :outputDocument, :options
 17 |   attr_accessor :format
 18 | 
 19 |   def initialize(name)
 20 |     @id = name
 21 |     @repo = RDF::Repository.new
 22 |     @options = {logger: RDF::Spec.logger}
 23 | 
 24 |     super()
 25 |   end
 26 | 
 27 |   def graph
 28 |     g = RDF::Graph.new
 29 |     @repo.each {|st| g << st if st.graph_name.nil? }
 30 |     g
 31 |   end
 32 | 
 33 |   def each_statement(&block); @repo.each_statement(&block); end
 34 | 
 35 |   def expectedResults; RDF::Literal::Boolean.new(true); end
 36 | 
 37 |   def add_debug(node, message = "", &block)
 38 |     log_debug(node, message, &block)
 39 |   end
 40 | 
 41 |   def add_warning(node, message, process_class = RDF::RDFA.Warning)
 42 |     log_warn(node, message, &block)
 43 |   end
 44 | 
 45 |   def load(elements)
 46 |     @options = {}
 47 |     result = nil
 48 |     elements.each do |context, value|
 49 |       case context
 50 |       when :default
 51 |         @inputDocument = value
 52 |         @repo << parse(value)
 53 |       when :query
 54 |         @outputDocument = value
 55 |         result = %(
 56 |           PREFIX dc:  <#{RDF::Vocab::DC.to_uri}>
 57 |           PREFIX foaf:<#{RDF::Vocab::FOAF.to_uri}>
 58 |           PREFIX owl: <#{RDF::OWL.to_uri}>
 59 |           PREFIX rdf: <#{RDF.to_uri}>
 60 |           PREFIX rdfa:<#{RDF::RDFA.to_uri}>
 61 |           PREFIX rdfs:<#{RDF::RDFS.to_uri}>
 62 |           PREFIX xsd: <#{RDF::XSD.to_uri}>
 63 |           PREFIX exp: <#{EXP.to_uri}>
 64 |           PREFIX :    <#{EXP.to_uri}>
 65 |           ASK WHERE {#{value}}
 66 |         )
 67 |       end
 68 |     end
 69 | 
 70 |     result
 71 |   end
 72 | 
 73 |   def parse(ttl)
 74 |     RDF::Graph.new << RDF::Turtle::Reader.new(ttl, prefixes: {
 75 |       dc:   RDF::Vocab::DC.to_uri,
 76 |       foaf: RDF::Vocab::FOAF.to_uri,
 77 |       owl:  RDF::OWL.to_uri,
 78 |       rdf:  RDF.to_uri,
 79 |       rdfa: RDF::RDFA.to_uri,
 80 |       rdfs: RDF::RDFS.to_uri,
 81 |       xsd:  RDF::XSD.to_uri,
 82 |       exp:  EXP.to_uri,
 83 |       nil   => EXP.to_uri,
 84 |     })
 85 |   end
 86 | end
 87 | 
 88 | describe RDF::RDFa::Expansion do
 89 |   let(:logger) {RDF::Spec.logger}
 90 | 
 91 |   describe :entailment do
 92 |     {
 93 |       "empty"   => {
 94 |         default: %q(),
 95 |         query: %q()
 96 |       },
 97 |       "simple"   => {
 98 |         default: %q(:a a rdfs:Class .),
 99 |         query: %q(
100 |           :a a rdfs:Class .
101 |         )
102 |       },
103 |       "prp-spo1"   => {
104 |         default: %q(<http://example/#me> :name "Gregg Kellogg" .),
105 |         query: %q(
106 |           <http://example/#me> :name "Gregg Kellogg"; foaf:name "Gregg Kellogg" .
107 |         )
108 |       },
109 |       "prp-eqp1"   => {
110 |         default: %q(<http://example/#me> :namee "Gregg Kellogg" .),
111 |         query: %q(
112 |           <http://example/#me> :namee "Gregg Kellogg"; foaf:name "Gregg Kellogg" .
113 |         )
114 |       },
115 |       "prp-eqp2"   => {
116 |         default: %q(<http://example/#me> foaf:name "Gregg Kellogg" .),
117 |         query: %q(
118 |           <http://example/#me> :namee "Gregg Kellogg"; foaf:name "Gregg Kellogg" .
119 |         )
120 |       },
121 |       "cax-sco"   => {
122 |         default: %q(<http://example/#me> a :Person .),
123 |         query: %q(
124 |           <http://example/#me> a :Person, foaf:Person .
125 |         )
126 |       },
127 |       "cax-eqc1"   => {
128 |         default: %q(<http://example/#me> a :Persone .),
129 |         query: %q(
130 |           <http://example/#me> a :Persone, foaf:Person .
131 |         )
132 |       },
133 |       "cax-eqc2"   => {
134 |         default: %q(<http://example/#me> a foaf:Person .),
135 |         query: %q(
136 |           <http://example/#me> a foaf:Person, :Persone .
137 |         )
138 |       },
139 |     }.each do |test, elements|
140 |       it test do
141 |         mt = ExpansionTester.new(test)
142 |         query = mt.load(elements)
143 |         mt.send(:entailment, mt.repo, [EXP])
144 |         expect(mt.graph).to pass_query(query, mt)
145 |       end
146 |     end
147 |   end
148 | 
149 |   describe :expand do
150 |     {
151 |       "simple"   => {
152 |         default: %q(<http://example/document> rdfa:usesVocabulary exp: .),
153 |         "http://example.org/vocab#" => %q(
154 |           exp:Person owl:equivalentClass foaf:Person .
155 |         ),
156 |         query: %q(<http://example/document> rdfa:usesVocabulary exp: .)
157 |       },
158 |       "prp-spo1"   => {
159 |         default: %q(
160 |           <http://example/document> rdfa:usesVocabulary exp: .
161 |           <http://example/#me> exp:name "Gregg Kellogg" .
162 |         ),
163 |         "http://example.org/vocab#" => %q(
164 |           exp:name rdfs:subPropertyOf foaf:name .
165 |         ),
166 |         query: %q(
167 |           <http://example/document> rdfa:usesVocabulary exp: .
168 |           <http://example/#me> exp:name "Gregg Kellogg";
169 |             foaf:name "Gregg Kellogg" .
170 |         )
171 |       },
172 |       "prp-eqp1"   => {
173 |         default: %q(
174 |           <http://example/document> rdfa:usesVocabulary exp: .
175 |           <http://example/#me> exp:name "Gregg Kellogg" .
176 |         ),
177 |         "http://example.org/vocab#" => %q(
178 |           exp:namee owl:equivalentProperty foaf:name .
179 |         ),
180 |         query: %q(
181 |           <http://example/document> rdfa:usesVocabulary exp: .
182 |           <http://example/#me> exp:namee "Gregg Kellogg";
183 |             foaf:name "Gregg Kellogg" .
184 |         )
185 |       },
186 |       "prp-eqp2"   => {
187 |         default: %q(
188 |           <http://example/document> rdfa:usesVocabulary exp: .
189 |           <http://example/#me> foaf:name "Gregg Kellogg" .
190 |         ),
191 |         "http://example.org/vocab#" => %q(
192 |           exp:name owl:equivalentProperty foaf:name .
193 |         ),
194 |         query: %q(
195 |           <http://example/document> rdfa:usesVocabulary exp: .
196 |           <http://example/#me> exp:namee "Gregg Kellogg";
197 |             foaf:name "Gregg Kellogg" .
198 |         )
199 |       },
200 |       "cax-sco"   => {
201 |         default: %q(
202 |           <http://example/document> rdfa:usesVocabulary exp: .
203 |           <http://example/#me> a exp:Person .
204 |         ),
205 |         "http://example.org/vocab#" => %q(
206 |           exp:Person rdfs:subClassOf foaf:Person .
207 |         ),
208 |         query: %q(
209 |           <http://example/document> rdfa:usesVocabulary exp: .
210 |           <http://example/#me> a exp:Person, foaf:Person .
211 |         )
212 |       },
213 |       "cax-eqc1"   => {
214 |         default: %q(
215 |           <http://example/document> rdfa:usesVocabulary exp: .
216 |           <http://example/#me> a exp:Persone .
217 |         ),
218 |         "http://example.org/vocab#" => %q(
219 |           exp:Person owl:equivalentClass foaf:Person .
220 |         ),
221 |         query: %q(
222 |           <http://example/document> rdfa:usesVocabulary exp: .
223 |           <http://example/#me> a exp:Persone, foaf:Person .
224 |         )
225 |       },
226 |       "cax-eqc2"   => {
227 |         default: %q(
228 |           <http://example/document> rdfa:usesVocabulary exp: .
229 |           <http://example/#me> a foaf:Person .
230 |         ),
231 |         "http://example.org/vocab#" => %q(
232 |           exp:Person owl:equivalentClass foaf:Person .
233 |         ),
234 |         query: %q(
235 |           <http://example/document> rdfa:usesVocabulary exp: .
236 |           <http://example/#me> a exp:Persone, foaf:Person .
237 |         )
238 |       }
239 |     }.each do |test, elements|
240 |       it test do
241 |         mt = ExpansionTester.new(test)
242 |         query = mt.load(elements)
243 |         mt.expand(mt.repo)
244 |         expect(mt.graph).to pass_query(query, mt)
245 |       end
246 |     end
247 |   end
248 | 
249 |   describe :copy_properties do
250 |     {
251 |       "simple" => {
252 |         default: %q(
253 |           <http://example/> rdfa:copy _:ref .
254 |           _:ref a rdfa:Pattern; rdf:value "Pattern" .
255 |         ),
256 |         query: %q(<http://example/> rdf:value "Pattern" .)
257 |       },
258 |       "chaining ref" => {
259 |         default: %q(
260 |           <http://example/> rdfa:copy _:ref .
261 |           _:ref a rdfa:Pattern;
262 |             rdf:value "Pattern";
263 |             rdfa:copy _:ref2 .
264 |           _:ref2 a rdfa:Pattern;
265 |           rdf:value "Pattern2" .
266 |         ),
267 |         query: %q(<http://example/> rdf:value "Pattern", "Pattern2" .)
268 |       }
269 |     }.each do |test, elements|
270 |       it test do
271 |         mt = ExpansionTester.new(test)
272 |         query = mt.load(elements)
273 |         mt.copy_properties(mt.repo)
274 |         expect(mt.graph).to pass_query(query, mt)
275 |       end
276 |     end
277 |   end
278 | 
279 |   context "with empty graph" do
280 |     it "returns an empty graph" do
281 |       rdfa = %q(<http></http>)
282 |       expect(parse(rdfa)).to be_equivalent_graph("", logger: logger)
283 |     end
284 |   end
285 | 
286 |   context "with graph not referencing vocabularies" do
287 |     it "returns unexpanded input" do
288 |       rdfa = %(
289 |         <html prefix="doap: http://usefulinc.com/ns/doap#">
290 |           <body about="http://example/" typeof="doap:Project">
291 |             <p>Project description for <span property="doap:name">RDF::RDFa</span>.</p>
292 |             <dl>
293 |               <dt>Creator</dt><dd>
294 |                 <a href="http://greggkellogg.net/foaf#me"
295 |                    rel="dc:creator">
296 |                    Gregg Kellogg
297 |                 </a>
298 |               </dd>
299 |             </dl>
300 |           </body>
301 |         </html>
302 |       )
303 |       query = %(
304 |         PREFIX doap: <http://usefulinc.com/ns/doap#>
305 |         PREFIX dc:   <http://purl.org/dc/terms/>
306 | 
307 |         ASK WHERE {
308 |           <http://example/> a doap:Project;
309 |             doap:name "RDF::RDFa";
310 |             dc:creator <http://greggkellogg.net/foaf#me> .
311 |         }
312 |       )
313 |       expect(parse(rdfa)).to pass_query(query, logger: logger)
314 |     end
315 |   end
316 | 
317 |   context "with @vocab" do
318 |     it "returns unexpanded input", pending: "vocabulary change?" do
319 |       rdfa = %(
320 |         <html vocab="http://usefulinc.com/ns/doap#">
321 |           <body about="http://example/" typeof="Project">
322 |             <p>Project description for <span property="name">RDF::RDFa</span>.</p>
323 |             <dl>
324 |               <dt>Creator</dt><dd>
325 |                 <a href="http://greggkellogg.net/foaf#me"
326 |                    rel="dc:creator">
327 |                    Gregg Kellogg
328 |                 </a>
329 |               </dd>
330 |             </dl>
331 |           </body>
332 |         </html>
333 |       )
334 |       query = %(
335 |         PREFIX doap: <http://usefulinc.com/ns/doap#>
336 |         PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
337 |         PREFIX wn:   <http://xmlns.com/wordnet/1.6/>
338 |         PREFIX foaf: <http://xmlns.com/foaf/0.1/>
339 |         PREFIX rdfa: <http://www.w3.org/ns/rdfa#>
340 |         PREFIX dc:   <http://purl.org/dc/terms/>
341 | 
342 |         ASK WHERE {
343 |           <http://example/> a doap:Project, wn:Project, foaf:Project;
344 |             rdfa:usesVocabulary <http://usefulinc.com/ns/doap#>;
345 |             doap:name "RDF::RDFa";
346 |             rdfs:label "RDF::RDFa";
347 |             dc:creator <http://greggkellogg.net/foaf#me> .
348 |         }
349 |       )
350 |       expect(parse(rdfa)).to pass_query(query, logger: logger)
351 |     end
352 | 
353 |     context "http://rdfa.info/vocabs/rdfa-test#" do
354 |       it "is not a default vocabulary" do
355 |         expect(RDF::Vocabulary.find("http://rdfa.info/vocabs/rdfa-test#")).to be_nil
356 |       end
357 | 
358 |       it "loads vocabulary when expanding" do
359 |         parse %(
360 |           <body prefix="rdfatest: http://rdfa.info/vocabs/rdfa-test#" vocab="http://rdfa.info/vocabs/rdfa-test#">
361 |             Using the property <code property="subProp" resource="rdfatest:subProp">subProp</code>
362 |             should cause a triple with <code>baseProp</code> to be added.
363 |           </body>
364 |         )
365 |         v = RDF::Vocabulary.find("http://rdfa.info/vocabs/rdfa-test#")
366 |         expect(v).not_to be_nil
367 |       end
368 |     end
369 |   end
370 | 
371 |   context "rdfa:Pattern" do
372 |     {
373 |       "to single id" =>
374 |       [
375 |         %q(
376 |           <div>
377 |             <div typeof="schema:Person">
378 |               <link property="rdfa:copy" resource="_:a"/>
379 |             </div>
380 |             <p resource="_:a" typeof="rdfa:Pattern">Name: <span property="schema:name">Amanda</span></p>
381 |           </div>
382 |         ),
383 |         %q(
384 |           PREFIX schema: <http://schema.org/>
385 |           ASK WHERE {[a schema:Person; schema:name "Amanda"]}
386 |         )
387 |       ],
388 |       "to generate listed property values" =>
389 |       [
390 |         %q(
391 |         <div>
392 |           <div typeof="schema:Person">
393 |             <p>My name is <span property="schema:name">Gregg</span></p>
394 |             <link property="rdfa:copy" resource="_:surname"/>
395 |           </div>
396 |           <p resource="_:surname" typeof="rdfa:Pattern">My name is <span property="schema:name">Kellogg</span></p>
397 |         </div>
398 |         ),
399 |         %q(
400 |           PREFIX schema: <http://schema.org/>
401 |           ASK WHERE {[ a schema:Person; schema:name "Gregg", "Kellogg"]}
402 |         )
403 |       ],
404 |       "to single id with different types" =>
405 |       [
406 |         %q(
407 |           <div>
408 |             <div typeof="schema:Person">
409 |               <link property="rdfa:copy" resource="_:a"/>
410 |             </div>
411 |             <div typeof="foaf:Person">
412 |               <link property="rdfa:copy" resource="_:a"/>
413 |             </div>
414 |             <p resource="_:a" typeof="rdfa:Pattern">Name: <span property="schema:name foaf:name">Amanda</span></p>
415 |           </div>
416 |         ),
417 |         %q(
418 |           PREFIX foaf: <http://xmlns.com/foaf/0.1/>
419 |           PREFIX schema: <http://schema.org/>
420 |           ASK WHERE{
421 |             [ a schema:Person; schema:name "Amanda"; foaf:name "Amanda"] .
422 |             [ a foaf:Person; schema:name "Amanda"; foaf:name "Amanda"] .
423 |           }
424 |         )
425 |       ],
426 |       "to multiple prototypes" =>
427 |       [
428 |         %q(
429 |           <div>
430 |             <div typeof="schema:Person">
431 |               <link property="rdfa:copy" resource="_:a"/>
432 |               <link property="rdfa:copy" resource="_:b"/>
433 |             </div>
434 |             <p resource="_:a" typeof="rdfa:Pattern">Name: <span property="schema:name">Amanda</span></p>
435 |             <p resource="_:b" typeof="rdfa:Pattern"><span property="schema:band">Jazz Band</span></p>
436 |           </div>
437 |         ),
438 |         %q(
439 |           PREFIX schema: <http://schema.org/>
440 |           ASK WHERE{
441 |             [ a schema:Person;
442 |               schema:name "Amanda";
443 |               schema:band "Jazz Band";
444 |             ]
445 |           }
446 |         )
447 |       ],
448 |       "with chaining" =>
449 |       [
450 |         %q(
451 |           <div>
452 |             <div typeof="schema:Person">
453 |               <link property="rdfa:copy" resource="_:a"/>
454 |               <link property="rdfa:copy" resource="_:b"/>
455 |             </div>
456 |             <p resource="_:a" typeof="rdfa:Pattern">Name: <span property="schema:name">Amanda</span></p>
457 |             <div resource="_:b" typeof="rdfa:Pattern">
458 |               <div property="schema:band" typeof=" schema:MusicGroup">
459 |                 <link property="rdfa:copy" resource="_:c"/>
460 |               </div>
461 |             </div>
462 |             <div resource="_:c" typeof="rdfa:Pattern">
463 |              <p>Band: <span property="schema:name">Jazz Band</span></p>
464 |              <p>Size: <span property="schema:size">12</span> players</p>
465 |             </div>
466 |           </div>
467 |         ),
468 |         %q(
469 |           PREFIX schema: <http://schema.org/>
470 |           ASK WHERE{
471 |             [ a schema:Person;
472 |               schema:name "Amanda" ;
473 |               schema:band [
474 |                 a schema:MusicGroup;
475 |                 schema:name "Jazz Band";
476 |                 schema:size "12"
477 |               ]
478 |             ]
479 |           }
480 |         )
481 |       ],
482 |       "shared" =>
483 |       [
484 |         %q(
485 |           <div>
486 |             <div typeof=""><link property="rdfa:copy" resource="_:a"/></div>
487 |             <div typeof=""><link property="rdfa:copy" resource="_:a"/></div>
488 |             <div resource="_:a" typeof="rdfa:Pattern">
489 |               <div property="schema:refers-to" typeof="">
490 |                 <span property="schema:name">Amanda</span>
491 |               </div>
492 |             </div>
493 |           </div>
494 |         ),
495 |         %q(
496 |           PREFIX schema: <http://schema.org/>
497 |           ASK WHERE{
498 |             [ schema:refers-to ?a ] .
499 |             [ schema:refers-to ?a ] .
500 |             ?a schema:name "Amanda" .
501 |           }
502 |         )
503 | 
504 |       ],
505 |     }.each do |title, (input, query)|
506 |       it title do
507 |         expect(parse(input)).to pass_query(query,
508 |           base_uri: "http://example.com/",
509 |           logger: logger)
510 |       end
511 |     end
512 |   end
513 | 
514 |   def parse(input, **options)
515 |     RDF::Graph.new << RDF::RDFa::Reader.new(input, logger: logger, vocab_expansion: true, **options)
516 |   end
517 | end
518 | 


--------------------------------------------------------------------------------
/example-files/core.ttl:
--------------------------------------------------------------------------------
  1 | @base <http://example.com> .
  2 | @prefix bibo: <http://purl.org/ontology/bibo/> .
  3 | @prefix dcterms: <http://purl.org/dc/terms/> .
  4 | @prefix foaf: <http://xmlns.com/foaf/0.1/> .
  5 | @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
  6 | @prefix xhv: <http://www.w3.org/1999/xhtml/vocab#> .
  7 | @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
  8 | 
  9 | <> a bibo:Document;
 10 |    dcterms:title "RDFa Core 1.1";
 11 |    dcterms:abstract """Abstract
 12 |       The current Web is primarily made up of an enormous number of documents
 13 |         that have been created using HTML. These documents contain significant
 14 |         amounts of structured data, which is largely unavailable to tools and
 15 |         applications. When publishers can express this data more completely, and
 16 |         when tools can read it, a new world of user functionality becomes
 17 |         available, letting users transfer structured data between applications
 18 |         and web sites, and allowing browsing applications to improve the user
 19 |         experience: an event on a web page can be directly imported into a
 20 |         user's desktop calendar; a license on a document can be detected so that
 21 |         users can be informed of their rights automatically; a photo's creator,
 22 |         camera setting information, resolution, location and topic can be
 23 |         published as easily as the original photo itself, enabling structured
 24 |         search and sharing.
 25 |       RDFa Core is a specification for attributes to express structured data
 26 |         in any markup language. The embedded data already available in the
 27 |         markup language (e.g., HTML) can often be reused by the RDFa markup, so
 28 |         that publishers don't need to repeat significant data in the document
 29 |         content. The underlying abstract representation is RDF [RDF-PRIMER],
 30 |         which lets publishers build their own vocabulary, extend others, and
 31 |         evolve their vocabulary with maximal interoperability over time. The
 32 |         expressed structure is closely tied to the data, so that rendered data
 33 |         can be copied and pasted along with its relevant structure.
 34 |       The rules for interpreting the data are generic, so that there is no
 35 |         need for different rules for different formats; this allows authors and
 36 |         publishers of data to define their own formats without having to update
 37 |         software, register formats via a central authority, or worry that two
 38 |         formats may interfere with each other.
 39 |       RDFa shares some of the same goals with microformats [MICROFORMATS].
 40 |         Whereas microformats specify both a syntax for embedding structured data
 41 |         into HTML documents and a vocabulary of specific terms for each
 42 |         microformat, RDFa specifies only a syntax and relies on independent
 43 |         specification of terms (often called vocabularies or taxonomies) by
 44 |         others. RDFa allows terms from multiple independently-developed
 45 |         vocabularies to be freely intermixed and is designed such that the
 46 |         language can be parsed without knowledge of the specific vocabulary
 47 |         being used. 
 48 |       This document is a detailed syntax specification for RDFa, aimed at:
 49 |       
 50 |         those looking to create an RDFa Processor, and who therefore need a
 51 |           detailed description of the parsing rules;
 52 |         those looking to integrate RDFa into a new markup language;
 53 |         those looking to recommend the use of RDFa within their
 54 |           organization, and who would like to create some guidelines for their
 55 |           users;
 56 |         anyone familiar with RDF, and who wants to understand more about
 57 |           what is happening 'under the hood', when an RDFa Processor runs.
 58 |       
 59 |        For those looking for an introduction to the use of RDFa and some
 60 |         real-world examples, please consult the [RDFA-PRIMER].
 61 |       
 62 |         How to Read this Document
 63 |         First, if you are not familiar with either RDFa or RDF, and
 64 |           simply want to add RDFa to your documents, then you may find the RDFa
 65 |           Primer [RDFA-PRIMER] to be a better introduction.
 66 |         If you are already familiar with RDFa, and you want to examine the
 67 |           processing rules — perhaps to create an RDFa Processor — then you'll
 68 |           find the Processing Model section of most
 69 |           interest. It contains an overview of each of the processing steps,
 70 |           followed by more detailed sections, one for each rule.
 71 |         If you are not familiar with RDFa, but you are familiar
 72 |           with RDF, then you might find reading the Syntax
 73 | 
 74 |             Overview useful, before looking at the Processing
 75 | 
 76 |             Model since it gives a range of examples of markup that use
 77 |           RDFa. Seeing some examples first should make reading the processing
 78 |           rules easier.
 79 |         If you are not familiar with RDF, then you might want to take a look
 80 |           at the section on RDF Terminology
 81 |           before trying to do too much with RDFa. Although RDFa is designed to
 82 |           be easy to author — and authors don't need to understand RDF to use it
 83 |           — anyone writing applications that consume RDFa will need to
 84 |           understand RDF. There is a lot of material about RDF on the web, and a
 85 |           growing range of tools that support RDFa. This document only contains
 86 |           enough background on RDF to make the goals of RDFa more clear.
 87 |         RDFa is a way of expressing RDF-style
 88 |           relationships using simple attributes in existing markup languages
 89 |           such as HTML. RDF is fully internationalized, and permits the use of
 90 |           Internationalized Resource Identifiers, or IRIs. You will see the term
 91 |           'IRI' used throughout this specification. Even if you are not familiar
 92 |           with the term IRI, you probably have seen the term 'URI' or 'URL'.
 93 |           IRIs are an extension of URIs that permits the use of characters
 94 |           outside those of plain ASCII. RDF allows the use of these characters,
 95 |           and so does RDFa. This specification has been careful to use the
 96 |           correct term, IRI, to make it clear that this is the case.
 97 |           Even though this specification exclusively
 98 |           references IRIs, it is possible that a Host Language will
 99 |           restrict the syntax for its attributes to a subset of IRIs
100 |           (e.g., @href in HTML5).  Regardless of
101 |           validation constraints in Host Languages, an RDFa Processor
102 |           is capable of processing IRIs.
103 |       
104 |     """;
105 |    dcterms:issued "2012-05-08T05:00:00+0000"^^xsd:dateTime;
106 |    dcterms:language "en";
107 |    dcterms:publisher [ a foaf:Organization;
108 |      foaf:homepage <http://www.w3.org/>;
109 |      foaf:name "World Wide Web Consortium"];
110 |    dcterms:references <http://www.w3.org/TR/1999/REC-html401-19991224>,
111 |      <http://microformats.org>,
112 |      <http://www.w3.org/2001/tag/doc/qnameids-2004-03-17>,
113 |      <http://www.w3.org/TR/2004/REC-rdf-concepts-20040210>,
114 |      <http://www.w3.org/TR/2004/REC-rdf-primer-20040210/>,
115 |      <http://www.w3.org/TR/1999/REC-rdf-syntax-19990222>,
116 |      <http://www.w3.org/TR/2004/REC-rdf-testcases-20040210>,
117 |      <http://www.w3.org/TR/2011/WD-rdfa-primer-20111208>,
118 |      <http://www.w3.org/TR/2008/REC-rdfa-syntax-20081014>,
119 |      <http://standards.iso.org/ittf/PubliclyAvailableStandards/c052348_ISO_IEC_19757-2_2008(E).zip>,
120 |      <http://www.megginson.com/downloads/SAX/>,
121 |      <http://www.w3.org/TeamSubmission/turtle/>,
122 |      <http://www.w3.org/TR/2011/WD-widgets-uri-20110927>,
123 |      <http://www.w3.org/TR/2001/REC-xhtml11-20010531>,
124 |      <http://www.w3.org/TR/2002/REC-xml-exc-c14n-20020718/>,
125 |      <http://www.w3.org/TR/2008/REC-xml-20081126/>,
126 |      <http://www.w3.org/TR/2012/REC-xmlschema11-1-20120405/>;
127 |    dcterms:replaces <http://www.w3.org/TR/2012/REC-rdfa-core-20120607/>;
128 |    dcterms:requires <http://www.w3.org/TR/2009/REC-owl2-overview-20091027/>,
129 |      <http://www.w3.org/TR/2009/REC-owl2-profiles-20091027/>,
130 |      <http://www.w3.org/TR/2009/REC-owl2-rdf-based-semantics-20091027/>,
131 |      <http://www.w3.org/TR/2004/REC-rdf-mt-20040210>,
132 |      <http://www.w3.org/TR/2004/REC-rdf-syntax-grammar-20040210>,
133 |      <http://www.ietf.org/rfc/rfc2119.txt>,
134 |      <http://www.ietf.org/rfc/rfc3987.txt>,
135 |      <http://www.w3.org/TR/2012/PR-xhtml-rdfa-20120508/>,
136 |      <http://www.w3.org/TR/2009/REC-xml-names-20091208/>,
137 |      <http://www.w3.org/TR/2006/REC-xml-20060816/>,
138 |      <http://www.w3.org/TR/2012/REC-xmlschema11-2-20120405/>;
139 |    bibo:chapter <#abstract>,
140 |      <#sotd>,
141 |      <#toc>,
142 |      <#s_motivation>,
143 |      <#s_Syntax_overview>,
144 |      <#s_rdfterminology>,
145 |      <#conformance>,
146 |      <#s_syntax>,
147 |      <#s_curies>,
148 |      <#s_model>,
149 |      <#s_rdfaindetail>,
150 |      <#s_initialcontexts>,
151 |      <#s_vocab_expansion>,
152 |      <#s_datatypes>,
153 |      <#vocabulary>,
154 |      <#a_history>,
155 |      <#a_acks>,
156 |      <#references>;
157 |    bibo:editor ([ a foaf:Person;
158 |        foaf:mbox <mailto:ben@adida.net>;
159 |        foaf:name "Ben Adida"] [ a foaf:Person;
160 |        foaf:mbox <mailto:mark.birbeck@webBackplane.com>;
161 |        foaf:name "Mark Birbeck"] [ a foaf:Person;
162 |        foaf:homepage <http://blog.halindrome.com>;
163 |        foaf:mbox <mailto:shane@aptest.com>;
164 |        foaf:name "Shane McCarron"] [ a foaf:Person;
165 |        foaf:homepage <http://www.w3.org/People/Ivan/>;
166 |        foaf:mbox <mailto:ivan@w3.org>;
167 |        foaf:name "Ivan Herman"]);
168 |    bibo:subtitle "Syntax and processing rules for embedding RDF through attributes";
169 |    xhv:license <http://www.w3.org/Consortium/Legal/ipr-notice#Copyright>;
170 |    xhv:stylesheet <chrome-extension://cpngackimfmofbokmjmljamhdncknpmg/style.css>,
171 |      <http://www.w3.org/StyleSheets/TR/W3C-PR> .
172 | 
173 | <#web-service-output-graph-preference> bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2010-07-01#resolution_1> .
174 | 
175 | <#T-IRI-reference> a bibo:Chapter .
176 | 
177 | <#a-description-of-rdfa-in-rdf-terms> a bibo:Chapter .
178 | 
179 | <#a_acks> a bibo:Chapter .
180 | 
181 | <#a_history> a bibo:Chapter;
182 |    bibo:chapter <#major-differences-with-rdfa-syntax-1.0> .
183 | 
184 | <#abstract> a bibo:Chapter;
185 |    bibo:chapter <#how-to-read-this-document> .
186 | 
187 | <#accessing-the-processor-graph> a bibo:Chapter;
188 |    bibo:issue [ a bibo:Issue;
189 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2010-07-01#resolution_1>],
190 |      [ a bibo:Issue] .
191 | 
192 | <#attribute_roles> a bibo:Chapter .
193 | 
194 | <#chaining-with--property-and--typeof> a bibo:Chapter .
195 | 
196 | <#changing-the-evaluation-context> a bibo:Chapter;
197 |    bibo:chapter <#setting-the-current-subject> .
198 | 
199 | <#compact-uri-expressions> a bibo:Chapter .
200 | 
201 | <#conformance> a bibo:Chapter;
202 |    bibo:chapter <#processorconf>,
203 |      <#hostlangconf>,
204 |      <#xmlrdfaconformance> .
205 | 
206 | <#determining-the-subject-with-neither--about-nor--typeof> a bibo:Chapter;
207 |    bibo:chapter <#inheriting-subject-from--resource>,
208 |      <#inheriting-an-anonymous-subject> .
209 | 
210 | <#evaluation-context> a bibo:Chapter .
211 | 
212 | <#examples> a bibo:Chapter .
213 | 
214 | <#general-use-of-curies-in-attributes> a bibo:Chapter .
215 | 
216 | <#graphs> a bibo:Chapter .
217 | 
218 | <#hostlangconf> a bibo:Chapter .
219 | 
220 | <#how-to-read-this-document> a bibo:Chapter .
221 | 
222 | <#incomplete-triples> a bibo:Chapter .
223 | 
224 | <#informative-references> a bibo:Chapter .
225 | 
226 | <#inheriting-an-anonymous-subject> a bibo:Chapter .
227 | 
228 | <#inheriting-subject-from--resource> a bibo:Chapter .
229 | 
230 | <#iri-object-resolution> a bibo:Chapter;
231 |    bibo:chapter <#using--resource-to-set-the-object>,
232 |      <#using--href-or--src-to-set-the-subject>,
233 |      <#incomplete-triples> .
234 | 
235 | <#language-tags> a bibo:Chapter .
236 | 
237 | <#list-generation> a bibo:Chapter .
238 | 
239 | <#major-differences-with-rdfa-syntax-1.0> a bibo:Chapter .
240 | 
241 | <#markup-fragments-and-rdfa> a bibo:Chapter .
242 | 
243 | <#normative-references> a bibo:Chapter .
244 | 
245 | <#object-resolution> a bibo:Chapter;
246 |    bibo:chapter <#object-resolution-for-the--property-attribute>,
247 |      <#iri-object-resolution> .
248 | 
249 | <#object-resolution-for-the--property-attribute> a bibo:Chapter;
250 |    bibo:chapter <#plain-literals-1>,
251 |      <#typed-literals-1>,
252 |      <#s-xml-literals> .
253 | 
254 | <#overview> a bibo:Chapter .
255 | 
256 | <#plain-literals> a bibo:Chapter .
257 | 
258 | <#plain-literals-1> a bibo:Chapter;
259 |    bibo:chapter <#language-tags> .
260 | 
261 | <#processor-graph-reporting> a bibo:Chapter .
262 | 
263 | <#processor-graph-terms> a bibo:Chapter .
264 | 
265 | <#processor-status> a bibo:Chapter;
266 |    bibo:chapter <#accessing-the-processor-graph>,
267 |      <#processor-graph-terms>;
268 |    bibo:issue [ a bibo:Issue;
269 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2010-07-15#resolution_1>] .
270 | 
271 | <#processorconf> a bibo:Chapter .
272 | 
273 | <#rdfa-attributes> a bibo:Chapter .
274 | 
275 | <#references> a bibo:Chapter;
276 |    bibo:chapter <#normative-references>,
277 |      <#informative-references> .
278 | 
279 | <#s-xml-literals> a bibo:Chapter .
280 | 
281 | <#s_Completing_Incomplete_Triples> a bibo:Chapter .
282 | 
283 | <#s_Syntax_overview> a bibo:Chapter;
284 |    bibo:chapter <#rdfa-attributes>,
285 |      <#examples> .
286 | 
287 | <#s_blankNodes> a bibo:Chapter;
288 |    bibo:issue [ a bibo:Issue;
289 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2010-10-21#resolution_3>] .
290 | 
291 | <#s_chaining> a bibo:Chapter .
292 | 
293 | <#s_curieprocessing> a bibo:Chapter;
294 |    bibo:chapter <#scoping-of-prefix-mappings>,
295 |      <#general-use-of-curies-in-attributes>,
296 |      <#s_terms>,
297 |      <#use-of-curies-in-specific-attributes>,
298 |      <#s_blankNodes>;
299 |    bibo:issue [ a bibo:Issue;
300 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2010-07-01#resolution_3>],
301 |      [ a bibo:Issue;
302 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2010-05-20#resolution_2>] .
303 | 
304 | <#s_curies> a bibo:Chapter;
305 |    bibo:chapter <#why-curies-and-not-qnames> .
306 | 
307 | <#s_datatypes> a bibo:Chapter;
308 |    bibo:chapter <#xml-schema-definition>,
309 |      <#xml-dtd-definition> .
310 | 
311 | <#s_expansion_control> a bibo:Chapter;
312 |    bibo:chapter <#s_vocab_guidelines> .
313 | 
314 | <#s_initialcontexts> a bibo:Chapter;
315 |    bibo:issue [ a bibo:Issue;
316 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2010-10-21#resolution_2>],
317 |      [ a bibo:Issue;
318 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2010-10-21#resolution_2>] .
319 | 
320 | <#s_model> a bibo:Chapter;
321 |    bibo:chapter <#overview>,
322 |      <#evaluation-context>,
323 |      <#s_chaining>,
324 |      <#s_curieprocessing>,
325 |      <#s_sequence>,
326 |      <#processor-status>,
327 |      <#vocabulary-expansion> .
328 | 
329 | <#s_motivation> a bibo:Chapter .
330 | 
331 | <#s_rdfaindetail> a bibo:Chapter;
332 |    bibo:chapter <#changing-the-evaluation-context>,
333 |      <#s_Completing_Incomplete_Triples>,
334 |      <#object-resolution>,
335 |      <#list-generation> .
336 | 
337 | <#s_rdfterminology> a bibo:Chapter;
338 |    bibo:chapter <#statements>,
339 |      <#triples>,
340 |      <#T-IRI-reference>,
341 |      <#plain-literals>,
342 |      <#typed-literals>,
343 |      <#turtle>,
344 |      <#graphs>,
345 |      <#compact-uri-expressions>,
346 |      <#markup-fragments-and-rdfa>,
347 |      <#a-description-of-rdfa-in-rdf-terms> .
348 | 
349 | <#s_sequence> a bibo:Chapter;
350 |    bibo:issue [ a bibo:Issue;
351 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2010-07-22#resolution_2>],
352 |      [ a bibo:Issue;
353 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2010-07-22#resolution_2>],
354 |      [ a bibo:Issue;
355 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2010-07-22#resolution_2>],
356 |      [ a bibo:Issue;
357 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2011-01-13#ISSUE__2d_62__3a____40_prefix_processing_order>,
358 |        <http://www.w3.org/2010/02/rdfa/meetings/2011-02-14#resolution_3>,
359 |        <http://www.w3.org/2010/02/rdfa/meetings/2010-05-13#resolution_1>],
360 |      [ a bibo:Issue;
361 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2010-05-13#resolution_3>],
362 |      [ a bibo:Issue;
363 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2011-11-10#resolution_2>],
364 |      [ a bibo:Issue;
365 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2011-11-10#resolution_2>],
366 |      [ a bibo:Issue;
367 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2011-11-10#resolution_2>],
368 |      [ a bibo:Issue;
369 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2011-11-10#resolution_2>],
370 |      [ a bibo:Issue],
371 |      [ a bibo:Issue;
372 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2010-06-17#resolution_2>;
373 |      bibo:issue [ a bibo:Issue;
374 |        bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2011-01-13#ISSUE__2d_60__3a__XMLLiteral_context_preservation>]],
375 |      [ a bibo:Issue;
376 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2011-11-10#resolution_2>],
377 |      [ a bibo:Issue;
378 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2011-11-10#resolution_2>],
379 |      [ a bibo:Issue;
380 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2011-11-10#resolution_2>],
381 |      [ a bibo:Issue;
382 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2010-05-13#resolution_2>] .
383 | 
384 | <#s_syntax> a bibo:Chapter;
385 |    bibo:chapter <#attribute_roles>,
386 |      <#white_space> .
387 | 
388 | <#s_terms> a bibo:Chapter .
389 | 
390 | <#s_vocab_entailment> a bibo:Chapter .
391 | 
392 | <#s_vocab_expansion> a bibo:Chapter;
393 |    bibo:chapter <#s_vocab_expansion_details>,
394 |      <#s_expansion_control> .
395 | 
396 | <#s_vocab_expansion_details> a bibo:Chapter;
397 |    bibo:chapter <#s_vocab_entailment> .
398 | 
399 | <#s_vocab_guidelines> a bibo:Chapter .
400 | 
401 | <#scoping-of-prefix-mappings> a bibo:Chapter .
402 | 
403 | <#setting-the-current-subject> a bibo:Chapter;
404 |    bibo:chapter <#the-current-document>,
405 |      <#using--about>,
406 |      <#typing-resources-with--typeof>,
407 |      <#determining-the-subject-with-neither--about-nor--typeof> .
408 | 
409 | <#sotd> a bibo:Chapter .
410 | 
411 | <#statements> a bibo:Chapter .
412 | 
413 | <#term-prefix-definitions-vocabulary> a bibo:Chapter .
414 | 
415 | <#the-current-document> a bibo:Chapter .
416 | 
417 | <#toc> a bibo:Chapter .
418 | 
419 | <#triples> a bibo:Chapter .
420 | 
421 | <#turtle> a bibo:Chapter .
422 | 
423 | <#typed-literals> a bibo:Chapter .
424 | 
425 | <#typed-literals-1> a bibo:Chapter .
426 | 
427 | <#typing-resources-with--typeof> a bibo:Chapter;
428 |    bibo:chapter <#chaining-with--property-and--typeof> .
429 | 
430 | <#use-of-curies-in-specific-attributes> a bibo:Chapter .
431 | 
432 | <#using--about> a bibo:Chapter .
433 | 
434 | <#using--href-or--src-to-set-the-subject> a bibo:Chapter .
435 | 
436 | <#using--resource-to-set-the-object> a bibo:Chapter .
437 | 
438 | <#vocabulary> a bibo:Chapter;
439 |    bibo:chapter <#term-prefix-definitions-vocabulary>,
440 |      <#processor-graph-reporting>,
441 |      <#vocabulary-relationship> .
442 | 
443 | <#vocabulary-expansion> a bibo:Chapter .
444 | 
445 | <#vocabulary-relationship> a bibo:Chapter .
446 | 
447 | <#white_space> a bibo:Chapter;
448 |    bibo:issue [ a bibo:Issue;
449 |      bibo:affirmedBy <http://www.w3.org/2010/02/rdfa/meetings/2010-05-20#resolution_1>] .
450 | 
451 | <#why-curies-and-not-qnames> a bibo:Chapter .
452 | 
453 | <#xml-dtd-definition> a bibo:Chapter .
454 | 
455 | <#xml-schema-definition> a bibo:Chapter .
456 | 
457 | <#xmlrdfaconformance> a bibo:Chapter .
458 | 


--------------------------------------------------------------------------------