rdf-tabular 0.1.3.1 → 0.2.0
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/README.md +4 -3
- data/VERSION +1 -1
- data/etc/README +4 -0
- data/etc/csvw.jsonld +1 -1
- data/etc/earl.html +10544 -0
- data/etc/earl.jsonld +17068 -0
- data/etc/earl.ttl +7114 -0
- data/etc/template.haml +205 -0
- data/etc/well-known +4 -0
- data/lib/rdf/tabular.rb +10 -4
- data/lib/rdf/tabular/format.rb +11 -7
- data/lib/rdf/tabular/metadata.rb +761 -314
- data/lib/rdf/tabular/reader.rb +276 -144
- data/spec/format_spec.rb +11 -8
- data/spec/matchers.rb +4 -4
- data/spec/metadata_spec.rb +120 -36
- data/spec/reader_spec.rb +56 -18
- data/spec/spec_helper.rb +10 -2
- data/spec/suite_helper.rb +35 -18
- data/spec/suite_spec.rb +26 -24
- metadata +15 -3
data/etc/template.haml
ADDED
|
@@ -0,0 +1,205 @@
|
|
|
1
|
+
-# This template is used for generating a rollup EARL report. It expects to be
|
|
2
|
+
-# called with a single _tests_ local with the following structure
|
|
3
|
+
- require 'cgi'
|
|
4
|
+
- require 'digest'
|
|
5
|
+
|
|
6
|
+
!!! 5
|
|
7
|
+
%html{:prefix => "earl: http://www.w3.org/ns/earl# doap: http://usefulinc.com/ns/doap# mf: http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#"}
|
|
8
|
+
- subjects = tests['testSubjects']
|
|
9
|
+
%head
|
|
10
|
+
%meta{"http-equiv" => "Content-Type", :content => "text/html;charset=utf-8"}
|
|
11
|
+
%meta{name: "viewport", content: "width=device-width, initial-scale=1.0"}
|
|
12
|
+
%link{rel: "stylesheet", type: "text/css", href: "https://www.w3.org/StyleSheets/TR/base"}
|
|
13
|
+
%title
|
|
14
|
+
= tests['name']
|
|
15
|
+
Implementation Report
|
|
16
|
+
:css
|
|
17
|
+
span[property='dc:description'] { display: none; }
|
|
18
|
+
td.PASS { color: green; }
|
|
19
|
+
td.FAIL { color: red; }
|
|
20
|
+
table.report {
|
|
21
|
+
border-width: 1px;
|
|
22
|
+
border-spacing: 2px;
|
|
23
|
+
border-style: outset;
|
|
24
|
+
border-color: gray;
|
|
25
|
+
border-collapse: separate;
|
|
26
|
+
background-color: white;
|
|
27
|
+
}
|
|
28
|
+
table.report th {
|
|
29
|
+
border-width: 1px;
|
|
30
|
+
padding: 1px;
|
|
31
|
+
border-style: inset;
|
|
32
|
+
border-color: gray;
|
|
33
|
+
background-color: white;
|
|
34
|
+
-moz-border-radius: ;
|
|
35
|
+
}
|
|
36
|
+
table.report td {
|
|
37
|
+
border-width: 1px;
|
|
38
|
+
padding: 1px;
|
|
39
|
+
border-style: inset;
|
|
40
|
+
border-color: gray;
|
|
41
|
+
background-color: white;
|
|
42
|
+
-moz-border-radius: ;
|
|
43
|
+
}
|
|
44
|
+
tr.summary {font-weight: bold;}
|
|
45
|
+
td.passed-all {color: green;}
|
|
46
|
+
td.passed-most {color: darkorange;}
|
|
47
|
+
td.passed-some {color: red;}
|
|
48
|
+
td.passed-none {color: gray;}
|
|
49
|
+
em.rfc2119 {
|
|
50
|
+
text-transform: lowercase;
|
|
51
|
+
font-variant: small-caps;
|
|
52
|
+
font-style: normal;
|
|
53
|
+
color: #900;
|
|
54
|
+
}
|
|
55
|
+
a.testlink {
|
|
56
|
+
color: inherit;
|
|
57
|
+
text-decoration: none;
|
|
58
|
+
}
|
|
59
|
+
a.testlink:hover {
|
|
60
|
+
text-decoration: underline;
|
|
61
|
+
}
|
|
62
|
+
%body
|
|
63
|
+
- subject_refs = {}
|
|
64
|
+
- tests['entries'].each {|m| m['title'] ||= m['description']}
|
|
65
|
+
%section{:about => tests['@id'], typeof: Array(tests['@type']).join(" ")}
|
|
66
|
+
%h2
|
|
67
|
+
Ruby rdf-tabular gem test results
|
|
68
|
+
%p
|
|
69
|
+
This document reports conformance for for the following specifications:
|
|
70
|
+
%ul
|
|
71
|
+
%li
|
|
72
|
+
%a{property: "doap:name", href: "http://www.w3.org/TR/tabular-data-model/"}="MetaModel for Tabular Data and Metadata on the Web"
|
|
73
|
+
%li
|
|
74
|
+
%a{property: "doap:name", href: "http://www.w3.org/TR/tabular-metadata/"}="Metadata Vocabulary for Tabular Data"
|
|
75
|
+
%li
|
|
76
|
+
%a{property: "doap:name", href: "http://www.w3.org/TR/csv2rdf/"}="Generating RDF from Tabular Data on the Web"
|
|
77
|
+
%li
|
|
78
|
+
%a{property: "doap:name", href: "http://www.w3.org/TR/csv2json/"}="Generating JSON from Tabular Data on the Web"
|
|
79
|
+
%p
|
|
80
|
+
This report is also available in
|
|
81
|
+
%a{:href => "earl.ttl"}
|
|
82
|
+
Turtle
|
|
83
|
+
%dl
|
|
84
|
+
- subjects.each_with_index do |subject, index|
|
|
85
|
+
- subject_refs[subject['@id']] = "subj_#{index}"
|
|
86
|
+
%dt{:id => subject_refs[subject['@id']]}
|
|
87
|
+
%a{:href => subject['@id']}
|
|
88
|
+
%span{:about => subject['@id'], property: "doap:name"}<= subject['name']
|
|
89
|
+
%dd{property: "earl:testSubjects", resource: subject['@id'], typeof: Array(subject['@type']).join(" "), :inlist => true}
|
|
90
|
+
%dl
|
|
91
|
+
- if subject['doapDesc']
|
|
92
|
+
%dt= "Description"
|
|
93
|
+
%dd{property: "doap:description", :lang => 'en'}<
|
|
94
|
+
~ CGI.escapeHTML subject['doapDesc']
|
|
95
|
+
- if subject['language']
|
|
96
|
+
%dt= "Programming Language"
|
|
97
|
+
%dd{property: "doap:programming-language"}<
|
|
98
|
+
~ CGI.escapeHTML subject['language']
|
|
99
|
+
- if subject['homepage']
|
|
100
|
+
%dt= "Home Page"
|
|
101
|
+
%dd{property: "doap:homepage"}
|
|
102
|
+
%a{href: subject['homepage']}
|
|
103
|
+
~ CGI.escapeHTML subject['homepage']
|
|
104
|
+
- if subject['developer']
|
|
105
|
+
%dt= "Developer"
|
|
106
|
+
%dd{:rel => "doap:developer"}
|
|
107
|
+
- subject['developer'].each do |dev|
|
|
108
|
+
%div{resource: dev['@id'], typeof: Array(dev['@type']).join(" ")}
|
|
109
|
+
- if dev.has_key?('@id')
|
|
110
|
+
%a{:href => dev['@id']}
|
|
111
|
+
%span{property: "foaf:name"}<
|
|
112
|
+
~ CGI.escapeHTML dev['foaf:name']
|
|
113
|
+
- else
|
|
114
|
+
%span{property: "foaf:name"}<
|
|
115
|
+
~ CGI.escapeHTML dev['foaf:name']
|
|
116
|
+
- if dev['foaf:homepage']
|
|
117
|
+
%a{property: "foaf:homepage", href: dev['foaf:homepage']}
|
|
118
|
+
~ CGI.escapeHTML dev['foaf:homepage']
|
|
119
|
+
%dt
|
|
120
|
+
Test Suite Compliance
|
|
121
|
+
%dd
|
|
122
|
+
%table.report
|
|
123
|
+
%tbody
|
|
124
|
+
- tests['entries'].sort_by {|m| m['title'].to_s.downcase}.each do |manifest|
|
|
125
|
+
- passed = manifest['entries'].select {|t| t['assertions'][index]['result']['outcome'] == 'earl:passed' }.length
|
|
126
|
+
- total = manifest['entries'].length
|
|
127
|
+
- pct = (passed * 100.0) / total
|
|
128
|
+
- cls = (pct == 100.0 ? 'passed-all' : (pct >= 85.0) ? 'passed-most' : (pct == 0.0 ? 'passed-none' : 'passed-some'))
|
|
129
|
+
%tr
|
|
130
|
+
%td
|
|
131
|
+
%a{href: "##{manifest['title']}"}
|
|
132
|
+
~ manifest['title']
|
|
133
|
+
%td{:class => cls}
|
|
134
|
+
= pct == 0.0 ? "Untested" : "#{passed}/#{total} (#{'%.1f' % pct}%)"
|
|
135
|
+
%section
|
|
136
|
+
%h2
|
|
137
|
+
Individual Test Results
|
|
138
|
+
- tests['entries'].sort_by {|m| m['title'].to_s.downcase}.each do |manifest|
|
|
139
|
+
- test_cases = manifest['entries']
|
|
140
|
+
%section{id: manifest['title'], typeof: manifest['@type'].join(" "), resource: manifest['@id']}
|
|
141
|
+
%h2{property: "dc:title mf:name"}<=manifest['title']
|
|
142
|
+
- Array(manifest['description']).each do |desc|
|
|
143
|
+
%p{property: "rdfs:comment"}<
|
|
144
|
+
~ CGI.escapeHTML desc
|
|
145
|
+
%table.report
|
|
146
|
+
- skip_subject = {}
|
|
147
|
+
- passed_tests = []
|
|
148
|
+
%tr
|
|
149
|
+
%th
|
|
150
|
+
Test
|
|
151
|
+
- subjects.each_with_index do |subject, index|
|
|
152
|
+
- subject_refs[subject['@id']] = "subj_#{index}"
|
|
153
|
+
-# If subject is untested for every test in this manifest, skip it
|
|
154
|
+
- skip_subject[subject['@id']] = manifest['entries'].all? {|t| t['assertions'][index]['result']['outcome'] == 'earl:untested'}
|
|
155
|
+
- unless skip_subject[subject['@id']]
|
|
156
|
+
%th
|
|
157
|
+
%a{:href => '#' + subject_refs[subject['@id']]}<=subject['name']
|
|
158
|
+
- test_cases.each do |test|
|
|
159
|
+
%tr{:rel => "mf:entries", typeof: test['@type'].join(" "), resource: test['@id'], :inlist => true}
|
|
160
|
+
%td
|
|
161
|
+
= "Test #{test['@id'].split("#").last}: #{CGI.escapeHTML test['title']}"
|
|
162
|
+
- test['assertions'].each_with_index do |assertion, ndx|
|
|
163
|
+
- next if skip_subject[assertion['subject']]
|
|
164
|
+
- pass_fail = assertion['result']['outcome'].split(':').last.upcase.sub(/(PASS|FAIL)ED$/, '\1')
|
|
165
|
+
- passed_tests[ndx] = (passed_tests[ndx] || 0) + (pass_fail == 'PASS' ? 1 : 0)
|
|
166
|
+
%td{:class => pass_fail, property: "earl:assertions", typeof: assertion['@type'], :inlist => true}
|
|
167
|
+
- if assertion['assertedBy']
|
|
168
|
+
%link{property: "earl:assertedBy", :href => assertion['assertedBy']}
|
|
169
|
+
%link{property: "earl:test", :href => assertion['test']}
|
|
170
|
+
%link{property: "earl:subject", :href => assertion['subject']}
|
|
171
|
+
- if assertion['mode']
|
|
172
|
+
%link{property: 'earl:mode', :href => assertion['mode']}
|
|
173
|
+
%span{property: "earl:result", typeof: assertion['result']['@type']}
|
|
174
|
+
%span{property: 'earl:outcome', resource: assertion['result']['outcome']}
|
|
175
|
+
= pass_fail
|
|
176
|
+
%tr.summary
|
|
177
|
+
%td
|
|
178
|
+
= "Percentage passed out of #{manifest['entries'].length} Tests"
|
|
179
|
+
- passed_tests.compact.each do |r|
|
|
180
|
+
- pct = (r * 100.0) / manifest['entries'].length
|
|
181
|
+
%td{:class => (pct == 100.0 ? 'passed-all' : (pct >= 95.0 ? 'passed-most' : 'passed-some'))}
|
|
182
|
+
= "#{'%.1f' % pct}%"
|
|
183
|
+
%section#appendix{property: "earl:generatedBy", resource: tests['generatedBy']['@id'], typeof: tests['generatedBy']['@type']}
|
|
184
|
+
%h2
|
|
185
|
+
Report Generation Software
|
|
186
|
+
- doap = tests['generatedBy']
|
|
187
|
+
- rel = doap['release']
|
|
188
|
+
%p
|
|
189
|
+
This report generated by
|
|
190
|
+
%span{property: "doap:name"}<
|
|
191
|
+
%a{:href => tests['generatedBy']['@id']}<
|
|
192
|
+
= doap['name']
|
|
193
|
+
%meta{property: "doap:shortdesc", :content => doap['shortdesc'], :lang => 'en'}
|
|
194
|
+
%meta{property: "doap:description", :content => doap['doapDesc'], :lang => 'en'}
|
|
195
|
+
version
|
|
196
|
+
%span{property: "doap:release", resource: rel['@id'], typeof: 'doap:Version'}
|
|
197
|
+
%span{property: "doap:revision"}<=rel['revision']
|
|
198
|
+
%meta{property: "doap:name", :content => rel['name']}
|
|
199
|
+
%meta{property: "doap:created", :content => rel['created'], :datatype => "xsd:date"}
|
|
200
|
+
an
|
|
201
|
+
%a{property: "doap:license", :href => doap['license']}<="Unlicensed"
|
|
202
|
+
%span{property: "doap:programming-language"}<="Ruby"
|
|
203
|
+
application. More information is available at
|
|
204
|
+
%a{property: "doap:homepage", :href => doap['homepage']}<=doap['homepage']
|
|
205
|
+
= "."
|
data/etc/well-known
ADDED
data/lib/rdf/tabular.rb
CHANGED
|
@@ -1,9 +1,5 @@
|
|
|
1
1
|
$:.unshift(File.expand_path("..", __FILE__))
|
|
2
2
|
require 'rdf' # @see http://rubygems.org/gems/rdf
|
|
3
|
-
begin
|
|
4
|
-
require 'byebug' # REMOVE ME
|
|
5
|
-
rescue LoadError
|
|
6
|
-
end
|
|
7
3
|
require 'csv'
|
|
8
4
|
|
|
9
5
|
module RDF
|
|
@@ -28,6 +24,16 @@ module RDF
|
|
|
28
24
|
autoload :Transformation, 'rdf/tabular/metadata'
|
|
29
25
|
autoload :VERSION, 'rdf/tabular/version'
|
|
30
26
|
|
|
27
|
+
# Metadata errors detected
|
|
28
|
+
class Error < RDF::ReaderError; end
|
|
29
|
+
|
|
30
|
+
# Relative location of site-wide configuration file
|
|
31
|
+
SITE_WIDE_CONFIG = "/.well-known/csvm".freeze
|
|
32
|
+
SITE_WIDE_DEFAULT = %(
|
|
33
|
+
{+url}-metadata.json
|
|
34
|
+
csv-metadata.json
|
|
35
|
+
).gsub(/^\s+/, '').freeze
|
|
36
|
+
|
|
31
37
|
def self.debug?; @debug; end
|
|
32
38
|
def self.debug=(value); @debug = value; end
|
|
33
39
|
end
|
data/lib/rdf/tabular/format.rb
CHANGED
|
@@ -8,12 +8,13 @@ module RDF::Tabular
|
|
|
8
8
|
# RDF::Format.for(:tsv) #=> RDF::Tabular::Format
|
|
9
9
|
# RDF::Format.for("etc/foaf.csv")
|
|
10
10
|
# RDF::Format.for("etc/foaf.tsv")
|
|
11
|
-
# RDF::Format.for(:
|
|
12
|
-
# RDF::Format.for(:
|
|
13
|
-
# RDF::Format.for(:
|
|
14
|
-
# RDF::Format.for(:
|
|
15
|
-
# RDF::Format.for(:
|
|
16
|
-
# RDF::Format.for(:
|
|
11
|
+
# RDF::Format.for(file_name: "etc/foaf.csv")
|
|
12
|
+
# RDF::Format.for(file_name: "etc/foaf.tsv")
|
|
13
|
+
# RDF::Format.for(file_extension: "csv")
|
|
14
|
+
# RDF::Format.for(file_extension: "tsv")
|
|
15
|
+
# RDF::Format.for(content_type: "text/csv")
|
|
16
|
+
# RDF::Format.for(content_type: "text/tab-separated-values")
|
|
17
|
+
# RDF::Format.for(content_type: "application/csvm+json")
|
|
17
18
|
#
|
|
18
19
|
# @example Obtaining serialization format MIME types
|
|
19
20
|
# RDF::Format.content_types #=> {"text/csv" => [RDF::Tabular::Format]}
|
|
@@ -25,7 +26,10 @@ module RDF::Tabular
|
|
|
25
26
|
class Format < RDF::Format
|
|
26
27
|
content_type 'text/csv',
|
|
27
28
|
extensions: [:csv, :tsv],
|
|
28
|
-
alias:
|
|
29
|
+
alias: %w{
|
|
30
|
+
text/tab-separated-values
|
|
31
|
+
application/csvm+json
|
|
32
|
+
}
|
|
29
33
|
content_encoding 'utf-8'
|
|
30
34
|
|
|
31
35
|
reader { RDF::Tabular::Reader }
|
data/lib/rdf/tabular/metadata.rb
CHANGED
|
@@ -11,8 +11,7 @@ require 'yaml' # used by BCP47, which should have required it.
|
|
|
11
11
|
# CSVM Metadata processor
|
|
12
12
|
#
|
|
13
13
|
# * Extracts Metadata from file or Hash definition
|
|
14
|
-
# *
|
|
15
|
-
# * Extract Metadata from a CSV file
|
|
14
|
+
# * Extract Embedded Metadata from a CSV file
|
|
16
15
|
# * Return table-level annotations
|
|
17
16
|
# * Return Column-level annotations
|
|
18
17
|
# * Return row iterator with column information
|
|
@@ -45,30 +44,28 @@ module RDF::Tabular
|
|
|
45
44
|
valueUrl: :uri_template,
|
|
46
45
|
}.freeze
|
|
47
46
|
INHERITED_DEFAULTS = {
|
|
48
|
-
aboutUrl: "".freeze,
|
|
49
47
|
default: "".freeze,
|
|
50
48
|
lang: "und",
|
|
51
49
|
null: "".freeze,
|
|
52
50
|
ordered: false,
|
|
53
|
-
propertyUrl: "".freeze,
|
|
54
51
|
required: false,
|
|
55
52
|
textDirection: "ltr".freeze,
|
|
56
|
-
valueUrl: "".freeze,
|
|
57
53
|
}.freeze
|
|
58
54
|
|
|
59
55
|
# Valid datatypes
|
|
60
56
|
DATATYPES = {
|
|
61
|
-
anyAtomicType: RDF::XSD.
|
|
57
|
+
anyAtomicType: RDF::XSD.anyAtomicType,
|
|
62
58
|
anyURI: RDF::XSD.anyURI,
|
|
63
59
|
base64Binary: RDF::XSD.basee65Binary,
|
|
64
60
|
boolean: RDF::XSD.boolean,
|
|
65
61
|
byte: RDF::XSD.byte,
|
|
66
62
|
date: RDF::XSD.date,
|
|
67
63
|
dateTime: RDF::XSD.dateTime,
|
|
68
|
-
|
|
64
|
+
dayTimeDuration: RDF::XSD.dayTimeDuration,
|
|
69
65
|
dateTimeStamp: RDF::XSD.dateTimeStamp,
|
|
70
66
|
decimal: RDF::XSD.decimal,
|
|
71
67
|
double: RDF::XSD.double,
|
|
68
|
+
duration: RDF::XSD.duration,
|
|
72
69
|
float: RDF::XSD.float,
|
|
73
70
|
ENTITY: RDF::XSD.ENTITY,
|
|
74
71
|
gDay: RDF::XSD.gDay,
|
|
@@ -84,6 +81,7 @@ module RDF::Tabular
|
|
|
84
81
|
Name: RDF::XSD.Name,
|
|
85
82
|
NCName: RDF::XSD.NCName,
|
|
86
83
|
negativeInteger: RDF::XSD.negativeInteger,
|
|
84
|
+
NMTOKEN: RDF::XSD.NMTOKEN,
|
|
87
85
|
nonNegativeInteger: RDF::XSD.nonNegativeInteger,
|
|
88
86
|
nonPositiveInteger: RDF::XSD.nonPositiveInteger,
|
|
89
87
|
normalizedString: RDF::XSD.normalizedString,
|
|
@@ -100,7 +98,7 @@ module RDF::Tabular
|
|
|
100
98
|
unsignedShort: RDF::XSD.unsignedShort,
|
|
101
99
|
yearMonthDuration: RDF::XSD.yearMonthDuration,
|
|
102
100
|
|
|
103
|
-
any: RDF::XSD.
|
|
101
|
+
any: RDF::XSD.anyAtomicType,
|
|
104
102
|
binary: RDF::XSD.base64Binary,
|
|
105
103
|
datetime: RDF::XSD.dateTime,
|
|
106
104
|
html: RDF.HTML,
|
|
@@ -115,7 +113,7 @@ module RDF::Tabular
|
|
|
115
113
|
|
|
116
114
|
# Local version of the context
|
|
117
115
|
# @return [JSON::LD::Context]
|
|
118
|
-
LOCAL_CONTEXT = ::JSON::LD::Context.new.parse(File.expand_path("../../../../etc/csvw.jsonld", __FILE__))
|
|
116
|
+
LOCAL_CONTEXT = ::JSON::LD::Context.new.parse(File.expand_path("../../../../etc/csvw.jsonld", __FILE__)).freeze
|
|
119
117
|
|
|
120
118
|
# ID of this Metadata
|
|
121
119
|
# @return [RDF::URI]
|
|
@@ -139,7 +137,9 @@ module RDF::Tabular
|
|
|
139
137
|
#
|
|
140
138
|
# @param [String] path
|
|
141
139
|
# @param [Hash{Symbol => Object}] options
|
|
142
|
-
# see `RDF::Util::File.open_file` in RDF.rb
|
|
140
|
+
# see `RDF::Util::File.open_file` in RDF.rb and {#new}
|
|
141
|
+
# @yield [Metadata]
|
|
142
|
+
# @raise [IOError] if file not found
|
|
143
143
|
def self.open(path, options = {})
|
|
144
144
|
options = options.merge(
|
|
145
145
|
headers: {
|
|
@@ -152,8 +152,25 @@ module RDF::Tabular
|
|
|
152
152
|
end
|
|
153
153
|
end
|
|
154
154
|
|
|
155
|
+
# Return the well-known configuration for a file, and remember using a weak-reference cache to avoid uncessary retreivles.
|
|
156
|
+
# @param [String] base, the URL used for finding the file
|
|
157
|
+
# @return [Array<String>, false]
|
|
158
|
+
def self.site_wide_config(base)
|
|
159
|
+
require 'rdf/util/cache' unless defined?(::RDF::Util::Cache)
|
|
160
|
+
@cache ||= RDF::Util::Cache.new(-1)
|
|
161
|
+
|
|
162
|
+
config_loc = RDF::URI(base).join(SITE_WIDE_CONFIG).to_s
|
|
163
|
+
# Only load if we haven't tried before. Use `SITE_WIDE_DEFAULT` if not found
|
|
164
|
+
if @cache[config_loc].nil?
|
|
165
|
+
@cache[config_loc] = RDF::Util::File.open_file(config_loc) do |rd|
|
|
166
|
+
rd.each_line.to_a
|
|
167
|
+
end rescue SITE_WIDE_DEFAULT.split
|
|
168
|
+
end
|
|
169
|
+
@cache[config_loc]
|
|
170
|
+
end
|
|
171
|
+
|
|
155
172
|
##
|
|
156
|
-
# Return metadata for a file, based on user-specified and
|
|
173
|
+
# Return metadata for a file, based on user-specified, linked, and site-wide location configuration from an input file
|
|
157
174
|
# @param [IO, StringIO] input
|
|
158
175
|
# @param [Hash{Symbol => Object}] options
|
|
159
176
|
# @option options [Metadata, Hash, String, RDF::URI] :metadata user supplied metadata, merged on top of extracted metadata. If provided as a URL, Metadata is loade from that location
|
|
@@ -175,22 +192,46 @@ module RDF::Tabular
|
|
|
175
192
|
# Search for metadata until found
|
|
176
193
|
|
|
177
194
|
# load link metadata, if available
|
|
178
|
-
|
|
179
|
-
if input.respond_to?(:links) &&
|
|
195
|
+
all_locs = []
|
|
196
|
+
if !metadata && input.respond_to?(:links) &&
|
|
180
197
|
link = input.links.find_link(%w(rel describedby))
|
|
181
|
-
|
|
198
|
+
link_loc = RDF::URI(base).join(link.href).to_s
|
|
199
|
+
md = Metadata.open(link_loc, options.merge(filenames: link_loc, reason: "load linked metadata: #{link_loc}"))
|
|
200
|
+
all_locs << link_loc if md
|
|
201
|
+
# Metadata must describe file to be useful
|
|
202
|
+
metadata = md if md && md.describes_file?(base)
|
|
182
203
|
end
|
|
183
204
|
|
|
184
|
-
|
|
185
|
-
|
|
205
|
+
locs = []
|
|
206
|
+
# If we still don't have metadata, load the site-wide configuration file and use templates found there as locations
|
|
207
|
+
if !metadata && base
|
|
208
|
+
templates = site_wide_config(base)
|
|
209
|
+
debug("for_input", options) {"templates: #{templates.map(&:to_s).inspect}"}
|
|
210
|
+
locs = templates.map do |template|
|
|
211
|
+
t = Addressable::Template.new(template)
|
|
212
|
+
RDF::URI(base).join(t.expand(url: base).to_s)
|
|
213
|
+
end
|
|
214
|
+
debug("for_input", options) {"locs: #{locs.map(&:to_s).inspect}"}
|
|
215
|
+
|
|
216
|
+
locs.each do |loc|
|
|
217
|
+
metadata ||= begin
|
|
218
|
+
md = Metadata.open(loc, options.merge(filenames: loc, reason: "load found metadata: #{loc}"))
|
|
219
|
+
# Metadata must describe file to be useful
|
|
220
|
+
all_locs << loc if md
|
|
221
|
+
md if md && md.describes_file?(base)
|
|
222
|
+
rescue IOError
|
|
223
|
+
debug("for_input", options) {"failed to load found metadata #{loc}: #{$!}"}
|
|
224
|
+
nil
|
|
225
|
+
end
|
|
226
|
+
end
|
|
186
227
|
end
|
|
187
228
|
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
229
|
+
# If Metadata was found, but no metadata describes the file, issue a warning
|
|
230
|
+
if !all_locs.empty? && !metadata
|
|
231
|
+
warnings = options.fetch(:warnings, [])
|
|
232
|
+
warnings << "Found metadata at #{all_locs.join(",")}, which does not describe #{base}, ignoring"
|
|
233
|
+
if options[:validate] && !options[:warnings]
|
|
234
|
+
$stderr.puts "Warnings: #{warnings.join("\n")}"
|
|
194
235
|
end
|
|
195
236
|
end
|
|
196
237
|
|
|
@@ -198,7 +239,7 @@ module RDF::Tabular
|
|
|
198
239
|
metadata = case
|
|
199
240
|
when metadata then metadata
|
|
200
241
|
when base then TableGroup.new({"@context" => "http://www.w3.org/ns/csvw", tables: [{url: base}]}, options)
|
|
201
|
-
else TableGroup.new({"@context" => "http://www.w3.org/ns/csvw", tables: []}, options)
|
|
242
|
+
else TableGroup.new({"@context" => "http://www.w3.org/ns/csvw", tables: [{url: nil}]}, options)
|
|
202
243
|
end
|
|
203
244
|
|
|
204
245
|
# Make TableGroup, if not already
|
|
@@ -217,6 +258,8 @@ module RDF::Tabular
|
|
|
217
258
|
else ::JSON.parse(input.to_s)
|
|
218
259
|
end
|
|
219
260
|
|
|
261
|
+
raise ::JSON::ParserError unless object.is_a?(Hash)
|
|
262
|
+
|
|
220
263
|
unless options[:parent]
|
|
221
264
|
# Add context, if not set (which it should be)
|
|
222
265
|
object['@context'] ||= options.delete(:@context) || options[:context]
|
|
@@ -237,7 +280,7 @@ module RDF::Tabular
|
|
|
237
280
|
when %w(tables).any? {|k| object_keys.include?(k)} then :TableGroup
|
|
238
281
|
when %w(dialect tableSchema transformations).any? {|k| object_keys.include?(k)} then :Table
|
|
239
282
|
when %w(targetFormat scriptFormat source).any? {|k| object_keys.include?(k)} then :Transformation
|
|
240
|
-
when %w(columns primaryKey foreignKeys).any? {|k| object_keys.include?(k)} then :Schema
|
|
283
|
+
when %w(columns primaryKey foreignKeys rowTitles).any? {|k| object_keys.include?(k)} then :Schema
|
|
241
284
|
when %w(name virtual).any? {|k| object_keys.include?(k)} then :Column
|
|
242
285
|
when %w(commentPrefix delimiter doubleQuote encoding header headerRowCount).any? {|k| object_keys.include?(k)} then :Dialect
|
|
243
286
|
when %w(lineTerminators quoteChar skipBlankRows skipColumns skipInitialSpace skipRows trim).any? {|k| object_keys.include?(k)} then :Dialect
|
|
@@ -251,13 +294,15 @@ module RDF::Tabular
|
|
|
251
294
|
when :Column then RDF::Tabular::Column
|
|
252
295
|
when :Dialect then RDF::Tabular::Dialect
|
|
253
296
|
else
|
|
254
|
-
raise Error, "
|
|
297
|
+
raise Error, "Unknown metadata type: #{type.inspect}"
|
|
255
298
|
end
|
|
256
299
|
end
|
|
257
300
|
|
|
258
301
|
md = klass.allocate
|
|
259
302
|
md.send(:initialize, object, options)
|
|
260
303
|
md
|
|
304
|
+
rescue ::JSON::ParserError
|
|
305
|
+
raise Error, "Expected input to be a JSON Object"
|
|
261
306
|
end
|
|
262
307
|
|
|
263
308
|
##
|
|
@@ -271,6 +316,8 @@ module RDF::Tabular
|
|
|
271
316
|
# Context used for this metadata. Taken from input if not provided
|
|
272
317
|
# @option options [RDF::URI] :base
|
|
273
318
|
# The Base URL to use when expanding the document. This overrides the value of `input` if it is a URL. If not specified and `input` is not an URL, the base URL defaults to the current document URL if in a browser context, or the empty string if there is no document context.
|
|
319
|
+
# @option options [Boolean] :normalize normalize the object
|
|
320
|
+
# @option options [Boolean] :validate Strict metadata validation
|
|
274
321
|
# @raise [Error]
|
|
275
322
|
# @return [Metadata]
|
|
276
323
|
def initialize(input, options = {})
|
|
@@ -285,15 +332,15 @@ module RDF::Tabular
|
|
|
285
332
|
@context = case input['@context']
|
|
286
333
|
when Array
|
|
287
334
|
warn "Context missing required value 'http://www.w3.org/ns/csvw'" unless input['@context'].include?('http://www.w3.org/ns/csvw')
|
|
288
|
-
LOCAL_CONTEXT.parse(input['@context'].detect {|e| e.is_a?(Hash)} || {})
|
|
335
|
+
LOCAL_CONTEXT.dup.parse(input['@context'].detect {|e| e.is_a?(Hash)} || {})
|
|
289
336
|
when Hash
|
|
290
337
|
warn "Context missing required value 'http://www.w3.org/ns/csvw'" unless input['@context'].include?('http://www.w3.org/ns/csvw')
|
|
291
|
-
LOCAL_CONTEXT.parse(input['@context'])
|
|
292
|
-
when "http://www.w3.org/ns/csvw" then LOCAL_CONTEXT
|
|
338
|
+
LOCAL_CONTEXT.dup.parse(input['@context'])
|
|
339
|
+
when "http://www.w3.org/ns/csvw" then LOCAL_CONTEXT.dup
|
|
293
340
|
else
|
|
294
341
|
if self.is_a?(TableGroup) || self.is_a?(Table) && !@parent
|
|
295
342
|
warn "Context missing required value 'http://www.w3.org/ns/csvw'"
|
|
296
|
-
LOCAL_CONTEXT
|
|
343
|
+
LOCAL_CONTEXT.dup
|
|
297
344
|
end
|
|
298
345
|
end
|
|
299
346
|
|
|
@@ -326,17 +373,17 @@ module RDF::Tabular
|
|
|
326
373
|
when :url
|
|
327
374
|
# URL of CSV relative to metadata
|
|
328
375
|
object[:url] = value
|
|
329
|
-
@url = base.join(value)
|
|
330
|
-
@
|
|
376
|
+
@url = @options[:base].join(value)
|
|
377
|
+
@options[:base] = @url if @context # Use as base for expanding IRIs
|
|
331
378
|
when :@id
|
|
332
379
|
# metadata identifier
|
|
333
380
|
object[:@id] = if value.is_a?(String)
|
|
334
381
|
value
|
|
335
382
|
else
|
|
336
383
|
warn "#{type} has invalid property '@id' (#{value.inspect}): expected a string"
|
|
337
|
-
""
|
|
384
|
+
"" # Default value
|
|
338
385
|
end
|
|
339
|
-
@id = base.join(object[:@id])
|
|
386
|
+
@id = @options[:base].join(object[:@id])
|
|
340
387
|
else
|
|
341
388
|
if @properties.has_key?(key) || INHERITED_PROPERTIES.has_key?(key)
|
|
342
389
|
self.send("#{key}=".to_sym, value)
|
|
@@ -348,7 +395,15 @@ module RDF::Tabular
|
|
|
348
395
|
end
|
|
349
396
|
|
|
350
397
|
# Set type from @type, if present and not otherwise defined
|
|
351
|
-
@type
|
|
398
|
+
@type = object[:@type].to_sym if object[:@type]
|
|
399
|
+
|
|
400
|
+
if options[:normalize]
|
|
401
|
+
# If normalizing, also remove remaining @context
|
|
402
|
+
self.normalize!
|
|
403
|
+
@context = nil
|
|
404
|
+
object.delete(:@context)
|
|
405
|
+
end
|
|
406
|
+
|
|
352
407
|
if reason
|
|
353
408
|
debug("md#initialize") {reason}
|
|
354
409
|
debug("md#initialize") {"filenames: #{filenames}"}
|
|
@@ -356,8 +411,14 @@ module RDF::Tabular
|
|
|
356
411
|
end
|
|
357
412
|
end
|
|
358
413
|
|
|
359
|
-
# Setters
|
|
414
|
+
# Getters and Setters
|
|
360
415
|
INHERITED_PROPERTIES.keys.each do |key|
|
|
416
|
+
define_method(key) do
|
|
417
|
+
object.fetch(key) do
|
|
418
|
+
parent ? parent.send(key) : default_value(key)
|
|
419
|
+
end
|
|
420
|
+
end
|
|
421
|
+
|
|
361
422
|
define_method("#{key}=".to_sym) do |value|
|
|
362
423
|
invalid = case key
|
|
363
424
|
when :aboutUrl, :default, :propertyUrl, :valueUrl
|
|
@@ -370,7 +431,7 @@ module RDF::Tabular
|
|
|
370
431
|
when :ordered, :required
|
|
371
432
|
"boolean" unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
|
|
372
433
|
when :separator
|
|
373
|
-
"
|
|
434
|
+
"string or null" unless value.nil? || value.is_a?(String)
|
|
374
435
|
when :textDirection
|
|
375
436
|
"rtl or ltr" unless %(rtl ltr).include?(value)
|
|
376
437
|
when :datatype
|
|
@@ -379,7 +440,7 @@ module RDF::Tabular
|
|
|
379
440
|
|
|
380
441
|
if invalid
|
|
381
442
|
warn "#{type} has invalid property '#{key}' (#{value.inspect}): expected #{invalid}"
|
|
382
|
-
object
|
|
443
|
+
object.delete(key)
|
|
383
444
|
else
|
|
384
445
|
object[key] = value
|
|
385
446
|
end
|
|
@@ -399,18 +460,19 @@ module RDF::Tabular
|
|
|
399
460
|
# An object property that provides a schema description as described in section 3.8 Schemas, for all the tables in the group. This may be provided as an embedded object within the JSON metadata or as a URL reference to a separate JSON schema document
|
|
400
461
|
# when loading a remote schema, assign @id from it's location if not already set
|
|
401
462
|
def tableSchema=(value)
|
|
402
|
-
case value
|
|
463
|
+
object[:tableSchema] = case value
|
|
403
464
|
when String
|
|
404
|
-
link = base.join(value).to_s
|
|
405
|
-
|
|
406
|
-
|
|
407
|
-
|
|
465
|
+
link = context.base.join(value).to_s
|
|
466
|
+
md = Schema.open(link, @options.merge(parent: self, context: nil, normalize: true))
|
|
467
|
+
md[:@id] ||= link
|
|
468
|
+
md
|
|
408
469
|
when Hash
|
|
409
|
-
|
|
470
|
+
Schema.new(value, @options.merge(parent: self, context: nil))
|
|
410
471
|
when Schema
|
|
411
|
-
|
|
472
|
+
value
|
|
412
473
|
else
|
|
413
474
|
warn "#{type} has invalid property 'tableSchema' (#{value.inspect}): expected a URL or object"
|
|
475
|
+
Schema.new({}, @options.merge(parent: self, context: nil))
|
|
414
476
|
end
|
|
415
477
|
end
|
|
416
478
|
|
|
@@ -445,13 +507,16 @@ module RDF::Tabular
|
|
|
445
507
|
end
|
|
446
508
|
|
|
447
509
|
# If provided, dialect provides hints to processors about how to parse the referenced file to create a tabular data model.
|
|
448
|
-
@dialect = case value
|
|
510
|
+
@dialect = object[:dialect] = case value
|
|
449
511
|
when String
|
|
450
|
-
|
|
512
|
+
link = context.base.join(value).to_s
|
|
513
|
+
md = Metadata.open(link, @options.merge(parent: self, context: nil, normalize: true))
|
|
514
|
+
md[:@id] ||= link
|
|
515
|
+
md
|
|
451
516
|
when Hash
|
|
452
|
-
|
|
517
|
+
Dialect.new(value, @options.merge(parent: self, context: nil))
|
|
453
518
|
when Dialect
|
|
454
|
-
|
|
519
|
+
value
|
|
455
520
|
else
|
|
456
521
|
warn "#{type} has invalid property 'dialect' (#{value.inspect}): expected a URL or object"
|
|
457
522
|
nil
|
|
@@ -460,16 +525,18 @@ module RDF::Tabular
|
|
|
460
525
|
|
|
461
526
|
# Set new datatype
|
|
462
527
|
# @return [Dialect]
|
|
528
|
+
# @raise [Error] if datatype is not valid
|
|
463
529
|
def datatype=(value)
|
|
464
530
|
val = case value
|
|
465
531
|
when Hash then Datatype.new(value, parent: self)
|
|
466
532
|
else Datatype.new({base: value}, parent: self)
|
|
467
533
|
end
|
|
468
534
|
|
|
469
|
-
if val.valid?
|
|
535
|
+
if val.valid? || value.is_a?(Hash)
|
|
536
|
+
# Set it if it was specified as an object, which may cause validation errors later
|
|
470
537
|
object[:datatype] = val
|
|
471
538
|
else
|
|
472
|
-
warn "#{type} has invalid property 'datatype': expected a
|
|
539
|
+
warn "#{type} has invalid property 'datatype': expected a built-in or an object"
|
|
473
540
|
end
|
|
474
541
|
end
|
|
475
542
|
|
|
@@ -538,7 +605,7 @@ module RDF::Tabular
|
|
|
538
605
|
value = object[key]
|
|
539
606
|
case key
|
|
540
607
|
when :base
|
|
541
|
-
|
|
608
|
+
errors << "#{type} has invalid base: #{value.inspect}" unless DATATYPES.keys.map(&:to_s).include?(value)
|
|
542
609
|
when :columns
|
|
543
610
|
value.each do |v|
|
|
544
611
|
begin
|
|
@@ -549,14 +616,20 @@ module RDF::Tabular
|
|
|
549
616
|
end
|
|
550
617
|
column_names = value.map(&:name)
|
|
551
618
|
errors << "#{type} has invalid property '#{key}': must have unique names: #{column_names.inspect}" unless column_names.uniq == column_names
|
|
552
|
-
when :dialect, :tables, :tableSchema, :transformations
|
|
619
|
+
when :datatype, :dialect, :tables, :tableSchema, :transformations
|
|
553
620
|
Array(value).each do |t|
|
|
554
|
-
|
|
555
|
-
|
|
556
|
-
|
|
557
|
-
|
|
621
|
+
# Make sure value is of appropriate class
|
|
622
|
+
if t.is_a?({datatype: Datatype, dialect: Dialect, tables: Table, tableSchema: Schema, transformations: Transformation}[key])
|
|
623
|
+
begin
|
|
624
|
+
t.validate!
|
|
625
|
+
rescue Error => e
|
|
626
|
+
errors << e.message
|
|
627
|
+
end
|
|
628
|
+
else
|
|
629
|
+
errors << "#{type} has invalid property '#{key}': unexpected value #{value.class.name}"
|
|
558
630
|
end
|
|
559
631
|
end
|
|
632
|
+
errors << "#{type} has invalid property 'tables': must not be empty" if key == :tables && Array(value).empty?
|
|
560
633
|
when :foreignKeys
|
|
561
634
|
# An array of foreign key definitions that define how the values from specified columns within this table link to rows within this table or other tables. A foreign key definition is a JSON object with the properties:
|
|
562
635
|
value.each do |fk|
|
|
@@ -577,13 +650,13 @@ module RDF::Tabular
|
|
|
577
650
|
errors << "#{type} has invalid property '#{key}': reference has a schemaReference: #{reference.inspect}"
|
|
578
651
|
end
|
|
579
652
|
# resource is the URL of a Table in the TableGroup
|
|
580
|
-
ref = base.join(reference['resource']).to_s
|
|
653
|
+
ref = context.base.join(reference['resource']).to_s
|
|
581
654
|
table = root.is_a?(TableGroup) && root.tables.detect {|t| t.url == ref}
|
|
582
655
|
errors << "#{type} has invalid property '#{key}': table referenced by #{ref} not found" unless table
|
|
583
656
|
table.tableSchema if table
|
|
584
657
|
elsif reference.has_key?('schemaReference')
|
|
585
658
|
# resource is the @id of a Schema in the TableGroup
|
|
586
|
-
ref = base.join(reference['schemaReference']).to_s
|
|
659
|
+
ref = context.base.join(reference['schemaReference']).to_s
|
|
587
660
|
tables = root.is_a?(TableGroup) ? root.tables.select {|t| t.tableSchema[:@id] == ref} : []
|
|
588
661
|
case tables.length
|
|
589
662
|
when 0
|
|
@@ -608,6 +681,114 @@ module RDF::Tabular
|
|
|
608
681
|
errors << "#{type} has invalid property '#{key}': reference must be an object #{reference.inspect}"
|
|
609
682
|
end
|
|
610
683
|
end
|
|
684
|
+
when :format
|
|
685
|
+
case value
|
|
686
|
+
when Hash
|
|
687
|
+
# Object form only appropriate for numeric type
|
|
688
|
+
unless %w(
|
|
689
|
+
decimal integer long int short byte double float number
|
|
690
|
+
nonNegativeInteger positiveInteger nonPositiveInteger negativeInteger
|
|
691
|
+
unsignedLong unsignedInt unsignedShort unsignedByte
|
|
692
|
+
).include?(self.base)
|
|
693
|
+
warn "#{type} has invalid property '#{key}': Object form only allowed on string or binary datatypes"
|
|
694
|
+
object.delete(:format) # act as if not set
|
|
695
|
+
end
|
|
696
|
+
|
|
697
|
+
# Otherwise, if it exists, its a UAX35 number pattern
|
|
698
|
+
begin
|
|
699
|
+
parse_uax35_number(value["pattern"], nil, value.fetch('groupChar', ','), value.fetch('decimalChar', '.'))
|
|
700
|
+
rescue ArgumentError => e
|
|
701
|
+
warn "#{type} has invalid property '#{key}' pattern: #{e.message}"
|
|
702
|
+
object[:format].delete("pattern") # act as if not set
|
|
703
|
+
end
|
|
704
|
+
else
|
|
705
|
+
case self.base
|
|
706
|
+
when 'boolean'
|
|
707
|
+
unless value.split("|").length == 2
|
|
708
|
+
warn "#{type} has invalid property '#{key}': annotation provides the true and false values expected, separated by '|'"
|
|
709
|
+
object.delete(:format) # act as if not set
|
|
710
|
+
end
|
|
711
|
+
when :decimal, :integer, :long, :int, :short, :byte,
|
|
712
|
+
:nonNegativeInteger, :positiveInteger,
|
|
713
|
+
:unsignedLong, :unsignedInt, :unsignedShort, :unsignedByte,
|
|
714
|
+
:nonPositiveInteger, :negativeInteger,
|
|
715
|
+
:double, :float, :number
|
|
716
|
+
begin
|
|
717
|
+
parse_uax35_number(value, nil)
|
|
718
|
+
rescue ArgumentError => e
|
|
719
|
+
warn "#{type} has invalid property '#{key}': #{e.message}"
|
|
720
|
+
object.delete(:format) # act as if not set
|
|
721
|
+
end
|
|
722
|
+
when 'date', 'dateTime', 'datetime', 'dateTimeStamp', 'time'
|
|
723
|
+
# Parse and validate format
|
|
724
|
+
begin
|
|
725
|
+
parse_uax35_date(value, nil)
|
|
726
|
+
rescue ArgumentError => e
|
|
727
|
+
warn "#{type} has invalid property '#{key}': #{e.message}"
|
|
728
|
+
object.delete(:format) # act as if not set
|
|
729
|
+
end
|
|
730
|
+
else
|
|
731
|
+
# Otherwise, if it exists, its a regular expression
|
|
732
|
+
begin
|
|
733
|
+
Regexp.compile(value)
|
|
734
|
+
rescue
|
|
735
|
+
warn "#{type} has invalid property '#{key}': #{$!.message}"
|
|
736
|
+
object.delete(:format) # act as if not set
|
|
737
|
+
end
|
|
738
|
+
end
|
|
739
|
+
end
|
|
740
|
+
when :length, :minLength, :maxLength
|
|
741
|
+
# Applications must raise an error if both length and minLength are specified and length is less than minLength.
|
|
742
|
+
# Similarly, applications must raise an error if both length and maxLength are specified and length is greater than maxLength.
|
|
743
|
+
if object[:length]
|
|
744
|
+
case key
|
|
745
|
+
when :minLength
|
|
746
|
+
errors << "#{type} has invalid property minLength': both length and minLength requires length be greater than or equal to minLength" if object[:length] < value
|
|
747
|
+
when :maxLength
|
|
748
|
+
errors << "#{type} has invalid property maxLength': both length and maxLength requires length be less than or equal to maxLength" if object[:length] > value
|
|
749
|
+
end
|
|
750
|
+
end
|
|
751
|
+
|
|
752
|
+
# Applications must raise an error if minLength and maxLength are both specified and minLength is greater than maxLength.
|
|
753
|
+
if key == :maxLength && object[:minLength]
|
|
754
|
+
errors << "#{type} has invalid property #{key}': both minLength and maxLength requires minLength be less than or equal to maxLength" if object[:minLength] > value
|
|
755
|
+
end
|
|
756
|
+
|
|
757
|
+
# Applications must raise an error if length, maxLength, or minLength are specified and the base datatype is not string or one of its subtypes, or a binary type.
|
|
758
|
+
unless %w(string normalizedString token language Name NMTOKEN hexBinary base64Binary binary).include?(self.base)
|
|
759
|
+
errors << "#{type} has invalid property '#{key}': only allowed on string or binary datatypes"
|
|
760
|
+
end
|
|
761
|
+
when :minimum, :maximum, :minInclusive, :maxInclusive, :minExclusive, :maxExclusive
|
|
762
|
+
case self.base
|
|
763
|
+
when 'decimal', 'integer', 'long', 'int', 'short', 'byte', 'double', 'number', 'float',
|
|
764
|
+
'nonNegativeInteger', 'positiveInteger', 'unsignedLong', 'unsignedInt', 'unsignedShort', 'unsignedByte',
|
|
765
|
+
'nonPositiveInteger', 'negativeInteger', 'date', 'dateTime', 'datetime', 'dateTimeStamp', 'time',
|
|
766
|
+
'duration', 'dayTimeDuration', 'yearMonthDuration'
|
|
767
|
+
errors << "#{type} has invalid property '#{key}': #{value.to_ntriples} is not a valid #{self.base}" unless value.valid?
|
|
768
|
+
|
|
769
|
+
case key
|
|
770
|
+
when :minInclusive
|
|
771
|
+
# Applications MUST raise an error if both minInclusive and minExclusive are specified
|
|
772
|
+
errors << "#{type} cannot specify both minInclusive and minExclusive" if self.minExclusive
|
|
773
|
+
|
|
774
|
+
# Applications MUST raise an error if both minInclusive and maxInclusive are specified and maxInclusive is less than minInclusive
|
|
775
|
+
errors << "#{type} maxInclusive < minInclusive" if self.maxInclusive && self.maxInclusive < value
|
|
776
|
+
|
|
777
|
+
# Applications MUST raise an error if both minInclusive and maxExclusive are specified and maxExclusive is less than or equal to minInclusive
|
|
778
|
+
errors << "#{type} maxExclusive <= minInclusive" if self.maxExclusive && self.maxExclusive <= value
|
|
779
|
+
when :maxInclusive
|
|
780
|
+
# Applications MUST raise an error if both maxInclusive and maxExclusive are specified
|
|
781
|
+
errors << "#{type} cannot specify both maInclusive and maxExclusive" if self.maxExclusive
|
|
782
|
+
when :minExclusive
|
|
783
|
+
# Applications MUST raise an error if both minExclusive and maxExclusive are specified and maxExclusive is less than minExclusive
|
|
784
|
+
errors << "#{type} minExclusive < maxExclusive" if self.maxExclusive && self.maxExclusive < value
|
|
785
|
+
|
|
786
|
+
# Applications MUST raise an error if both minExclusive and maxInclusive are specified and maxInclusive is less than or equal to minExclusive
|
|
787
|
+
errors << "#{type} maxInclusive < minExclusive" if self.maxInclusive && self.maxInclusive <= value
|
|
788
|
+
end
|
|
789
|
+
else
|
|
790
|
+
errors << "#{type} has invalid property '#{key}': only allowed on numeric, date/time or duration datatypes"
|
|
791
|
+
end
|
|
611
792
|
when :notes
|
|
612
793
|
unless value.is_a?(Hash) || value.is_a?(Array)
|
|
613
794
|
errors << "#{type} has invalid property '#{key}': #{value}, Object or Array"
|
|
@@ -617,7 +798,7 @@ module RDF::Tabular
|
|
|
617
798
|
rescue Error => e
|
|
618
799
|
errors << "#{type} has invalid content '#{key}': #{e.message}"
|
|
619
800
|
end
|
|
620
|
-
when :primaryKey
|
|
801
|
+
when :primaryKey, :rowTitles
|
|
621
802
|
# A column reference property that holds either a single reference to a column description object or an array of references.
|
|
622
803
|
"#{type} has invalid property '#{key}': no column references found" unless Array(value).length > 0
|
|
623
804
|
Array(value).each do |k|
|
|
@@ -628,9 +809,18 @@ module RDF::Tabular
|
|
|
628
809
|
when :@id
|
|
629
810
|
# Must not be a BNode
|
|
630
811
|
if value.to_s.start_with?("_:")
|
|
631
|
-
errors << "#{type} has invalid property '#{key}': #{value.inspect}, must not start with '_:"
|
|
812
|
+
errors << "#{type} has invalid property '#{key}': #{value.inspect}, must not start with '_:'"
|
|
813
|
+
end
|
|
814
|
+
|
|
815
|
+
# Datatype @id MUST NOT be the URL of a built-in type
|
|
816
|
+
if self.is_a?(Datatype) && DATATYPES.values.include?(value)
|
|
817
|
+
errors << "#{type} has invalid property '#{key}': #{value.inspect}, must not be the URL of a built-in datatype"
|
|
632
818
|
end
|
|
633
819
|
when :@type
|
|
820
|
+
# Must not be a BNode
|
|
821
|
+
if value.to_s.start_with?("_:")
|
|
822
|
+
errors << "#{type} has invalid property '#{key}': #{value.inspect}, must not start with '_:'"
|
|
823
|
+
end
|
|
634
824
|
unless value.to_sym == type
|
|
635
825
|
errors << "#{type} has invalid property '#{key}': #{value.inspect}, expected #{type}"
|
|
636
826
|
end
|
|
@@ -690,7 +880,9 @@ module RDF::Tabular
|
|
|
690
880
|
next
|
|
691
881
|
end
|
|
692
882
|
number += 1
|
|
693
|
-
|
|
883
|
+
row = Row.new(data, self, number, number + skipped, @options)
|
|
884
|
+
(self.object[:rows] ||= []) << row if @options[:validate] # Keep track of rows when validating
|
|
885
|
+
yield(row)
|
|
694
886
|
end
|
|
695
887
|
end
|
|
696
888
|
|
|
@@ -775,18 +967,39 @@ module RDF::Tabular
|
|
|
775
967
|
object.keys.any? {|k| k.to_s.include?(':')}
|
|
776
968
|
end
|
|
777
969
|
|
|
970
|
+
# Does this metadata describe the file (URL)?
|
|
971
|
+
# @param [RDF::URL] url
|
|
972
|
+
# @return [Boolean]
|
|
973
|
+
def describes_file?(url)
|
|
974
|
+
case self
|
|
975
|
+
when TableGroup
|
|
976
|
+
tables.any? {|t| t.url == url}
|
|
977
|
+
else
|
|
978
|
+
self.url == url
|
|
979
|
+
end
|
|
980
|
+
end
|
|
981
|
+
|
|
778
982
|
# Verify that the metadata we're using is compatible with embedded metadata
|
|
779
983
|
# @param [Table] other
|
|
780
984
|
# @raise [Error] if not compatible
|
|
781
985
|
def verify_compatible!(other)
|
|
782
986
|
if self.is_a?(TableGroup)
|
|
783
987
|
unless tables.any? {|t| t.url == other.url && t.verify_compatible!(other)}
|
|
784
|
-
|
|
988
|
+
if @options[:validate]
|
|
989
|
+
raise Error, "TableGroups must have Table with matching url #{tables.map(&:url).inspect} vs #{other.url.inspect}"
|
|
990
|
+
else
|
|
991
|
+
warn "TableGroups must have Table with matching url #{tables.map(&:url).inspect} vs #{other.url.inspect}"
|
|
992
|
+
end
|
|
785
993
|
end
|
|
786
994
|
else
|
|
787
995
|
# Tables must have the same url
|
|
788
|
-
|
|
789
|
-
|
|
996
|
+
unless url == other.url
|
|
997
|
+
if @options[:validate]
|
|
998
|
+
raise Error, "Tables must have the same url: #{url.inspect} vs #{other.url.inspect}}"
|
|
999
|
+
else
|
|
1000
|
+
warn "Tables must have the same url: #{url.inspect} vs #{other.url.inspect}}"
|
|
1001
|
+
end
|
|
1002
|
+
end
|
|
790
1003
|
|
|
791
1004
|
# Each column description within B MUST match the corresponding column description in A for non-virtual columns
|
|
792
1005
|
non_virtual_columns = Array(tableSchema.columns).reject(&:virtual)
|
|
@@ -798,23 +1011,41 @@ module RDF::Tabular
|
|
|
798
1011
|
index = 0
|
|
799
1012
|
object_columns.all? do |cb|
|
|
800
1013
|
ca = non_virtual_columns[index]
|
|
801
|
-
|
|
802
|
-
|
|
803
|
-
|
|
804
|
-
|
|
805
|
-
|
|
806
|
-
|
|
807
|
-
|
|
808
|
-
|
|
809
|
-
|
|
810
|
-
|
|
811
|
-
|
|
812
|
-
|
|
813
|
-
|
|
814
|
-
|
|
815
|
-
|
|
816
|
-
|
|
817
|
-
|
|
1014
|
+
ta = ca.titles || {}
|
|
1015
|
+
tb = cb.titles || {}
|
|
1016
|
+
if !ca.object.has_key?(:name) && !cb.object.has_key?(:name) && ta.empty? && tb.empty?
|
|
1017
|
+
true
|
|
1018
|
+
elsif ca.object.has_key?(:name) && cb.object.has_key?(:name)
|
|
1019
|
+
raise Error, "Columns don't match: ca: #{ca.inspect}, cb: #{cb.inspect}" unless ca.name == cb.name
|
|
1020
|
+
elsif @options[:validate] || !ta.empty? && !tb.empty?
|
|
1021
|
+
# If validating, column compatibility requires strict match between titles
|
|
1022
|
+
titles_match = case
|
|
1023
|
+
when Array(ta['und']).any? {|t| tb.values.flatten.compact.include?(t)}
|
|
1024
|
+
true
|
|
1025
|
+
when Array(tb['und']).any? {|t| ta.values.flatten.compact.include?(t)}
|
|
1026
|
+
true
|
|
1027
|
+
when ta.any? {|lang, values| !(Array(tb[lang]) & Array(values)).empty?}
|
|
1028
|
+
# Match on title and language
|
|
1029
|
+
true
|
|
1030
|
+
else
|
|
1031
|
+
# Match if a language from ta is a prefix of a language from tb with matching titles
|
|
1032
|
+
ta.any? do |la, values|
|
|
1033
|
+
tb.keys.any? do |lb|
|
|
1034
|
+
(la.start_with?(lb) || lb.start_with?(la)) && !(Array(tb[lb]) & Array(values)).empty?
|
|
1035
|
+
end
|
|
1036
|
+
end
|
|
1037
|
+
end
|
|
1038
|
+
|
|
1039
|
+
if titles_match
|
|
1040
|
+
true
|
|
1041
|
+
elsif !@options[:validate]
|
|
1042
|
+
# If not validating, columns don't match, but processing continues
|
|
1043
|
+
warn "Columns don't match: ca: #{ca.inspect}, cb: #{cb.inspect}"
|
|
1044
|
+
true
|
|
1045
|
+
else
|
|
1046
|
+
raise Error, "Columns don't match: ca: #{ca.inspect}, cb: #{cb.inspect}"
|
|
1047
|
+
end
|
|
1048
|
+
end
|
|
818
1049
|
index += 1
|
|
819
1050
|
end
|
|
820
1051
|
end
|
|
@@ -822,7 +1053,7 @@ module RDF::Tabular
|
|
|
822
1053
|
end
|
|
823
1054
|
|
|
824
1055
|
def inspect
|
|
825
|
-
self.class.name + object.inspect
|
|
1056
|
+
self.class.name + (respond_to?(:to_atd) ? to_atd : object).inspect
|
|
826
1057
|
end
|
|
827
1058
|
|
|
828
1059
|
# Proxy to @object
|
|
@@ -830,7 +1061,7 @@ module RDF::Tabular
|
|
|
830
1061
|
def []=(key, value); object[key] = value; end
|
|
831
1062
|
def each(&block); object.each(&block); end
|
|
832
1063
|
def ==(other)
|
|
833
|
-
object == (other.is_a?(Hash) ? other : other.object)
|
|
1064
|
+
object == (other.is_a?(Hash) ? other : (other.respond_to?(:object) ? other.object : other))
|
|
834
1065
|
end
|
|
835
1066
|
def to_json(args=nil); object.to_json(args); end
|
|
836
1067
|
|
|
@@ -845,8 +1076,6 @@ module RDF::Tabular
|
|
|
845
1076
|
normalize_jsonld(key, value)
|
|
846
1077
|
when ->(k) {key.to_s == '@context'}
|
|
847
1078
|
"http://www.w3.org/ns/csvw"
|
|
848
|
-
when :link
|
|
849
|
-
base.join(value).to_s
|
|
850
1079
|
when :array
|
|
851
1080
|
value = [value] unless value.is_a?(Array)
|
|
852
1081
|
value.map do |v|
|
|
@@ -854,13 +1083,15 @@ module RDF::Tabular
|
|
|
854
1083
|
v.normalize!
|
|
855
1084
|
elsif v.is_a?(Hash) && (ref = v["reference"]).is_a?(Hash)
|
|
856
1085
|
# SPEC SUGGESTION: special case for foreignKeys
|
|
857
|
-
ref["resource"] = base.join(ref["resource"]).to_s if ref["resource"]
|
|
858
|
-
ref["schemaReference"] = base.join(ref["schemaReference"]).to_s if ref["schemaReference"]
|
|
1086
|
+
ref["resource"] = context.base.join(ref["resource"]).to_s if ref["resource"]
|
|
1087
|
+
ref["schemaReference"] = context.base.join(ref["schemaReference"]).to_s if ref["schemaReference"]
|
|
859
1088
|
v
|
|
860
1089
|
else
|
|
861
1090
|
v
|
|
862
1091
|
end
|
|
863
1092
|
end
|
|
1093
|
+
when :link
|
|
1094
|
+
context.base.join(value).to_s
|
|
864
1095
|
when :object
|
|
865
1096
|
case value
|
|
866
1097
|
when Metadata then value.normalize!
|
|
@@ -872,6 +1103,14 @@ module RDF::Tabular
|
|
|
872
1103
|
end
|
|
873
1104
|
when :natural_language
|
|
874
1105
|
value.is_a?(Hash) ? value : {(context.default_language || 'und') => Array(value)}
|
|
1106
|
+
when :atomic
|
|
1107
|
+
case key
|
|
1108
|
+
when :minimum, :maximum, :minInclusive, :maxInclusive, :minExclusive, :maxExclusive
|
|
1109
|
+
# Convert to a typed literal based on `base`. This will be validated later
|
|
1110
|
+
RDF::Literal(value, datatype: DATATYPES[self.base.to_sym])
|
|
1111
|
+
else
|
|
1112
|
+
value
|
|
1113
|
+
end
|
|
875
1114
|
else
|
|
876
1115
|
value
|
|
877
1116
|
end
|
|
@@ -901,10 +1140,10 @@ module RDF::Tabular
|
|
|
901
1140
|
raise Error, "Value object may not contain keys other than @value, @type, or @language: #{value.to_json}"
|
|
902
1141
|
elsif (value.keys.sort & %w(@language @type)) == %w(@language @type)
|
|
903
1142
|
raise Error, "Value object may not contain both @type and @language: #{value.to_json}"
|
|
904
|
-
elsif value['@language'] && !BCP47::Language.identify(value['@language'])
|
|
905
|
-
warn "Value object with @language must use valid language: #{value.to_json}"
|
|
1143
|
+
elsif value['@language'] && !BCP47::Language.identify(value['@language'].to_s)
|
|
1144
|
+
warn "Value object with @language must use valid language: #{value.to_json}"
|
|
906
1145
|
value.delete('@language')
|
|
907
|
-
elsif value['@type'] && !context.expand_iri(value['@type'], vocab: true).absolute?
|
|
1146
|
+
elsif value['@type'] && (value['@type'].start_with?('_:') || !context.expand_iri(value['@type'], vocab: true).absolute?)
|
|
908
1147
|
raise Error, "Value object with @type must defined type: #{value.to_json}"
|
|
909
1148
|
end
|
|
910
1149
|
value
|
|
@@ -919,7 +1158,7 @@ module RDF::Tabular
|
|
|
919
1158
|
Array(v).each do |vv|
|
|
920
1159
|
# Validate that all type values transform to absolute IRIs
|
|
921
1160
|
resource = context.expand_iri(vv, vocab: true)
|
|
922
|
-
raise Error, "Invalid type #{vv} in JSON-LD context" unless resource.
|
|
1161
|
+
raise Error, "Invalid type #{vv} in JSON-LD context" unless resource.is_a?(RDF::URI) && resource.absolute?
|
|
923
1162
|
end
|
|
924
1163
|
nv[k] = v
|
|
925
1164
|
when /^(@|_:)/
|
|
@@ -981,13 +1220,6 @@ module RDF::Tabular
|
|
|
981
1220
|
end
|
|
982
1221
|
end
|
|
983
1222
|
|
|
984
|
-
def inherited_property_value(method)
|
|
985
|
-
# Inherited properties
|
|
986
|
-
object.fetch(method.to_sym) do
|
|
987
|
-
parent.send(method) if parent
|
|
988
|
-
end
|
|
989
|
-
end
|
|
990
|
-
|
|
991
1223
|
def default_value(prop)
|
|
992
1224
|
self.class.const_get(:DEFAULTS).merge(INHERITED_DEFAULTS)[prop]
|
|
993
1225
|
end
|
|
@@ -1033,24 +1265,30 @@ module RDF::Tabular
|
|
|
1033
1265
|
transformations: :array,
|
|
1034
1266
|
}.freeze
|
|
1035
1267
|
DEFAULTS = {
|
|
1036
|
-
tableDirection: "
|
|
1268
|
+
tableDirection: "auto".freeze,
|
|
1037
1269
|
}.freeze
|
|
1038
1270
|
REQUIRED = [:tables].freeze
|
|
1039
1271
|
|
|
1040
|
-
# Setters
|
|
1272
|
+
# Getters and Setters
|
|
1041
1273
|
PROPERTIES.each do |key, type|
|
|
1042
|
-
next if [:
|
|
1274
|
+
next if [:dialect].include?(key)
|
|
1275
|
+
|
|
1276
|
+
define_method(key) do
|
|
1277
|
+
object.fetch(key, DEFAULTS[key])
|
|
1278
|
+
end
|
|
1279
|
+
|
|
1280
|
+
next if [:tables, :tableSchema, :transformations].include?(key)
|
|
1043
1281
|
define_method("#{key}=".to_sym) do |value|
|
|
1044
1282
|
invalid = case key
|
|
1045
1283
|
when :tableDirection
|
|
1046
|
-
"rtl, ltr, or
|
|
1284
|
+
"rtl, ltr, or auto" unless %(rtl ltr auto).include?(value)
|
|
1047
1285
|
when :notes, :tables, :tableSchema, :dialect, :transformations
|
|
1048
1286
|
# We handle this through a separate setters
|
|
1049
1287
|
end
|
|
1050
1288
|
|
|
1051
1289
|
if invalid
|
|
1052
1290
|
warn "#{type} has invalid property '#{key}' (#{value.inspect}): expected #{invalid}"
|
|
1053
|
-
object
|
|
1291
|
+
object.delete(key)
|
|
1054
1292
|
else
|
|
1055
1293
|
object[key] = value
|
|
1056
1294
|
end
|
|
@@ -1063,15 +1301,6 @@ module RDF::Tabular
|
|
|
1063
1301
|
super || tables.any? {|t| t.has_annotations? }
|
|
1064
1302
|
end
|
|
1065
1303
|
|
|
1066
|
-
# Logic for accessing elements as accessors
|
|
1067
|
-
def method_missing(method, *args)
|
|
1068
|
-
if INHERITED_PROPERTIES.has_key?(method.to_sym)
|
|
1069
|
-
inherited_property_value(method.to_sym)
|
|
1070
|
-
else
|
|
1071
|
-
PROPERTIES.has_key?(method.to_sym) ? object[method.to_sym] : super
|
|
1072
|
-
end
|
|
1073
|
-
end
|
|
1074
|
-
|
|
1075
1304
|
##
|
|
1076
1305
|
# Iterate over all tables
|
|
1077
1306
|
# @yield [Table]
|
|
@@ -1102,7 +1331,7 @@ module RDF::Tabular
|
|
|
1102
1331
|
object.inject({
|
|
1103
1332
|
"@id" => (id.to_s if id),
|
|
1104
1333
|
"@type" => "AnnotatedTableGroup",
|
|
1105
|
-
"tables" =>
|
|
1334
|
+
"tables" => Array(self.tables).map(&:to_atd)
|
|
1106
1335
|
}) do |memo, (k, v)|
|
|
1107
1336
|
memo[k.to_s] ||= v
|
|
1108
1337
|
memo
|
|
@@ -1124,32 +1353,37 @@ module RDF::Tabular
|
|
|
1124
1353
|
}.freeze
|
|
1125
1354
|
DEFAULTS = {
|
|
1126
1355
|
suppressOutput: false,
|
|
1127
|
-
tableDirection: "
|
|
1356
|
+
tableDirection: "auto".freeze,
|
|
1128
1357
|
}.freeze
|
|
1129
1358
|
REQUIRED = [:url].freeze
|
|
1130
1359
|
|
|
1131
|
-
# Setters
|
|
1360
|
+
# Getters and Setters
|
|
1132
1361
|
PROPERTIES.each do |key, type|
|
|
1133
|
-
next if [:
|
|
1362
|
+
next if [:dialect, :url].include?(key)
|
|
1363
|
+
define_method(key) do
|
|
1364
|
+
object.fetch(key, DEFAULTS[key])
|
|
1365
|
+
end
|
|
1366
|
+
|
|
1367
|
+
next if [:tableSchema, :transformations].include?(key)
|
|
1134
1368
|
define_method("#{key}=".to_sym) do |value|
|
|
1135
1369
|
invalid = case key
|
|
1136
1370
|
when :suppressOutput
|
|
1137
1371
|
"boolean true or false" unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
|
|
1138
1372
|
when :tableDirection
|
|
1139
|
-
"rtl, ltr, or
|
|
1373
|
+
"rtl, ltr, or auto" unless %(rtl ltr auto).include?(value)
|
|
1140
1374
|
when :url
|
|
1141
|
-
"valid URL" unless value.is_a?(String) && base.join(value).valid?
|
|
1375
|
+
"valid URL" unless value.is_a?(String) && context.base.join(value).valid?
|
|
1142
1376
|
when :notes, :tableSchema, :dialect, :transformations
|
|
1143
1377
|
# We handle this through a separate setters
|
|
1144
1378
|
end
|
|
1145
1379
|
|
|
1146
1380
|
if invalid
|
|
1147
1381
|
warn "#{type} has invalid property '#{key}' (#{value.inspect}): expected #{invalid}"
|
|
1148
|
-
object
|
|
1382
|
+
object.delete(key)
|
|
1149
1383
|
elsif key == :url
|
|
1150
1384
|
# URL of CSV relative to metadata
|
|
1151
1385
|
object[:url] = value
|
|
1152
|
-
@url = base.join(value)
|
|
1386
|
+
@url = context.base.join(value)
|
|
1153
1387
|
@context.base = @url if @context # Use as base for expanding IRIs
|
|
1154
1388
|
else
|
|
1155
1389
|
object[key] = value
|
|
@@ -1180,22 +1414,13 @@ module RDF::Tabular
|
|
|
1180
1414
|
"@id" => (id.to_s if id),
|
|
1181
1415
|
"@type" => "AnnotatedTable",
|
|
1182
1416
|
"url" => self.url.to_s,
|
|
1183
|
-
"columns" => tableSchema.columns.map(&:to_atd),
|
|
1417
|
+
"columns" => Array(tableSchema ? tableSchema.columns : []).map(&:to_atd),
|
|
1184
1418
|
"rows" => []
|
|
1185
1419
|
}) do |memo, (k, v)|
|
|
1186
1420
|
memo[k.to_s] ||= v
|
|
1187
1421
|
memo
|
|
1188
1422
|
end.delete_if {|k,v| v.nil? || v.is_a?(Metadata) || k.to_s == "@context"}
|
|
1189
1423
|
end
|
|
1190
|
-
|
|
1191
|
-
# Logic for accessing elements as accessors
|
|
1192
|
-
def method_missing(method, *args)
|
|
1193
|
-
if INHERITED_PROPERTIES.has_key?(method.to_sym)
|
|
1194
|
-
inherited_property_value(method.to_sym)
|
|
1195
|
-
else
|
|
1196
|
-
PROPERTIES.has_key?(method.to_sym) ? object[method.to_sym] : super
|
|
1197
|
-
end
|
|
1198
|
-
end
|
|
1199
1424
|
end
|
|
1200
1425
|
|
|
1201
1426
|
class Schema < Metadata
|
|
@@ -1205,21 +1430,26 @@ module RDF::Tabular
|
|
|
1205
1430
|
columns: :array,
|
|
1206
1431
|
foreignKeys: :array,
|
|
1207
1432
|
primaryKey: :column_reference,
|
|
1433
|
+
rowTitles: :column_reference,
|
|
1208
1434
|
}.freeze
|
|
1209
1435
|
DEFAULTS = {}.freeze
|
|
1210
1436
|
REQUIRED = [].freeze
|
|
1211
1437
|
|
|
1212
|
-
# Setters
|
|
1438
|
+
# Getters and Setters
|
|
1213
1439
|
PROPERTIES.each do |key, type|
|
|
1440
|
+
define_method(key) do
|
|
1441
|
+
object.fetch(key, DEFAULTS[key])
|
|
1442
|
+
end
|
|
1443
|
+
|
|
1214
1444
|
define_method("#{key}=".to_sym) do |value|
|
|
1215
1445
|
invalid = case key
|
|
1216
|
-
when :primaryKey
|
|
1446
|
+
when :primaryKey, :rowTitles
|
|
1217
1447
|
"string or array of strings" unless !value.is_a?(Hash) && Array(value).all? {|v| v.is_a?(String)}
|
|
1218
1448
|
end
|
|
1219
1449
|
|
|
1220
1450
|
if invalid
|
|
1221
1451
|
warn "#{type} has invalid property '#{key}' (#{value.inspect}): expected #{invalid}"
|
|
1222
|
-
object
|
|
1452
|
+
object.delete(key)
|
|
1223
1453
|
else
|
|
1224
1454
|
object[key] = value
|
|
1225
1455
|
end
|
|
@@ -1270,12 +1500,21 @@ module RDF::Tabular
|
|
|
1270
1500
|
end
|
|
1271
1501
|
end
|
|
1272
1502
|
|
|
1273
|
-
|
|
1274
|
-
|
|
1275
|
-
|
|
1276
|
-
|
|
1277
|
-
|
|
1278
|
-
|
|
1503
|
+
##
|
|
1504
|
+
# List of foreign keys referencing the specified table
|
|
1505
|
+
#
|
|
1506
|
+
# @param [Table] table
|
|
1507
|
+
# @return [Array<Hash>]
|
|
1508
|
+
def foreign_keys_referencing(table)
|
|
1509
|
+
Array(foreignKeys).select do |fk|
|
|
1510
|
+
reference = fk['reference']
|
|
1511
|
+
if reference['resource']
|
|
1512
|
+
ref = context.base.join(reference['resource']).to_s
|
|
1513
|
+
table.url == ref
|
|
1514
|
+
else # schemaReference
|
|
1515
|
+
ref = context.base.join(reference['schemaReference']).to_s
|
|
1516
|
+
table.tableSchema.id == ref
|
|
1517
|
+
end
|
|
1279
1518
|
end
|
|
1280
1519
|
end
|
|
1281
1520
|
end
|
|
@@ -1321,8 +1560,12 @@ module RDF::Tabular
|
|
|
1321
1560
|
super || columns.any? {|c| c.has_annotations? }
|
|
1322
1561
|
end
|
|
1323
1562
|
|
|
1324
|
-
# Setters
|
|
1563
|
+
# Getters and Setters
|
|
1325
1564
|
PROPERTIES.each do |key, t|
|
|
1565
|
+
define_method(key) do
|
|
1566
|
+
object.fetch(key, DEFAULTS[key])
|
|
1567
|
+
end
|
|
1568
|
+
|
|
1326
1569
|
define_method("#{key}=".to_sym) do |value|
|
|
1327
1570
|
invalid = case key
|
|
1328
1571
|
when :name
|
|
@@ -1339,7 +1582,7 @@ module RDF::Tabular
|
|
|
1339
1582
|
object.delete(key) if object[key].nil?
|
|
1340
1583
|
elsif invalid
|
|
1341
1584
|
warn "#{type} has invalid property '#{key}' (#{value.inspect}): expected #{invalid}"
|
|
1342
|
-
object
|
|
1585
|
+
object.delete(key)
|
|
1343
1586
|
else
|
|
1344
1587
|
object[key] = value
|
|
1345
1588
|
end
|
|
@@ -1360,7 +1603,7 @@ module RDF::Tabular
|
|
|
1360
1603
|
# @return [RDF::URI]
|
|
1361
1604
|
def id;
|
|
1362
1605
|
url = table ? table.url : RDF::URI("")
|
|
1363
|
-
url + "#col=#{self.sourceNumber}";
|
|
1606
|
+
url.to_s + "#col=#{self.sourceNumber}";
|
|
1364
1607
|
end
|
|
1365
1608
|
|
|
1366
1609
|
# Return Annotated Column representation
|
|
@@ -1380,15 +1623,6 @@ module RDF::Tabular
|
|
|
1380
1623
|
memo
|
|
1381
1624
|
end.delete_if {|k,v| v.nil?}
|
|
1382
1625
|
end
|
|
1383
|
-
|
|
1384
|
-
# Logic for accessing elements as accessors
|
|
1385
|
-
def method_missing(method, *args)
|
|
1386
|
-
if INHERITED_PROPERTIES.has_key?(method.to_sym)
|
|
1387
|
-
inherited_property_value(method.to_sym)
|
|
1388
|
-
else
|
|
1389
|
-
PROPERTIES.has_key?(method.to_sym) ? object[method.to_sym] : super
|
|
1390
|
-
end
|
|
1391
|
-
end
|
|
1392
1626
|
end
|
|
1393
1627
|
|
|
1394
1628
|
class Transformation < Metadata
|
|
@@ -1404,8 +1638,13 @@ module RDF::Tabular
|
|
|
1404
1638
|
DEFAULTS = {}.freeze
|
|
1405
1639
|
REQUIRED = %w(url targetFormat scriptFormat).map(&:to_sym).freeze
|
|
1406
1640
|
|
|
1407
|
-
# Setters
|
|
1641
|
+
# Getters and Setters
|
|
1408
1642
|
PROPERTIES.each do |key, type|
|
|
1643
|
+
next if [:url].include?(key)
|
|
1644
|
+
define_method(key) do
|
|
1645
|
+
object.fetch(key, DEFAULTS[key])
|
|
1646
|
+
end
|
|
1647
|
+
|
|
1409
1648
|
define_method("#{key}=".to_sym) do |value|
|
|
1410
1649
|
invalid = case key
|
|
1411
1650
|
when :scriptFormat, :targetFormat
|
|
@@ -1416,17 +1655,12 @@ module RDF::Tabular
|
|
|
1416
1655
|
|
|
1417
1656
|
if invalid
|
|
1418
1657
|
warn "#{type} has invalid property '#{key}' (#{value.inspect}): expected #{invalid}"
|
|
1419
|
-
object
|
|
1658
|
+
object.delete(key)
|
|
1420
1659
|
else
|
|
1421
1660
|
object[key] = value
|
|
1422
1661
|
end
|
|
1423
1662
|
end
|
|
1424
1663
|
end
|
|
1425
|
-
|
|
1426
|
-
# Logic for accessing elements as accessors
|
|
1427
|
-
def method_missing(method, *args)
|
|
1428
|
-
PROPERTIES.has_key?(method.to_sym) ? object[method.to_sym] : super
|
|
1429
|
-
end
|
|
1430
1664
|
end
|
|
1431
1665
|
|
|
1432
1666
|
class Dialect < Metadata
|
|
@@ -1444,7 +1678,7 @@ module RDF::Tabular
|
|
|
1444
1678
|
skipColumns: 0,
|
|
1445
1679
|
skipInitialSpace: false,
|
|
1446
1680
|
skipRows: 0,
|
|
1447
|
-
trim:
|
|
1681
|
+
trim: true
|
|
1448
1682
|
}.freeze
|
|
1449
1683
|
|
|
1450
1684
|
PROPERTIES = {
|
|
@@ -1467,13 +1701,15 @@ module RDF::Tabular
|
|
|
1467
1701
|
|
|
1468
1702
|
REQUIRED = [].freeze
|
|
1469
1703
|
|
|
1470
|
-
# Setters
|
|
1704
|
+
# Getters and Setters
|
|
1471
1705
|
PROPERTIES.keys.each do |key|
|
|
1706
|
+
define_method(key) do
|
|
1707
|
+
object.fetch(key, DEFAULTS[key])
|
|
1708
|
+
end
|
|
1709
|
+
|
|
1472
1710
|
define_method("#{key}=".to_sym) do |value|
|
|
1473
1711
|
invalid = case key
|
|
1474
|
-
when :commentPrefix, :delimiter, :quoteChar
|
|
1475
|
-
"a single character string" unless value.is_a?(String) && value.length == 1
|
|
1476
|
-
when :lineTerminators
|
|
1712
|
+
when :commentPrefix, :delimiter, :quoteChar, :lineTerminators
|
|
1477
1713
|
"a string" unless value.is_a?(String)
|
|
1478
1714
|
when :doubleQuote, :header, :skipInitialSpace, :skipBlankRows
|
|
1479
1715
|
"boolean true or false" unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
|
|
@@ -1493,7 +1729,7 @@ module RDF::Tabular
|
|
|
1493
1729
|
object.delete(key) if object[key].nil?
|
|
1494
1730
|
elsif invalid
|
|
1495
1731
|
warn "#{type} has invalid property '#{key}' (#{value.inspect}): expected #{invalid}"
|
|
1496
|
-
object
|
|
1732
|
+
object.delete(key)
|
|
1497
1733
|
else
|
|
1498
1734
|
object[key] = value
|
|
1499
1735
|
end
|
|
@@ -1515,7 +1751,7 @@ module RDF::Tabular
|
|
|
1515
1751
|
# default for trim comes from skipInitialSpace
|
|
1516
1752
|
# @return [Boolean, String]
|
|
1517
1753
|
def trim
|
|
1518
|
-
object.fetch(:trim, self.skipInitialSpace ? 'start' :
|
|
1754
|
+
object.fetch(:trim, self.skipInitialSpace ? 'start' : true)
|
|
1519
1755
|
end
|
|
1520
1756
|
|
|
1521
1757
|
##
|
|
@@ -1546,7 +1782,8 @@ module RDF::Tabular
|
|
|
1546
1782
|
}
|
|
1547
1783
|
}
|
|
1548
1784
|
metadata ||= table # In case the embedded metadata becomes the final metadata
|
|
1549
|
-
metadata["lang"] = options[:lang] if options[:lang]
|
|
1785
|
+
lang = metadata["lang"] = options[:lang] if options[:lang]
|
|
1786
|
+
lang ||= 'und'
|
|
1550
1787
|
|
|
1551
1788
|
# Set encoding on input
|
|
1552
1789
|
csv = ::CSV.new(input, csv_options)
|
|
@@ -1575,9 +1812,9 @@ module RDF::Tabular
|
|
|
1575
1812
|
# Initialize titles
|
|
1576
1813
|
columns = table["tableSchema"]["columns"] ||= []
|
|
1577
1814
|
column = columns[index - skipCols] ||= {
|
|
1578
|
-
"titles" => {
|
|
1815
|
+
"titles" => {lang => []},
|
|
1579
1816
|
}
|
|
1580
|
-
column["titles"][
|
|
1817
|
+
column["titles"][lang] << value
|
|
1581
1818
|
end
|
|
1582
1819
|
end
|
|
1583
1820
|
debug("embedded_metadata") {"table: #{table.inspect}"}
|
|
@@ -1585,20 +1822,12 @@ module RDF::Tabular
|
|
|
1585
1822
|
|
|
1586
1823
|
Table.new(table, options.merge(reason: "load embedded metadata: #{table['@id']}"))
|
|
1587
1824
|
end
|
|
1588
|
-
|
|
1589
|
-
# Logic for accessing elements as accessors
|
|
1590
|
-
def method_missing(method, *args)
|
|
1591
|
-
if DEFAULTS.has_key?(method.to_sym)
|
|
1592
|
-
# As set, or with default
|
|
1593
|
-
object.fetch(method.to_sym, DEFAULTS[method.to_sym])
|
|
1594
|
-
else
|
|
1595
|
-
super
|
|
1596
|
-
end
|
|
1597
|
-
end
|
|
1598
1825
|
end
|
|
1599
1826
|
|
|
1600
1827
|
class Datatype < Metadata
|
|
1601
1828
|
PROPERTIES = {
|
|
1829
|
+
:@id => :link,
|
|
1830
|
+
:@type => :atomic,
|
|
1602
1831
|
base: :atomic,
|
|
1603
1832
|
format: :atomic,
|
|
1604
1833
|
length: :atomic,
|
|
@@ -1612,50 +1841,248 @@ module RDF::Tabular
|
|
|
1612
1841
|
maxExclusive: :atomic,
|
|
1613
1842
|
}.freeze
|
|
1614
1843
|
REQUIRED = [].freeze
|
|
1615
|
-
DEFAULTS = {
|
|
1844
|
+
DEFAULTS = {
|
|
1845
|
+
base: "string"
|
|
1846
|
+
}.freeze
|
|
1616
1847
|
|
|
1617
1848
|
# Override `base` in Metadata
|
|
1618
1849
|
def base; object[:base]; end
|
|
1619
1850
|
|
|
1620
|
-
# Setters
|
|
1851
|
+
# Getters and Setters
|
|
1621
1852
|
PROPERTIES.each do |key, type|
|
|
1853
|
+
define_method(key) do
|
|
1854
|
+
object.fetch(key, DEFAULTS[key])
|
|
1855
|
+
end
|
|
1856
|
+
|
|
1622
1857
|
define_method("#{key}=".to_sym) do |value|
|
|
1623
1858
|
invalid = case key
|
|
1859
|
+
when :base
|
|
1860
|
+
"built-in datatype" unless DATATYPES.keys.map(&:to_s).include?(value)
|
|
1624
1861
|
when :minimum, :maximum, :minInclusive, :maxInclusive, :minExclusive, :maxExclusive
|
|
1625
1862
|
"numeric or valid date/time" unless value.is_a?(Numeric) ||
|
|
1626
1863
|
RDF::Literal::Date.new(value.to_s).valid? ||
|
|
1627
1864
|
RDF::Literal::Time.new(value.to_s).valid? ||
|
|
1628
1865
|
RDF::Literal::DateTime.new(value.to_s).valid?
|
|
1629
1866
|
when :format
|
|
1630
|
-
|
|
1631
|
-
|
|
1632
|
-
|
|
1633
|
-
|
|
1634
|
-
|
|
1635
|
-
object
|
|
1867
|
+
case value
|
|
1868
|
+
when String
|
|
1869
|
+
nil
|
|
1870
|
+
when Hash
|
|
1871
|
+
unless (value.keys.map(&:to_s) - %w(groupChar decimalChar pattern)).empty?
|
|
1872
|
+
"an object containing only groupChar, decimalChar, and/or pattern"
|
|
1636
1873
|
end
|
|
1874
|
+
else
|
|
1875
|
+
"a string or object"
|
|
1637
1876
|
end
|
|
1638
1877
|
when :length, :minLength, :maxLength
|
|
1639
1878
|
if !(value.is_a?(Numeric) && value.integer? && value >= 0)
|
|
1640
1879
|
"a non-negative integer"
|
|
1641
|
-
elsif key != :length && object[:length] && value != object[:length]
|
|
1642
|
-
# Applications must raise an error if length, maxLength or minLength are specified and the cell value is not a list (ie separator is not specified), a string or one of its subtypes, or a binary value.
|
|
1643
|
-
"both length and #{key} requires they be equal"
|
|
1644
1880
|
end
|
|
1645
1881
|
end
|
|
1646
1882
|
|
|
1647
1883
|
if invalid
|
|
1648
|
-
warn "#{type} has invalid property '#{key}' (#{value.inspect}): expected #{invalid}"
|
|
1649
|
-
object
|
|
1884
|
+
warn "#{self.type} has invalid property '#{key}' (#{value.inspect}): expected #{invalid}"
|
|
1885
|
+
object.delete(key)
|
|
1650
1886
|
else
|
|
1651
1887
|
object[key] = value
|
|
1652
1888
|
end
|
|
1653
1889
|
end
|
|
1654
1890
|
end
|
|
1655
1891
|
|
|
1656
|
-
|
|
1657
|
-
|
|
1658
|
-
|
|
1892
|
+
##
|
|
1893
|
+
# Parse the date format (if provided), and match against the value (if provided)
|
|
1894
|
+
# Otherwise, validate format and raise an error
|
|
1895
|
+
#
|
|
1896
|
+
# @param [String] format
|
|
1897
|
+
# @param [String] value
|
|
1898
|
+
# @return [String] XMLSchema version of value
|
|
1899
|
+
# @raise [ArgumentError] if format is not valid, or nil, if value does not match
|
|
1900
|
+
def parse_uax35_date(format, value)
|
|
1901
|
+
tz, date_format, time_format = nil, nil, nil
|
|
1902
|
+
return value unless format
|
|
1903
|
+
value ||= ""
|
|
1904
|
+
|
|
1905
|
+
# Extract tz info
|
|
1906
|
+
if md = format.match(/^(.*[dyms])+(\s*[xX]{1,5})$/)
|
|
1907
|
+
format, tz = md[1], md[2]
|
|
1908
|
+
end
|
|
1909
|
+
|
|
1910
|
+
date_format, time_format = format.split(' ')
|
|
1911
|
+
date_format, time_format = nil, date_format if self.base.to_sym == :time
|
|
1912
|
+
|
|
1913
|
+
# Extract date, of specified
|
|
1914
|
+
date_part = case date_format
|
|
1915
|
+
when 'yyyy-MM-dd' then value.match(/^(?<yr>\d{4})-(?<mo>\d{2})-(?<da>\d{2})/)
|
|
1916
|
+
when 'yyyyMMdd' then value.match(/^(?<yr>\d{4})(?<mo>\d{2})(?<da>\d{2})/)
|
|
1917
|
+
when 'dd-MM-yyyy' then value.match(/^(?<da>\d{2})-(?<mo>\d{2})-(?<yr>\d{4})/)
|
|
1918
|
+
when 'd-M-yyyy' then value.match(/^(?<da>\d{1,2})-(?<mo>\d{1,2})-(?<yr>\d{4})/)
|
|
1919
|
+
when 'MM-dd-yyyy' then value.match(/^(?<mo>\d{2})-(?<da>\d{2})-(?<yr>\d{4})/)
|
|
1920
|
+
when 'M-d-yyyy' then value.match(/^(?<mo>\d{1,2})-(?<da>\d{1,2})-(?<yr>\d{4})/)
|
|
1921
|
+
when 'dd/MM/yyyy' then value.match(/^(?<da>\d{2})\/(?<mo>\d{2})\/(?<yr>\d{4})/)
|
|
1922
|
+
when 'd/M/yyyy' then value.match(/^(?<da>\d{1,2})\/(?<mo>\d{1,2})\/(?<yr>\d{4})/)
|
|
1923
|
+
when 'MM/dd/yyyy' then value.match(/^(?<mo>\d{2})\/(?<da>\d{2})\/(?<yr>\d{4})/)
|
|
1924
|
+
when 'M/d/yyyy' then value.match(/^(?<mo>\d{1,2})\/(?<da>\d{1,2})\/(?<yr>\d{4})/)
|
|
1925
|
+
when 'dd.MM.yyyy' then value.match(/^(?<da>\d{2})\.(?<mo>\d{2})\.(?<yr>\d{4})/)
|
|
1926
|
+
when 'd.M.yyyy' then value.match(/^(?<da>\d{1,2})\.(?<mo>\d{1,2})\.(?<yr>\d{4})/)
|
|
1927
|
+
when 'MM.dd.yyyy' then value.match(/^(?<mo>\d{2})\.(?<da>\d{2})\.(?<yr>\d{4})/)
|
|
1928
|
+
when 'M.d.yyyy' then value.match(/^(?<mo>\d{1,2})\.(?<da>\d{1,2})\.(?<yr>\d{4})/)
|
|
1929
|
+
when 'yyyy-MM-ddTHH:mm' then value.match(/^(?<yr>\d{4})-(?<mo>\d{2})-(?<da>\d{2})T(?<hr>\d{2}):(?<mi>\d{2})(?<se>(?<ms>))/)
|
|
1930
|
+
when 'yyyy-MM-ddTHH:mm:ss' then value.match(/^(?<yr>\d{4})-(?<mo>\d{2})-(?<da>\d{2})T(?<hr>\d{2}):(?<mi>\d{2}):(?<se>\d{2})(?<ms>)/)
|
|
1931
|
+
when /yyyy-MM-ddTHH:mm:ss\.S+/
|
|
1932
|
+
md = value.match(/^(?<yr>\d{4})-(?<mo>\d{2})-(?<da>\d{2})T(?<hr>\d{2}):(?<mi>\d{2}):(?<se>\d{2})\.(?<ms>\d+)/)
|
|
1933
|
+
num_ms = date_format.match(/S+/).to_s.length
|
|
1934
|
+
md if md && md[:ms].length <= num_ms
|
|
1935
|
+
else
|
|
1936
|
+
raise ArgumentError, "unrecognized date/time format #{date_format}" if date_format
|
|
1937
|
+
nil
|
|
1938
|
+
end
|
|
1939
|
+
|
|
1940
|
+
# Forward past date part
|
|
1941
|
+
if date_part
|
|
1942
|
+
value = value[date_part.to_s.length..-1]
|
|
1943
|
+
value = value.lstrip if date_part && value.start_with?(' ')
|
|
1944
|
+
end
|
|
1945
|
+
|
|
1946
|
+
# Extract time, of specified
|
|
1947
|
+
time_part = case time_format
|
|
1948
|
+
when 'HH:mm:ss' then value.match(/^(?<hr>\d{2}):(?<mi>\d{2}):(?<se>\d{2})(?<ms>)/)
|
|
1949
|
+
when 'HHmmss' then value.match(/^(?<hr>\d{2})(?<mi>\d{2})(?<se>\d{2})(?<ms>)/)
|
|
1950
|
+
when 'HH:mm' then value.match(/^(?<hr>\d{2}):(?<mi>\d{2})(?<se>)(?<ms>)/)
|
|
1951
|
+
when 'HHmm' then value.match(/^(?<hr>\d{2})(?<mi>\d{2})(?<se>)(?<ms>)/)
|
|
1952
|
+
when /HH:mm:ss\.S+/
|
|
1953
|
+
md = value.match(/^(?<hr>\d{2}):(?<mi>\d{2}):(?<se>\d{2})\.(?<ms>\d+)/)
|
|
1954
|
+
num_ms = time_format.match(/S+/).to_s.length
|
|
1955
|
+
md if md && md[:ms].length <= num_ms
|
|
1956
|
+
else
|
|
1957
|
+
raise ArgumentError, "unrecognized date/time format #{time_format}" if time_format
|
|
1958
|
+
nil
|
|
1959
|
+
end
|
|
1960
|
+
|
|
1961
|
+
# If there's a date_format but no date_part, match fails
|
|
1962
|
+
return nil if date_format && date_part.nil?
|
|
1963
|
+
|
|
1964
|
+
# If there's a time_format but no time_part, match fails
|
|
1965
|
+
return nil if time_format && time_part.nil?
|
|
1966
|
+
|
|
1967
|
+
# Forward past time part
|
|
1968
|
+
value = value[time_part.to_s.length..-1] if time_part
|
|
1969
|
+
|
|
1970
|
+
# Use datetime match for time
|
|
1971
|
+
time_part = date_part if date_part && date_part.names.include?("hr")
|
|
1972
|
+
|
|
1973
|
+
# If there's a timezone, it may optionally start with whitespace
|
|
1974
|
+
value = value.lstrip if tz.to_s.start_with?(' ')
|
|
1975
|
+
tz_part = value if tz
|
|
1976
|
+
|
|
1977
|
+
# Compose normalized value
|
|
1978
|
+
vd = ("%04d-%02d-%02d" % [date_part[:yr].to_i, date_part[:mo].to_i, date_part[:da].to_i]) if date_part
|
|
1979
|
+
vt = ("%02d:%02d:%02d" % [time_part[:hr].to_i, time_part[:mi].to_i, time_part[:se].to_i]) if time_part
|
|
1980
|
+
|
|
1981
|
+
# Add milliseconds, if matched
|
|
1982
|
+
vt += ".#{time_part[:ms]}" if time_part && !time_part[:ms].empty?
|
|
1983
|
+
|
|
1984
|
+
value = [vd, vt].compact.join('T')
|
|
1985
|
+
value += tz_part.to_s
|
|
1986
|
+
end
|
|
1987
|
+
|
|
1988
|
+
##
|
|
1989
|
+
# Parse the date format (if provided), and match against the value (if provided)
|
|
1990
|
+
# Otherwise, validate format and raise an error
|
|
1991
|
+
#
|
|
1992
|
+
# @param [String] pattern
|
|
1993
|
+
# @param [String] value
|
|
1994
|
+
# @param [String] groupChar
|
|
1995
|
+
# @param [String] decimalChar
|
|
1996
|
+
# @return [String] XMLSchema version of value or nil, if value does not match
|
|
1997
|
+
# @raise [ArgumentError] if format is not valid
|
|
1998
|
+
def parse_uax35_number(pattern, value, groupChar=",", decimalChar=".")
|
|
1999
|
+
return value if pattern.to_s.empty?
|
|
2000
|
+
value ||= ""
|
|
2001
|
+
|
|
2002
|
+
re = build_number_re(pattern, groupChar, decimalChar)
|
|
2003
|
+
|
|
2004
|
+
# Upcase value and remove internal spaces
|
|
2005
|
+
value = value.upcase.gsub(/\s+/, '')
|
|
2006
|
+
|
|
2007
|
+
# Remove groupChar from value
|
|
2008
|
+
value = value.gsub(groupChar, '')
|
|
2009
|
+
|
|
2010
|
+
# Replace decimalChar with "."
|
|
2011
|
+
value = value.gsub(decimalChar, '.')
|
|
2012
|
+
|
|
2013
|
+
if value =~ re
|
|
2014
|
+
# result re-assembles parts removed from value
|
|
2015
|
+
value
|
|
2016
|
+
else
|
|
2017
|
+
# no match
|
|
2018
|
+
nil
|
|
2019
|
+
end
|
|
2020
|
+
end
|
|
2021
|
+
|
|
2022
|
+
# Build a regular expression from the provided pattern to match value, after suitable modifications
|
|
2023
|
+
#
|
|
2024
|
+
# @param [String] pattern
|
|
2025
|
+
# @param [String] groupChar
|
|
2026
|
+
# @param [String] decimalChar
|
|
2027
|
+
# @return [Regexp] Regular expression matching value
|
|
2028
|
+
# @raise [ArgumentError] if format is not valid
|
|
2029
|
+
def build_number_re(pattern, groupChar, decimalChar)
|
|
2030
|
+
# pattern must be composed of only 0, #, decimalChar, groupChar, E, +, -, %, and ‰
|
|
2031
|
+
legal_number_pattern = /\A
|
|
2032
|
+
([%‰])?
|
|
2033
|
+
([+-])?
|
|
2034
|
+
# Mantissa
|
|
2035
|
+
(\#|#{groupChar == '.' ? '\.' : groupChar})*
|
|
2036
|
+
(0|#{groupChar == '.' ? '\.' : groupChar})*
|
|
2037
|
+
# Fractional
|
|
2038
|
+
(?:#{decimalChar == '.' ? '\.' : decimalChar}
|
|
2039
|
+
(0|#{groupChar == '.' ? '\.' : groupChar})*
|
|
2040
|
+
(\#|#{groupChar == '.' ? '\.' : groupChar})*
|
|
2041
|
+
# Exponent
|
|
2042
|
+
(E
|
|
2043
|
+
[+-]?
|
|
2044
|
+
(?:\#|#{groupChar == '.' ? '\.' : groupChar})*
|
|
2045
|
+
(?:0|#{groupChar == '.' ? '\.' : groupChar})*
|
|
2046
|
+
)?
|
|
2047
|
+
)?
|
|
2048
|
+
([%‰])?
|
|
2049
|
+
\Z/x
|
|
2050
|
+
|
|
2051
|
+
unless pattern =~ legal_number_pattern
|
|
2052
|
+
raise ArgumentError, "unrecognized number pattern #{pattern}"
|
|
2053
|
+
end
|
|
2054
|
+
|
|
2055
|
+
# Remove groupChar from pattern
|
|
2056
|
+
pattern = pattern.gsub(groupChar, '')
|
|
2057
|
+
|
|
2058
|
+
# Replace decimalChar with "."
|
|
2059
|
+
pattern = pattern.gsub(decimalChar, '.')
|
|
2060
|
+
|
|
2061
|
+
# Split on decimalChar and E
|
|
2062
|
+
parts = pattern.split(/[\.E]/)
|
|
2063
|
+
|
|
2064
|
+
# Construct regular expression
|
|
2065
|
+
mantissa_str = case parts[0]
|
|
2066
|
+
when /\A([%‰])?([+-])?#+(0+)([%‰])?\Z/ then "#{$1}#{$2}\\d{#{$3.length},}#{$4}"
|
|
2067
|
+
when /\A([%‰])?([+-])?(0+)([%‰])?\Z/ then "#{$1}#{$2}\\d{#{$3.length}}#{$4}"
|
|
2068
|
+
when /\A([%‰])?([+-])?#+([%‰])?\Z/ then "#{$1}#{$2}\\d*#{$4}"
|
|
2069
|
+
end
|
|
2070
|
+
|
|
2071
|
+
fractional_str = case parts[1]
|
|
2072
|
+
when /\A(0+)(#+)([%‰])?\Z/ then "\\d{#{$1.length},#{$1.length+$2.length}}#{$3}"
|
|
2073
|
+
when /\A(0+)([%‰])?\Z/ then "\\d{#{$1.length}}#{$2}"
|
|
2074
|
+
when /\A(#+)([%‰])?\Z/ then "\\d{,#{$1.length}}#{$2}"
|
|
2075
|
+
end
|
|
2076
|
+
fractional_str = "\\.#{fractional_str}" if fractional_str
|
|
2077
|
+
|
|
2078
|
+
exponent_str = case parts[2]
|
|
2079
|
+
when /\A([+-])?(#+)(0+)([%‰])?\Z/ then "#{$1}\\d{#{$3.length},#{$2.length+$3.length}}#{$4}"
|
|
2080
|
+
when /\A([+-])?(0+)([%‰])?\Z/ then "#{$1}\\d{#{$2.length}}#{$3}"
|
|
2081
|
+
when /\A([+-])?(#+)([%‰])?\Z/ then "#{$1}\\d{,#{$2.length}}#{$3}"
|
|
2082
|
+
end
|
|
2083
|
+
exponent_str = "E#{exponent_str}" if exponent_str
|
|
2084
|
+
|
|
2085
|
+
Regexp.new("^#{mantissa_str}#{fractional_str}#{exponent_str}$")
|
|
1659
2086
|
end
|
|
1660
2087
|
end
|
|
1661
2088
|
|
|
@@ -1697,6 +2124,10 @@ module RDF::Tabular
|
|
|
1697
2124
|
"errors" => self.errors
|
|
1698
2125
|
}.delete_if {|k,v| Array(v).empty?}
|
|
1699
2126
|
end
|
|
2127
|
+
|
|
2128
|
+
def inspect
|
|
2129
|
+
self.class.name + to_atd.inspect
|
|
2130
|
+
end
|
|
1700
2131
|
end
|
|
1701
2132
|
|
|
1702
2133
|
# Row values, hashed by `name`
|
|
@@ -1715,6 +2146,16 @@ module RDF::Tabular
|
|
|
1715
2146
|
# @return [Table]
|
|
1716
2147
|
attr_reader :table
|
|
1717
2148
|
|
|
2149
|
+
#
|
|
2150
|
+
# Cells providing a unique row identifier
|
|
2151
|
+
# @return [Array<Cell>]
|
|
2152
|
+
attr_reader :primaryKey
|
|
2153
|
+
|
|
2154
|
+
#
|
|
2155
|
+
# Title(s) of this row
|
|
2156
|
+
# @return [Array<RDF::Literal>]
|
|
2157
|
+
attr_reader :titles
|
|
2158
|
+
|
|
1718
2159
|
#
|
|
1719
2160
|
# Context from Table with base set to table URL for expanding URI Templates
|
|
1720
2161
|
# @return [JSON::LD::Context]
|
|
@@ -1725,8 +2166,10 @@ module RDF::Tabular
|
|
|
1725
2166
|
# @param [Metadata] metadata for Table
|
|
1726
2167
|
# @param [Integer] number 1-based row number after skipped/header rows
|
|
1727
2168
|
# @param [Integer] source_number 1-based row number from source
|
|
2169
|
+
# @param [Hash{Symbol => Object}] options ({})
|
|
2170
|
+
# @option options [Boolean] :validate check for PK/FK consistency
|
|
1728
2171
|
# @return [Row]
|
|
1729
|
-
def initialize(row, metadata, number, source_number)
|
|
2172
|
+
def initialize(row, metadata, number, source_number, options = {})
|
|
1730
2173
|
@table = metadata
|
|
1731
2174
|
@number = number
|
|
1732
2175
|
@sourceNumber = source_number
|
|
@@ -1748,7 +2191,7 @@ module RDF::Tabular
|
|
|
1748
2191
|
end
|
|
1749
2192
|
|
|
1750
2193
|
# Make sure that the row length is at least as long as the number of column definitions, to implicitly include virtual columns
|
|
1751
|
-
columns.each_with_index {|c, index| row[index] ||=
|
|
2194
|
+
columns.each_with_index {|c, index| row[index] ||= c.null}
|
|
1752
2195
|
|
|
1753
2196
|
row.each_with_index do |value, index|
|
|
1754
2197
|
|
|
@@ -1764,7 +2207,7 @@ module RDF::Tabular
|
|
|
1764
2207
|
|
|
1765
2208
|
@values << cell = Cell.new(metadata, column, self, value)
|
|
1766
2209
|
|
|
1767
|
-
datatype = column.datatype || Datatype.new(base: "string", parent: column)
|
|
2210
|
+
datatype = column.datatype || Datatype.new({base: "string"}, parent: column)
|
|
1768
2211
|
value = value.gsub(/\r\t\a/, ' ') unless %w(string json xml html anyAtomicType any).include?(datatype.base)
|
|
1769
2212
|
value = value.strip.gsub(/\s+/, ' ') unless %w(string json xml html anyAtomicType any normalizedString).include?(datatype.base)
|
|
1770
2213
|
# if the resulting string is an empty string, apply the remaining steps to the string given by the default property
|
|
@@ -1787,23 +2230,35 @@ module RDF::Tabular
|
|
|
1787
2230
|
v.strip!
|
|
1788
2231
|
end
|
|
1789
2232
|
|
|
1790
|
-
expanded_dt = metadata.context.expand_iri(datatype.base, vocab: true)
|
|
2233
|
+
expanded_dt = datatype.id || metadata.context.expand_iri(datatype.base, vocab: true)
|
|
1791
2234
|
if (lit_or_errors = value_matching_datatype(v.dup, datatype, expanded_dt, column.lang)).is_a?(RDF::Literal)
|
|
1792
2235
|
lit_or_errors
|
|
1793
2236
|
else
|
|
1794
2237
|
cell_errors += lit_or_errors
|
|
1795
|
-
RDF::Literal(v, language: column.lang)
|
|
2238
|
+
RDF::Literal(v, language: (column.lang unless column.lang == "und"))
|
|
1796
2239
|
end
|
|
1797
2240
|
end
|
|
1798
2241
|
end.compact
|
|
1799
2242
|
|
|
2243
|
+
# Check for required values
|
|
2244
|
+
if column.required && (cell_values.any? {|v| v.to_s.empty?} || cell_values.empty?)
|
|
2245
|
+
cell_errors << "Required column has empty value(s): #{cell_values.map(&:to_s).inspect}"
|
|
2246
|
+
end
|
|
1800
2247
|
cell.value = (column.separator ? cell_values : cell_values.first)
|
|
1801
2248
|
cell.errors = cell_errors
|
|
1802
|
-
metadata.send(:debug, "#{self.number}: each_cell ##{self.sourceNumber},#{cell.column.sourceNumber}", cell.errors.join("\n")) unless cell_errors.empty?
|
|
1803
2249
|
|
|
1804
2250
|
map_values[columns[index - skipColumns].name] = (column.separator ? cell_values.map(&:to_s) : cell_values.first.to_s)
|
|
1805
2251
|
end
|
|
1806
2252
|
|
|
2253
|
+
# Record primaryKey if validating
|
|
2254
|
+
@primaryKey = @values.
|
|
2255
|
+
select {|cell| Array(table.tableSchema.primaryKey).include?(cell.column.name)} if options[:validate]
|
|
2256
|
+
|
|
2257
|
+
# Record any row titles
|
|
2258
|
+
@titles = @values.
|
|
2259
|
+
select {|cell| Array(table.tableSchema.rowTitles).include?(cell.column.name)}.
|
|
2260
|
+
map(&:value)
|
|
2261
|
+
|
|
1807
2262
|
# Map URLs for row
|
|
1808
2263
|
@values.each_with_index do |cell, index|
|
|
1809
2264
|
mapped_values = map_values.merge(
|
|
@@ -1824,30 +2279,24 @@ module RDF::Tabular
|
|
|
1824
2279
|
{
|
|
1825
2280
|
"@id" => id.to_s,
|
|
1826
2281
|
"@type" => "Row",
|
|
1827
|
-
"table" => (table.id
|
|
2282
|
+
"table" => (table.id || table.url),
|
|
1828
2283
|
"number" => self.number,
|
|
1829
2284
|
"sourceNumber" => self.sourceNumber,
|
|
1830
|
-
"cells" => @values.map(&:
|
|
2285
|
+
"cells" => @values.map(&:value)
|
|
1831
2286
|
}.delete_if {|k,v| v.nil?}
|
|
1832
2287
|
end
|
|
1833
2288
|
|
|
2289
|
+
def inspect
|
|
2290
|
+
self.class.name + to_atd.inspect
|
|
2291
|
+
end
|
|
2292
|
+
|
|
1834
2293
|
private
|
|
1835
2294
|
#
|
|
1836
2295
|
# given a datatype specification, return a literal matching that specififcation, if found, otherwise nil
|
|
1837
2296
|
# @return [RDF::Literal]
|
|
1838
2297
|
def value_matching_datatype(value, datatype, expanded_dt, language)
|
|
1839
|
-
value_errors = []
|
|
1840
|
-
|
|
1841
|
-
# Check constraints
|
|
1842
|
-
if datatype.length && value.length != datatype.length
|
|
1843
|
-
value_errors << "#{value} does not have length #{datatype.length}"
|
|
1844
|
-
end
|
|
1845
|
-
if datatype.minLength && value.length < datatype.minLength
|
|
1846
|
-
value_errors << "#{value} does not have length >= #{datatype.minLength}"
|
|
1847
|
-
end
|
|
1848
|
-
if datatype.maxLength && value.length > datatype.maxLength
|
|
1849
|
-
value_errors << "#{value} does not have length <= #{datatype.maxLength}"
|
|
1850
|
-
end
|
|
2298
|
+
lit, value_errors = nil, []
|
|
2299
|
+
original_value = value.dup
|
|
1851
2300
|
|
|
1852
2301
|
format = datatype.format
|
|
1853
2302
|
# Datatype specific constraints and conversions
|
|
@@ -1857,29 +2306,39 @@ module RDF::Tabular
|
|
|
1857
2306
|
:unsignedLong, :unsignedInt, :unsignedShort, :unsignedByte,
|
|
1858
2307
|
:nonPositiveInteger, :negativeInteger,
|
|
1859
2308
|
:double, :float, :number
|
|
2309
|
+
|
|
1860
2310
|
# Normalize representation based on numeric-specific facets
|
|
1861
|
-
|
|
1862
|
-
|
|
1863
|
-
|
|
1864
|
-
|
|
1865
|
-
|
|
2311
|
+
|
|
2312
|
+
format = case format
|
|
2313
|
+
when String then {"pattern" => format}
|
|
2314
|
+
when Hash then format
|
|
2315
|
+
else {}
|
|
1866
2316
|
end
|
|
1867
|
-
|
|
1868
|
-
|
|
1869
|
-
|
|
2317
|
+
|
|
2318
|
+
groupChar = format["groupChar"]
|
|
2319
|
+
decimalChar = format["decimalChar"] || '.'
|
|
2320
|
+
pattern = format["pattern"]
|
|
2321
|
+
|
|
2322
|
+
if !datatype.parse_uax35_number(pattern, value, groupChar || ",", decimalChar)
|
|
2323
|
+
value_errors << "#{value} does not match pattern #{pattern}"
|
|
1870
2324
|
end
|
|
1871
|
-
|
|
1872
|
-
|
|
2325
|
+
|
|
2326
|
+
# pattern facet failed
|
|
2327
|
+
value_errors << "#{value} has repeating #{groupChar.inspect}" if groupChar && value.include?(groupChar*2)
|
|
2328
|
+
value = value.gsub(groupChar, '') if groupChar
|
|
2329
|
+
value = value.sub(decimalChar, '.')
|
|
1873
2330
|
|
|
1874
2331
|
# Extract percent or per-mille sign
|
|
1875
2332
|
percent = permille = false
|
|
1876
|
-
|
|
1877
|
-
|
|
1878
|
-
|
|
1879
|
-
|
|
1880
|
-
|
|
1881
|
-
|
|
1882
|
-
|
|
2333
|
+
if groupChar
|
|
2334
|
+
case value
|
|
2335
|
+
when /%/
|
|
2336
|
+
value = value.sub('%', '')
|
|
2337
|
+
percent = true
|
|
2338
|
+
when /‰/
|
|
2339
|
+
value = value.sub('‰', '')
|
|
2340
|
+
permille = true
|
|
2341
|
+
end
|
|
1883
2342
|
end
|
|
1884
2343
|
|
|
1885
2344
|
lit = RDF::Literal(value, datatype: expanded_dt)
|
|
@@ -1889,129 +2348,117 @@ module RDF::Tabular
|
|
|
1889
2348
|
o = o / 1000 if permille
|
|
1890
2349
|
lit = RDF::Literal(o, datatype: expanded_dt)
|
|
1891
2350
|
end
|
|
2351
|
+
|
|
2352
|
+
if !lit.plain? && datatype.minimum && lit < datatype.minimum
|
|
2353
|
+
value_errors << "#{value} < minimum #{datatype.minimum}"
|
|
2354
|
+
end
|
|
2355
|
+
case
|
|
2356
|
+
when datatype.minimum && lit < datatype.minimum
|
|
2357
|
+
value_errors << "#{value} < minimum #{datatype.minimum}"
|
|
2358
|
+
when datatype.maximum && lit > datatype.maximum
|
|
2359
|
+
value_errors << "#{value} > maximum #{datatype.maximum}"
|
|
2360
|
+
when datatype.minInclusive && lit < datatype.minInclusive
|
|
2361
|
+
value_errors << "#{value} < minInclusive #{datatype.minInclusive}"
|
|
2362
|
+
when datatype.maxInclusive && lit > datatype.maxInclusive
|
|
2363
|
+
value_errors << "#{value} > maxInclusive #{datatype.maxInclusive}"
|
|
2364
|
+
when datatype.minExclusive && lit <= datatype.minExclusive
|
|
2365
|
+
value_errors << "#{value} <= minExclusive #{datatype.minExclusive}"
|
|
2366
|
+
when datatype.maxExclusive && lit >= datatype.maxExclusive
|
|
2367
|
+
value_errors << "#{value} ?= maxExclusive #{datatype.maxExclusive}"
|
|
2368
|
+
end
|
|
1892
2369
|
when :boolean
|
|
1893
|
-
|
|
2370
|
+
if format
|
|
1894
2371
|
# True/False determined by Y|N values
|
|
1895
2372
|
t, f = format.to_s.split('|', 2)
|
|
1896
2373
|
case
|
|
1897
2374
|
when value == t
|
|
1898
|
-
|
|
2375
|
+
lit = RDF::Literal::TRUE
|
|
1899
2376
|
when value == f
|
|
1900
|
-
|
|
2377
|
+
lit = RDF::Literal::FALSE
|
|
1901
2378
|
else
|
|
1902
2379
|
value_errors << "#{value} does not match boolean format #{format}"
|
|
1903
|
-
RDF::Literal::Boolean.new(value)
|
|
1904
2380
|
end
|
|
1905
2381
|
else
|
|
1906
2382
|
if %w(1 true).include?(value.downcase)
|
|
1907
|
-
RDF::Literal::TRUE
|
|
2383
|
+
lit = RDF::Literal::TRUE
|
|
1908
2384
|
elsif %w(0 false).include?(value.downcase)
|
|
1909
|
-
RDF::Literal::FALSE
|
|
2385
|
+
lit = RDF::Literal::FALSE
|
|
2386
|
+
else
|
|
2387
|
+
value_errors << "#{value} does not match boolean"
|
|
1910
2388
|
end
|
|
1911
2389
|
end
|
|
1912
2390
|
when :date, :time, :dateTime, :dateTimeStamp, :datetime
|
|
1913
|
-
|
|
1914
|
-
|
|
1915
|
-
|
|
1916
|
-
|
|
1917
|
-
if format && (md = format.match(/^(.*[dyms])+(\s*[xX]{1,5})$/))
|
|
1918
|
-
format, tz = md[1], md[2]
|
|
2391
|
+
if value = datatype.parse_uax35_date(format, value)
|
|
2392
|
+
lit = RDF::Literal(value, datatype: expanded_dt)
|
|
2393
|
+
else
|
|
2394
|
+
value_errors << "#{original_value} does not match format #{format}"
|
|
1919
2395
|
end
|
|
1920
|
-
|
|
1921
|
-
|
|
1922
|
-
|
|
1923
|
-
|
|
1924
|
-
|
|
1925
|
-
|
|
1926
|
-
|
|
1927
|
-
|
|
1928
|
-
|
|
1929
|
-
|
|
1930
|
-
|
|
1931
|
-
|
|
1932
|
-
|
|
1933
|
-
|
|
1934
|
-
|
|
1935
|
-
|
|
1936
|
-
when 'd/M/yyyy' then value.match(/^(?<da>\d{1,2})\/(?<mo>\d{1,2})\/(?<yr>\d{4})/)
|
|
1937
|
-
when 'MM/dd/yyyy' then value.match(/^(?<mo>\d{2})\/(?<da>\d{2})\/(?<yr>\d{4})/)
|
|
1938
|
-
when 'M/d/yyyy' then value.match(/^(?<mo>\d{1,2})\/(?<da>\d{1,2})\/(?<yr>\d{4})/)
|
|
1939
|
-
when 'dd.MM.yyyy' then value.match(/^(?<da>\d{2})\.(?<mo>\d{2})\.(?<yr>\d{4})/)
|
|
1940
|
-
when 'd.M.yyyy' then value.match(/^(?<da>\d{1,2})\.(?<mo>\d{1,2})\.(?<yr>\d{4})/)
|
|
1941
|
-
when 'MM.dd.yyyy' then value.match(/^(?<mo>\d{2})\.(?<da>\d{2})\.(?<yr>\d{4})/)
|
|
1942
|
-
when 'M.d.yyyy' then value.match(/^(?<mo>\d{1,2})\.(?<da>\d{1,2})\.(?<yr>\d{4})/)
|
|
1943
|
-
when 'yyyy-MM-ddTHH:mm:ss' then value.match(/^(?<yr>\d{4})-(?<mo>\d{2})-(?<da>\d{2})T(?<hr>\d{2}):(?<mi>\d{2}):(?<se>\d{2})/)
|
|
1944
|
-
when 'yyyy-MM-ddTHH:mm' then value.match(/^(?<yr>\d{4})-(?<mo>\d{2})-(?<da>\d{2})T(?<hr>\d{2}):(?<mi>\d{2})(?<se>)/)
|
|
1945
|
-
else
|
|
1946
|
-
value_errors << "unrecognized date/time format #{date_format}" if date_format
|
|
1947
|
-
nil
|
|
2396
|
+
when :duration, :dayTimeDuration, :yearMonthDuration
|
|
2397
|
+
# SPEC CONFUSION: surely format also includes that for other duration types?
|
|
2398
|
+
re = Regexp.new(format) rescue nil
|
|
2399
|
+
if re.nil? ||value.match(re)
|
|
2400
|
+
lit = RDF::Literal(value, datatype: expanded_dt)
|
|
2401
|
+
else
|
|
2402
|
+
value_errors << "#{value} does not match format #{format}"
|
|
2403
|
+
end
|
|
2404
|
+
when :hexBinary, :base64Binary
|
|
2405
|
+
lit = RDF::Literal.new(value, datatype: expanded_dt)
|
|
2406
|
+
unless lit.valid?
|
|
2407
|
+
value_errors << "#{value} is invalid"
|
|
2408
|
+
lit = RDF::Literal.new(value)
|
|
2409
|
+
else
|
|
2410
|
+
if datatype.length && lit.object.length != datatype.length
|
|
2411
|
+
value_errors << "decoded #{value} does not have length #{datatype.length}"
|
|
1948
2412
|
end
|
|
1949
|
-
|
|
1950
|
-
|
|
1951
|
-
if date_part
|
|
1952
|
-
value = value[date_part.to_s.length..-1]
|
|
1953
|
-
value = value.lstrip if date_part && value.start_with?(' ')
|
|
2413
|
+
if datatype.minLength && lit.object.length < datatype.minLength
|
|
2414
|
+
value_errors << "decoded #{value} does not have length >= #{datatype.length}"
|
|
1954
2415
|
end
|
|
1955
|
-
|
|
1956
|
-
|
|
1957
|
-
time_part = case time_format
|
|
1958
|
-
when 'HH:mm:ss' then value.match(/^(?<hr>\d{2}):(?<mi>\d{2}):(?<se>\d{2})/)
|
|
1959
|
-
when 'HHmmss' then value.match(/^(?<hr>\d{2})(?<mi>\d{2})(?<se>\d{2})/)
|
|
1960
|
-
when 'HH:mm' then value.match(/^(?<hr>\d{2}):(?<mi>\d{2})(?<se>)/)
|
|
1961
|
-
when 'HHmm' then value.match(/^(?<hr>\d{2})(?<mi>\d{2})(?<se>)/)
|
|
1962
|
-
else
|
|
1963
|
-
value_errors << "unrecognized date/time format #{time_format}" if time_format
|
|
1964
|
-
nil
|
|
2416
|
+
if datatype.maxLength && lit.object.length < datatype.maxLength
|
|
2417
|
+
value_errors << "decoded #{value} does not have length <= #{datatype.length}"
|
|
1965
2418
|
end
|
|
1966
|
-
|
|
1967
|
-
# Forward past time part
|
|
1968
|
-
value = value[time_part.to_s.length..-1] if time_part
|
|
1969
|
-
|
|
1970
|
-
# Use datetime match for time
|
|
1971
|
-
time_part = date_part if date_part && date_part.names.include?("hr")
|
|
1972
|
-
|
|
1973
|
-
# If there's a timezone, it may optionally start with whitespace
|
|
1974
|
-
value = value.lstrip if tz.to_s.start_with?(' ')
|
|
1975
|
-
tz_part = value if tz
|
|
1976
|
-
|
|
1977
|
-
# Compose normalized value
|
|
1978
|
-
vd = ("%04d-%02d-%02d" % [date_part[:yr].to_i, date_part[:mo].to_i, date_part[:da].to_i]) if date_part
|
|
1979
|
-
vt = ("%02d:%02d:%02d" % [time_part[:hr].to_i, time_part[:mi].to_i, time_part[:se].to_i]) if time_part
|
|
1980
|
-
value = [vd, vt].compact.join('T')
|
|
1981
|
-
value += tz_part.to_s
|
|
1982
2419
|
end
|
|
1983
|
-
|
|
1984
|
-
lit = RDF::Literal(value, datatype: expanded_dt)
|
|
1985
|
-
when :duration, :dayTimeDuration, :yearMonthDuration
|
|
1986
|
-
# SPEC CONFUSION: surely format also includes that for other duration types?
|
|
1987
|
-
lit = RDF::Literal(value, datatype: expanded_dt)
|
|
1988
2420
|
when :anyType, :anySimpleType, :ENTITIES, :IDREFS, :NMTOKENS,
|
|
1989
2421
|
:ENTITY, :ID, :IDREF, :NOTATION
|
|
1990
2422
|
value_errors << "#{value} uses unsupported datatype: #{datatype.base}"
|
|
1991
2423
|
else
|
|
1992
2424
|
# For other types, format is a regexp
|
|
1993
|
-
|
|
2425
|
+
re = Regexp.new(format) rescue nil
|
|
2426
|
+
unless re.nil? || value.match(re)
|
|
1994
2427
|
value_errors << "#{value} does not match format #{format}"
|
|
1995
2428
|
end
|
|
1996
2429
|
lit = if value_errors.empty?
|
|
1997
2430
|
if expanded_dt == RDF::XSD.string
|
|
1998
2431
|
# Type string will still use language
|
|
1999
|
-
RDF::Literal(value, language: language)
|
|
2432
|
+
RDF::Literal(value, language: (language unless language == "und"))
|
|
2000
2433
|
else
|
|
2001
2434
|
RDF::Literal(value, datatype: expanded_dt)
|
|
2002
2435
|
end
|
|
2003
2436
|
end
|
|
2004
2437
|
end
|
|
2005
2438
|
|
|
2439
|
+
if datatype.length && value.to_s.length != datatype.length && ![:hexBinary, :base64Binary].include?(datatype.base.to_sym)
|
|
2440
|
+
value_errors << "#{value} does not have length #{datatype.length}"
|
|
2441
|
+
end
|
|
2442
|
+
if datatype.minLength && value.to_s.length < datatype.minLength && ![:hexBinary, :base64Binary].include?(datatype.base.to_sym)
|
|
2443
|
+
value_errors << "#{value} does not have length >= #{datatype.minLength}"
|
|
2444
|
+
end
|
|
2445
|
+
if datatype.maxLength && value.to_s.length > datatype.maxLength && ![:hexBinary, :base64Binary].include?(datatype.base.to_sym)
|
|
2446
|
+
value_errors << "#{value} does not have length <= #{datatype.maxLength}"
|
|
2447
|
+
end
|
|
2448
|
+
|
|
2449
|
+
# value constraints
|
|
2450
|
+
value_errors << "#{value} < minimum #{datatype.minimum}" if datatype.minimum && lit < datatype.minimum
|
|
2451
|
+
value_errors << "#{value} > maximum #{datatype.maximum}" if datatype.maximum && lit > datatype.maximum
|
|
2452
|
+
value_errors << "#{value} < minInclusive #{datatype.minInclusive}" if datatype.minInclusive && lit < datatype.minInclusive
|
|
2453
|
+
value_errors << "#{value} > maxInclusive #{datatype.maxInclusive}" if datatype.maxInclusive && lit > datatype.maxInclusive
|
|
2454
|
+
value_errors << "#{value} <= minExclusive #{datatype.minExclusive}" if datatype.minExclusive && lit <= datatype.minExclusive
|
|
2455
|
+
value_errors << "#{value} >= maxExclusive #{datatype.maxExclusive}" if datatype.maxExclusive && lit >= datatype.maxExclusive
|
|
2456
|
+
|
|
2006
2457
|
# Final value is a valid literal, or a plain literal otherwise
|
|
2007
2458
|
value_errors << "#{value} is not a valid #{datatype.base}" if lit && !lit.valid?
|
|
2008
2459
|
|
|
2009
|
-
#
|
|
2010
|
-
|
|
2460
|
+
# Either return matched literal value or errors
|
|
2011
2461
|
value_errors.empty? ? lit : value_errors
|
|
2012
2462
|
end
|
|
2013
2463
|
end
|
|
2014
|
-
|
|
2015
|
-
# Metadata errors detected
|
|
2016
|
-
class Error < StandardError; end
|
|
2017
2464
|
end
|