jcrvalidator 0.5.3 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (11) hide show
  1. checksums.yaml +4 -4
  2. data/lib/jcr/check_groups.rb +1 -3
  3. data/lib/jcr/evaluate_array_rules.rb +44 -20
  4. data/lib/jcr/evaluate_group_rules.rb +21 -3
  5. data/lib/jcr/evaluate_member_rules.rb +32 -3
  6. data/lib/jcr/evaluate_object_rules.rb +74 -20
  7. data/lib/jcr/evaluate_rules.rb +207 -10
  8. data/lib/jcr/evaluate_value_rules.rb +256 -19
  9. data/lib/jcr/jcr.rb +54 -27
  10. data/lib/jcr/parser.rb +170 -110
  11. metadata +2 -1
data/lib/jcr/parser.rb CHANGED
@@ -21,9 +21,8 @@ module JCR
21
21
 
22
22
  root(:jcr)
23
23
 
24
- rule(:jcr) { ( spcCmnt | directive ).repeat >> root_rule.maybe >> ( spcCmnt | directive | rule ).repeat }
25
- #! jcr = *( sp-cmt / directive ) [ root_rule ]
26
- #! *( sp-cmt / directive / rule )
24
+ rule(:jcr) { ( spcCmnt | directive | root_rule | rule ).repeat }
25
+ #! jcr = *( sp-cmt / directive / root_rule / rule )
27
26
  #!
28
27
 
29
28
  rule(:spcCmnt) { spaces | comment }
@@ -35,6 +34,8 @@ module JCR
35
34
  #! spaces = 1*( WSP / CR / LF )
36
35
  rule(:spaces?) { spaces.maybe }
37
36
  #/ spaces? -> [ spaces ]
37
+ rule(:wsp) { match('[\t ]') }
38
+ # WSP is a standard ABNF production so is not expanded here
38
39
  rule(:comment) { str(';') >> ( str('\;') | match('[^\r\n;]') ).repeat >> match('[\r\n;]') }
39
40
  #! comment = ";" *( "\;" / comment-char ) comment-end-char
40
41
  #! comment-char = HTAB / %x20-3A / %x3C-10FFFF
@@ -42,16 +43,21 @@ module JCR
42
43
  #! comment-end-char = CR / LF / ";"
43
44
  #!
44
45
 
45
- rule(:directive) { ( str('#') >> spaces? >> directive_def >> match('[\r\n]') ).as(:directive) }
46
- #! directive = "#" spaces? directive_def *WSP eol
47
- rule(:directive_def) { jcr_version_d | ruleset_id_d | import_d | tbd_directive_d }
48
- #! directive_def = jcr_version_d / ruleset_id_d / import_d /
49
- #! tbd_directive_d
50
- rule(:jcr_version_d) { (str('jcr-version') >> spaces >> p_integer.as(:major_version) >> str('.') >> p_integer.as(:minor_version)).as(:jcr_version_d) }
46
+ rule(:directive) { ( str('#') >> (one_line_directive | multi_line_directive) ).as(:directive) }
47
+ #! directive = "#" (one_line_directive / multi_line_directive)
48
+ rule(:one_line_directive) { ( spaces? >> ( directive_def | one_line_tbd_directive_d ) >> wsp.repeat >> match('[\r\n]') ) }
49
+ #! one_line_directive = spaces?
50
+ #! (directive_def / one_line_tbd_directive_d) *WSP eol
51
+ rule(:multi_line_directive) { str('{') >> spcCmnt? >> (directive_def | multi_line_tbd_directive_d) >> spcCmnt? >> str('}') }
52
+ #! multi_line_directive = "{" spcCmnt?
53
+ #! (directive_def / multi_line_tbd_directive_d) spcCmnt? "}"
54
+ rule(:directive_def) { jcr_version_d | ruleset_id_d | import_d }
55
+ #! directive_def = jcr_version_d / ruleset_id_d / import_d
56
+ rule(:jcr_version_d) { (str('jcr-version') >> spaces >> non_neg_integer.as(:major_version) >> str('.') >> non_neg_integer.as(:minor_version)).as(:jcr_version_d) }
51
57
  #! jcr_version_d = jcr-version-kw spaces major_version "." minor_version
52
58
  #> jcr-version-kw = "jcr-version"
53
- #! major_version = p_integer
54
- #! minor_version = p_integer
59
+ #! major_version = non_neg_integer
60
+ #! minor_version = non_neg_integer
55
61
  rule(:ruleset_id_d) { (str('ruleset-id') >> spaces >> ruleset_id.as(:ruleset_id)).as(:ruleset_id_d) }
56
62
  #! ruleset_id_d = ruleset-id-kw spaces ruleset_id
57
63
  #> ruleset-id-kw = "ruleset-id"
@@ -65,92 +71,113 @@ module JCR
65
71
  #! not-space = %x21-10FFFF
66
72
  rule(:ruleset_id_alias) { name.as(:ruleset_id_alias) }
67
73
  #! ruleset_id_alias = name
68
- rule(:tbd_directive_d) { name.as(:directive_name) >> ( spaces >> match('[^\r\n]').repeat.as(:directive_parameters) ).maybe }
69
- #! tbd_directive_d = directive_name [ spaces directive_parameters ]
74
+ rule(:one_line_tbd_directive_d) { name.as(:directive_name) >> ( wsp >> match('[^\r\n]').repeat.as(:directive_parameters) ).maybe }
75
+ #! one_line_tbd_directive_d = directive_name [ WSP one_line_directive_parameters ]
70
76
  #! directive_name = name
71
- #! directive_parameters = *not_eol
77
+ #! one_line_directive_parameters = *not_eol
72
78
  #! not_eol = HTAB / %x20-10FFFF
73
79
  #! eol = CR / LF
80
+ rule(:multi_line_tbd_directive_d) { name.as(:directive_name) >> ( spaces >> multi_line_directive_parameters.as(:directive_parameters) ).maybe }
81
+ #! multi_line_tbd_directive_d = directive_name
82
+ #! [ spaces multi_line_directive_parameters ]
83
+ rule(:multi_line_directive_parameters) { multi_line_parameters }
84
+ #! multi_line_directive_parameters = multi_line_parameters
85
+ rule(:multi_line_parameters) { (comment | q_string | regex | match('[^"/;}]')).repeat }
86
+ #! multi_line_parameters = *(comment / q_string / regex /
87
+ #! not_multi_line_special)
88
+ #! not_multi_line_special = spaces / %x21 / %x23-2E / %x30-3A / %x3C-7C /
89
+ #! %x7E-10FFFF ; not ", /, ; or }
74
90
  #!
75
91
 
76
92
  rule(:root_rule) { value_rule | group_rule } # N.B. Not target_rule_name
77
93
  #! root_rule = value_rule / group_rule
78
94
  #!
79
95
 
80
- rule(:rule) { ( rule_name >> spcCmnt? >> rule_def ).as(:rule) }
81
- #! rule = rule_name spcCmnt? rule_def
96
+ rule(:rule) { ( annotations.as(:annotations) >> str('$') >> rule_name >> spcCmnt? >> str('=') >> spcCmnt? >> rule_def ).as(:rule) }
97
+ #! rule = annotations "$" rule_name spcCmnt? "=" spcCmnt? rule_def
82
98
  #!
83
99
 
84
100
  rule(:rule_name) { name.as(:rule_name) }
85
101
  #! rule_name = name
86
- rule(:target_rule_name) { ((ruleset_id_alias >> str('.')).maybe >> rule_name).as(:target_rule_name) }
87
- #! target_rule_name = [ ruleset_id_alias "." ] rule_name
102
+ rule(:target_rule_name) { (annotations.as(:annotations) >> str('$') >> (ruleset_id_alias >> str('.')).maybe >> rule_name).as(:target_rule_name) }
103
+ #! target_rule_name = annotations "$" [ ruleset_id_alias "." ] rule_name
88
104
  rule(:name) { match('[a-zA-Z]') >> match('[a-zA-Z0-9\-_]').repeat }
89
105
  #! name = ALPHA *( ALPHA / DIGIT / "-" / "_" )
90
106
  #!
91
107
 
92
- rule(:rule_def) { type_rule | member_rule | group_rule }
93
- #! rule_def = type_rule / member_rule / group_rule
94
- rule(:type_rule) { value_rule | type_choice_rule | target_rule_name }
95
- #! type_rule = value_rule / type_choice_rule / target_rule_name
108
+ rule(:rule_def) { member_rule | (type_designator >> rule_def_type_rule) |
109
+ array_rule | object_rule | group_rule | target_rule_name }
110
+ #! rule_def = member_rule / type_designator rule_def_type_rule /
111
+ #! array_rule / object_rule / group_rule / target_rule_name
112
+ rule(:type_designator) { str('type') >> spcCmnt.repeat(1) | str(':') >> spcCmnt? }
113
+ #! type_designator = type-kw 1*spcCmnt / ":" spcCmnt?
114
+ #> type-kw = "type"
115
+ rule(:rule_def_type_rule) { value_rule | type_choice }
116
+ #! rule_def_type_rule = value_rule / type_choice
96
117
  rule(:value_rule) { primitive_rule | array_rule | object_rule }
97
118
  #! value_rule = primitive_rule / array_rule / object_rule
98
- rule(:member_rule) { ( annotations >> member_name_spec >> spcCmnt? >> type_rule ).as(:member_rule) }
119
+ rule(:member_rule) { ( annotations >> member_name_spec >> spcCmnt? >> str(':') >> spcCmnt? >> type_rule ).as(:member_rule) }
99
120
  #! member_rule = annotations
100
- #! member_name_spec spcCmnt? type_rule
121
+ #! member_name_spec spcCmnt? ":" spcCmnt? type_rule
101
122
  rule(:member_name_spec) { regex.as(:member_regex) | q_string.as(:member_name) }
102
123
  #! member_name_spec = regex / q_string
103
- rule(:type_choice_rule) { str(':').as(:type_choice_signifier) >> spcCmnt? >> type_choice }
104
- #! type_choice_rule = ":" spcCmnt? type_choice
124
+ rule(:type_rule) { value_rule | type_choice | target_rule_name }
125
+ #! type_rule = value_rule / type_choice / target_rule_name
105
126
  rule(:type_choice) { ( annotations >> str('(') >> type_choice_items >> ( choice_combiner >> type_choice_items ).repeat >> str(')') ).as(:group_rule) }
106
127
  #! type_choice = annotations "(" type_choice_items
107
128
  #! *( choice_combiner type_choice_items ) ")"
129
+ rule(:explicit_type_choice) { type_designator >> type_choice }
130
+ #! explicit_type_choice = type_designator type_choice
108
131
  rule(:type_choice_items) { spcCmnt? >> (type_choice | type_rule) >> spcCmnt? }
109
132
  #! type_choice_items = spcCmnt? ( type_choice / type_rule ) spcCmnt?
110
133
  #!
111
134
 
112
- rule(:annotations) { ( str('@(') >> spcCmnt? >> annotation_set >> spcCmnt? >> str(')') >> spcCmnt? ).repeat }
113
- #! annotations = *( "@(" spcCmnt? annotation_set spcCmnt? ")" spcCmnt? )
114
- rule(:annotation_set) { reject_annotation | unordered_annotation | root_annotation | tbd_annotation }
115
- #! annotation_set = reject_annotation / unordered_annotation /
135
+ rule(:annotations) { ( str('@{') >> spcCmnt? >> annotation_set >> spcCmnt? >> str('}') >> spcCmnt? ).repeat }
136
+ #! annotations = *( "@{" spcCmnt? annotation_set spcCmnt? "}" spcCmnt? )
137
+ rule(:annotation_set) { not_annotation | unordered_annotation | root_annotation | tbd_annotation }
138
+ #! annotation_set = not_annotation / unordered_annotation /
116
139
  #! root_annotation / tbd_annotation
117
- rule(:reject_annotation) { str('reject').as(:reject_annotation) }
118
- #! reject_annotation = reject-kw
119
- #> reject-kw = "reject"
140
+ rule(:not_annotation) { str('not').as(:not_annotation) }
141
+ #! not_annotation = not-kw
142
+ #> not-kw = "not"
120
143
  rule(:unordered_annotation) { str('unordered').as(:unordered_annotation) }
121
144
  #! unordered_annotation = unordered-kw
122
145
  #> unordered-kw = "unordered"
123
146
  rule(:root_annotation) { str('root').as(:root_annotation) }
124
147
  #! root_annotation = root-kw
125
148
  #> root-kw = "root"
126
- rule(:tbd_annotation) { name.as(:annotation_name) >> ( spaces >> match('[^)]').as(:annotation_parameters) ).maybe }
149
+ rule(:tbd_annotation) { name.as(:annotation_name) >> ( spaces >> annotation_parameters.as(:annotation_parameters) ).maybe }
127
150
  #! tbd_annotation = annotation_name [ spaces annotation_parameters ]
128
151
  #! annotation_name = name
129
- #! annotation_parameters = *( spaces / %x21-28 / %x2A-10FFFF )
130
- #! ; Not close bracket - ")"
152
+ rule(:annotation_parameters) { multi_line_parameters }
153
+ #! annotation_parameters = multi_line_parameters
131
154
  #!
132
155
 
133
- rule(:primitive_rule) { ( annotations >> str(':') >> spcCmnt? >> primimitive_def ).as(:primitive_rule) }
134
- #! primitive_rule = annotations ":" spcCmnt? primimitive_def
135
-
136
- rule(:primimitive_def) {
137
- null_type | boolean_type | true_value | false_value |
138
- string_type | string_range | string_value |
139
- float_type | float_range | float_value |
140
- integer_type | integer_range | integer_value |
141
- ip4_type | ip6_type | fqdn_type | idn_type |
142
- uri_range | uri_type | phone_type | email_type |
143
- full_date_type | full_time_type | date_time_type |
144
- base64_type | any
156
+ rule(:primitive_rule) { ( annotations >> primitive_def ).as(:primitive_rule) }
157
+ #! primitive_rule = annotations primitive_def
158
+
159
+ rule(:primitive_def) {
160
+ string_type | string_range | string_value |
161
+ null_type | boolean_type | true_value | false_value |
162
+ double_type | float_type | float_range | float_value |
163
+ integer_type | integer_range | integer_value |
164
+ sized_int_type | sized_uint_type |
165
+ ipv4_type | ipv6_type | ipaddr_type | fqdn_type | idn_type |
166
+ uri_range | uri_type | phone_type | email_type |
167
+ datetime_type | date_type | time_type |
168
+ hex_type | base32hex_type | base32_type | base64url_type | base64_type |
169
+ any
145
170
  }
146
- #! primimitive_def = null_type / boolean_type / true_value / false_value /
147
- #! string_type / string_range / string_value /
148
- #! float_type / float_range / float_value /
149
- #! integer_type / integer_range / integer_value /
150
- #! ip4_type / ip6_type / fqdn_type / idn_type /
171
+ #! primitive_def = string_type / string_range / string_value /
172
+ #! null_type / boolean_type / true_value / false_value /
173
+ #! double_type / float_type / float_range / float_value /
174
+ #! integer_type / integer_range / integer_value /
175
+ #! sized_int_type / sized_uint_type /
176
+ #! ipv4_type / ipv6_type / ipaddr_type / fqdn_type / idn_type /
151
177
  #! uri_range / uri_type / phone_type / email_type /
152
- #! full_date_type / full_time_type / date_time_type /
153
- #! base64_type / any
178
+ #! datetime_type / date_type / time_type /
179
+ #! hex_type / base32hex_type / base32_type / base64url_type / base64_type /
180
+ #! any
154
181
  rule(:null_type) { str('null').as(:null) }
155
182
  #! null_type = null-kw
156
183
  #> null-kw = "null"
@@ -170,6 +197,9 @@ module JCR
170
197
  #! string_value = q_string
171
198
  rule(:string_range) { regex }
172
199
  #! string_range = regex
200
+ rule(:double_type) { str('double').as(:double_v) }
201
+ #! double_type = double-kw
202
+ #> double-kw = "double"
173
203
  rule(:float_type) { str('float').as(:float_v) }
174
204
  #! float_type = float-kw
175
205
  #> float-kw = "float"
@@ -192,12 +222,21 @@ module JCR
192
222
  #! integer_max = integer
193
223
  rule(:integer_value) { integer.as(:integer) }
194
224
  #! integer_value = integer
195
- rule(:ip4_type) { str('ip4').as(:ip4) }
196
- #! ip4_type = ip4-kw
197
- #> ip4-kw = "ip4"
198
- rule(:ip6_type) { str('ip6').as(:ip6) }
199
- #! ip6_type = ip6-kw
200
- #> ip6-kw = "ip6"
225
+ rule(:sized_int_type) { ( str('int') >> pos_integer.as(:bits) ).as(:sized_int_v) }
226
+ #! sized_int_type = int-kw pos_integer
227
+ #> int-kw = "int"
228
+ rule(:sized_uint_type) { ( str('uint') >> pos_integer.as(:bits) ).as(:sized_uint_v) }
229
+ #! sized_uint_type = uint-kw pos_integer
230
+ #> uint-kw = "uint"
231
+ rule(:ipv4_type) { str('ipv4').as(:ipv4) }
232
+ #! ipv4_type = ipv4-kw
233
+ #> ipv4-kw = "ipv4"
234
+ rule(:ipv6_type) { str('ipv6').as(:ipv6) }
235
+ #! ipv6_type = ipv6-kw
236
+ #> ipv6-kw = "ipv6"
237
+ rule(:ipaddr_type) { str('ipaddr').as(:ipaddr) }
238
+ #! ipaddr_type = ipaddr-kw
239
+ #> ipaddr-kw = "ipaddr"
201
240
  rule(:fqdn_type) { str('fqdn').as(:fqdn) }
202
241
  #! fqdn_type = fqdn-kw
203
242
  #> fqdn-kw = "fqdn"
@@ -216,15 +255,27 @@ module JCR
216
255
  rule(:email_type) { str('email').as(:email) }
217
256
  #! email_type = email-kw
218
257
  #> email-kw = "email"
219
- rule(:full_date_type) { str('full-date').as(:full_date) }
220
- #! full-date_type = full-date-kw
221
- #> full-date-kw = "full-date"
222
- rule(:full_time_type) { str('full-time').as(:full_time) }
223
- #! full-time_type = full-time-kw
224
- #> full-time-kw = "full-time"
225
- rule(:date_time_type) { str('date-time').as(:date_time) }
226
- #! date-time_type = date-time-kw
227
- #> date-time-kw = "date-time"
258
+ rule(:datetime_type) { str('datetime').as(:datetime) }
259
+ #! datetime_type = datetime-kw
260
+ #> datetime-kw = "datetime"
261
+ rule(:date_type) { str('date').as(:date) }
262
+ #! date_type = date-kw
263
+ #> date-kw = "date"
264
+ rule(:time_type) { str('time').as(:time) }
265
+ #! time_type = time-kw
266
+ #> time-kw = "time"
267
+ rule(:hex_type) { str('hex').as(:hex) }
268
+ #! hex_type = hex-kw
269
+ #> hex-kw = "hex"
270
+ rule(:base32hex_type) { str('base32hex').as(:base32hex) }
271
+ #! base32hex_type = base32hex-kw
272
+ #> base32hex-kw = "base32hex"
273
+ rule(:base32_type) { str('base32').as(:base32) }
274
+ #! base32_type = base32-kw
275
+ #> base32-kw = "base32"
276
+ rule(:base64url_type) { str('base64url').as(:base64url) }
277
+ #! base64url_type = base64url-kw
278
+ #> base64url-kw = "base64url"
228
279
  rule(:base64_type) { str('base64').as(:base64) }
229
280
  #! base64_type = base64-kw
230
281
  #> base64-kw = "base64"
@@ -233,32 +284,32 @@ module JCR
233
284
  #> any-kw = "any"
234
285
  #!
235
286
 
236
- rule(:object_rule) { ( annotations >> (str(':') >> spcCmnt?).maybe >>
237
- str('{') >> spcCmnt? >> object_items.maybe >> spcCmnt? >> str('}') ).as(:object_rule) }
238
- #! object_rule = annotations [ ":" spcCmnt? ] "{" spcCmnt? [ object_items spcCmnt? ] "}"
287
+ rule(:object_rule) { ( annotations >>
288
+ str('{') >> spcCmnt? >> object_items.maybe >> spcCmnt? >> str('}') ).as(:object_rule) }
289
+ #! object_rule = annotations "{" spcCmnt? [ object_items spcCmnt? ] "}"
239
290
  rule(:object_items) { object_item >> (( spcCmnt? >> sequence_combiner >> spcCmnt? >> object_item ).repeat(1) |
240
291
  ( spcCmnt? >> choice_combiner >> spcCmnt? >> object_item ).repeat(1) ).maybe }
241
292
  #! object_items = object_item (*( sequence_combiner object_item ) /
242
293
  #! *( choice_combiner object_item ) )
243
- rule(:object_item ) { repetition.maybe >> spcCmnt? >> object_item_types }
244
- #! object_item = [ repetition spcCmnt? ] object_item_types
245
- rule(:object_item_types) { member_rule | target_rule_name | object_group }
246
- #! object_item_types = member_rule / target_rule_name / object_group
294
+ rule(:object_item ) { object_item_types >> spcCmnt? >> repetition.maybe }
295
+ #! object_item = object_item_types spcCmnt? [ repetition ]
296
+ rule(:object_item_types) { object_group | member_rule | target_rule_name }
297
+ #! object_item_types = object_group / member_rule / target_rule_name
247
298
  rule(:object_group) { ( str('(') >> spcCmnt? >> object_items.maybe >> spcCmnt? >> str(')') ).as(:group_rule) }
248
299
  #! object_group = "(" spcCmnt? [ object_items spcCmnt? ] ")"
249
300
  #!
250
301
 
251
- rule(:array_rule) { ( annotations >> (str(':') >> spcCmnt?).maybe >>
252
- str('[') >> spcCmnt? >> array_items.maybe >> spcCmnt? >> str(']') ).as(:array_rule) }
253
- #! array_rule = annotations [ ":" spcCmnt? ] "[" spcCmnt? [ array_items spcCmnt? ] "]"
302
+ rule(:array_rule) { ( annotations >>
303
+ str('[') >> spcCmnt? >> array_items.maybe >> spcCmnt? >> str(']') ).as(:array_rule) }
304
+ #! array_rule = annotations "[" spcCmnt? [ array_items spcCmnt? ] "]"
254
305
  rule(:array_items) { array_item >> (( spcCmnt? >> sequence_combiner >> spcCmnt? >> array_item ).repeat(1) |
255
306
  ( spcCmnt? >> choice_combiner >> spcCmnt? >> array_item ).repeat(1) ).maybe }
256
307
  #! array_items = array_item (*( sequence_combiner array_item ) /
257
308
  #! *( choice_combiner array_item ) )
258
- rule(:array_item) { repetition.maybe >> spcCmnt? >> array_item_types }
259
- #! array_item = [ repetition ] spcCmnt? array_item_types
260
- rule(:array_item_types) { type_rule | array_group }
261
- #! array_item_types = type_rule / array_group
309
+ rule(:array_item) { array_item_types >> spcCmnt? >> repetition.maybe }
310
+ #! array_item = array_item_types spcCmnt? [ repetition ]
311
+ rule(:array_item_types) { array_group | type_rule | explicit_type_choice }
312
+ #! array_item_types = array_group / type_rule / explicit_type_choice
262
313
  rule(:array_group) { ( str('(') >> spcCmnt? >> array_items.maybe >> spcCmnt? >> str(')') ).as(:group_rule) }
263
314
  #! array_group = "(" spcCmnt? [ array_items spcCmnt? ] ")"
264
315
  #!
@@ -269,10 +320,10 @@ module JCR
269
320
  ( spcCmnt? >> choice_combiner >> spcCmnt? >> group_item ).repeat(1) ).maybe }
270
321
  #! group_items = group_item (*( sequence_combiner group_item ) /
271
322
  #! *( choice_combiner group_item ) )
272
- rule(:group_item) { repetition.maybe >> spcCmnt? >> group_item_types }
273
- #! group_item = [ repetition ] spcCmnt? group_item_types
274
- rule(:group_item_types) { type_rule | member_rule | group_group }
275
- #! group_item_types = type_rule / member_rule / group_group
323
+ rule(:group_item) { group_item_types >> spcCmnt? >> repetition.maybe }
324
+ #! group_item = group_item_types spcCmnt? [ repetition ]
325
+ rule(:group_item_types) { group_group | member_rule | type_rule | explicit_type_choice }
326
+ #! group_item_types = group_group / member_rule / type_rule / explicit_type_choice
276
327
  rule(:group_group) { group_rule }
277
328
  #! group_group = group_rule
278
329
  #!
@@ -283,30 +334,39 @@ module JCR
283
334
  #! choice_combiner = spcCmnt? "|" spcCmnt?
284
335
  #!
285
336
 
286
- rule(:repetition) { optional | one_or_more | min_max_repetition | specific_repetition }
287
- #! repetition = optional / one_or_more / min_max_repetition /
288
- #! min_repetition / max_repetition /
289
- #! zero_or_more / specific_repetition
337
+ rule(:repetition) { str('@') >> spcCmnt? >> ( optional | one_or_more | zero_or_more |
338
+ min_max_repetition | specific_repetition ) }
339
+ #! repetition = "@" spcCmnt? ( optional / one_or_more / min_max_repetition /
340
+ #! min_repetition / max_repetition /
341
+ #! zero_or_more / specific_repetition )
290
342
  rule(:optional) { str('?').as(:optional) }
291
343
  #! optional = "?"
292
- rule(:one_or_more) { str('+').as(:one_or_more) }
293
- #! one_or_more = "+"
294
- #! zero_or_more = "*"
295
- rule(:min_max_repetition) { # This includes zero_or_more, min_only and max_only cases
296
- p_integer.maybe.as(:repetition_min) >> spcCmnt? >> str('*').as(:repetition_interval) >> spcCmnt? >> p_integer.maybe.as(:repetition_max) }
297
- #! min_max_repetition = min_repeat spcCmnt? "*" spcCmnt? max_repeat
298
- #! min_repetition = min_repeat spcCmnt? "*"
299
- #! max_repetition = "*" spcCmnt? max_repeat
300
- #! min_repeat = p_integer
301
- #! max_repeat = p_integer
302
- rule(:specific_repetition) { p_integer.as(:specific_repetition) }
303
- #! specific_repetition = p_integer
344
+ rule(:one_or_more) { str('+').as(:one_or_more) >> repetition_step.maybe }
345
+ #! one_or_more = "+" [ repetition_step ]
346
+ rule(:zero_or_more) { str('*').as(:zero_or_more) >> repetition_step.maybe }
347
+ #! zero_or_more = "*" [ repetition_step ]
348
+ rule(:min_max_repetition) { # This includes min_only and max_only cases
349
+ non_neg_integer.maybe.as(:repetition_min) >>
350
+ str("..").as(:repetition_interval) >>
351
+ non_neg_integer.maybe.as(:repetition_max) >>
352
+ repetition_step.maybe }
353
+ #! min_max_repetition = min_repeat ".." max_repeat [ repetition_step ]
354
+ #! min_repetition = min_repeat ".." [ repetition_step ]
355
+ #! max_repetition = ".." max_repeat [ repetition_step ]
356
+ #! min_repeat = non_neg_integer
357
+ #! max_repeat = non_neg_integer
358
+ rule(:specific_repetition) { non_neg_integer.as(:specific_repetition) }
359
+ #! specific_repetition = non_neg_integer
360
+ rule(:repetition_step) { str('%') >> non_neg_integer.as(:repetition_step) }
361
+ #! repetition_step = "%" non_neg_integer
304
362
  #!
305
363
 
306
- rule(:integer) { str('-').maybe >> match('[0-9]').repeat(1) }
307
- #! integer = ["-"] 1*DIGIT
308
- rule(:p_integer) { match('[0-9]').repeat(1) }
309
- #! p_integer = 1*DIGIT
364
+ rule(:integer) { str('0') | str('-').maybe >> pos_integer }
365
+ #! integer = "0" / ["-"] pos_integer
366
+ rule(:non_neg_integer) { str('0') | pos_integer }
367
+ #! non_neg_integer = "0" / pos_integer
368
+ rule(:pos_integer) { match('[1-9]') >> match('[0-9]').repeat }
369
+ #! pos_integer = digit1-9 *DIGIT
310
370
  #!
311
371
 
312
372
  rule(:float) { str('-').maybe >> match('[0-9]').repeat(1) >> str('.' ) >> match('[0-9]').repeat(1) }
@@ -361,8 +421,8 @@ module JCR
361
421
 
362
422
  class Transformer < Parslet::Transform
363
423
 
364
- rule(:rule_def=>simple(:primimitive_def)) { puts "found rule definition" }
365
- rule(:primimitive_def => simple(:x)) { puts "value sought is " + x }
424
+ rule(:rule_def=>simple(:primitive_def)) { puts "found rule definition" }
425
+ rule(:primitive_def => simple(:x)) { puts "value sought is " + x }
366
426
 
367
427
  end
368
428
 
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: jcrvalidator
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.5.3
4
+ version: 0.6.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Andrew Newton
@@ -68,6 +68,7 @@ dependencies:
68
68
  - !ruby/object:Gem::Version
69
69
  version: 0.1.4
70
70
  description: A JSON Content Rules (JCR) Validator library and command line utility.
71
+ Version 0.6.x is closely following -07 of the draft.
71
72
  email: andy@arin.net
72
73
  executables:
73
74
  - jcr