jsi 0.2.1 → 0.3.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.
@@ -1,3 +1,3 @@
1
1
  module JSI
2
- VERSION = "0.2.1".freeze
2
+ VERSION = "0.3.0".freeze
3
3
  end
@@ -0,0 +1,7 @@
1
+ # frozen_string_literal: true
2
+
3
+ module JSI
4
+ schema_id = 'http://json-schema.org/draft-04/schema'
5
+ schema_content = ::JSON.parse(File.read(::JSON::Validator.validators[schema_id].metaschema))
6
+ JSONSchemaOrgDraft04 = MetaschemaNode.new(schema_content).jsi_schema_module
7
+ end
@@ -0,0 +1,7 @@
1
+ # frozen_string_literal: true
2
+
3
+ module JSI
4
+ schema_id = 'http://json-schema.org/draft/schema' # I don't know why this is not http://json-schema.org/draft-06/schema
5
+ schema_content = ::JSON.parse(File.read(::JSON::Validator.validators[schema_id].metaschema))
6
+ JSONSchemaOrgDraft06 = MetaschemaNode.new(schema_content).jsi_schema_module
7
+ end
@@ -1,25 +1,32 @@
1
1
  require_relative 'test_helper'
2
2
 
3
+ base = {
4
+ 'description' => 'named array schema',
5
+ 'type' => 'array',
6
+ 'items' => [
7
+ {'type' => 'string'},
8
+ {'type' => 'object'},
9
+ {'type' => 'array', 'items' => {}},
10
+ ],
11
+ }
12
+ NamedArrayInstance = JSI.class_for_schema(base)
13
+ NamedIdArrayInstance = JSI.class_for_schema({'$id' => 'https://schemas.jsi.unth.net/test/base/named_array_schema'}.merge(base))
14
+
3
15
  describe JSI::BaseArray do
4
- let(:document) do
5
- ['foo', {'lamp' => [3]}, ['q', 'r']]
6
- end
7
- let(:path) { [] }
8
- let(:pointer) { JSI::JSON::Pointer.new(path) }
9
- let(:instance) { JSI::JSON::Node.new_by_type(document, pointer) }
16
+ let(:instance) { ['foo', {'lamp' => [3]}, ['q', 'r'], {'four' => 4}] }
10
17
  let(:schema_content) do
11
18
  {
19
+ 'description' => 'hash schema',
12
20
  'type' => 'array',
13
21
  'items' => [
14
22
  {'type' => 'string'},
15
- {'type' => 'object', 'items' => {}},
16
- {'type' => 'array'},
23
+ {'type' => 'object'},
24
+ {'type' => 'array', 'items' => {}},
17
25
  ],
18
26
  }
19
27
  end
20
28
  let(:schema) { JSI::Schema.new(schema_content) }
21
- let(:class_for_schema) { JSI.class_for_schema(schema) }
22
- let(:subject) { class_for_schema.new(instance) }
29
+ let(:subject) { schema.new_jsi(instance) }
23
30
 
24
31
  describe '#[] with a default that is a basic type' do
25
32
  let(:schema_content) do
@@ -29,21 +36,21 @@ describe JSI::BaseArray do
29
36
  }
30
37
  end
31
38
  describe 'default value' do
32
- let(:document) { [1] }
39
+ let(:instance) { [1] }
33
40
  it 'returns the default value' do
34
41
  assert_equal('foo', subject[2])
35
42
  end
36
43
  end
37
44
  describe 'nondefault value (basic type)' do
38
- let(:document) { ['who'] }
45
+ let(:instance) { ['who'] }
39
46
  it 'returns the nondefault value' do
40
47
  assert_equal('who', subject[0])
41
48
  end
42
49
  end
43
50
  describe 'nondefault value (nonbasic type)' do
44
- let(:document) { [[2]] }
51
+ let(:instance) { [[2]] }
45
52
  it 'returns the nondefault value' do
46
- assert_instance_of(JSI.class_for_schema(schema['items']), subject[0])
53
+ assert_is_a(schema.items.jsi_schema_module, subject[0])
47
54
  assert_equal([2], subject[0].as_json)
48
55
  end
49
56
  end
@@ -56,22 +63,22 @@ describe JSI::BaseArray do
56
63
  }
57
64
  end
58
65
  describe 'default value' do
59
- let(:document) { [{'bar' => 3}] }
66
+ let(:instance) { [{'bar' => 3}] }
60
67
  it 'returns the default value' do
61
- assert_instance_of(JSI.class_for_schema(schema['items']), subject[1])
68
+ assert_is_a(schema.items.jsi_schema_module, subject[1])
62
69
  assert_equal({'foo' => 2}, subject[1].as_json)
63
70
  end
64
71
  end
65
72
  describe 'nondefault value (basic type)' do
66
- let(:document) { [true, 'who'] }
73
+ let(:instance) { [true, 'who'] }
67
74
  it 'returns the nondefault value' do
68
75
  assert_equal('who', subject[1])
69
76
  end
70
77
  end
71
78
  describe 'nondefault value (nonbasic type)' do
72
- let(:document) { [true, [2]] }
79
+ let(:instance) { [true, [2]] }
73
80
  it 'returns the nondefault value' do
74
- assert_instance_of(JSI.class_for_schema(schema['items']), subject[1])
81
+ assert_is_a(schema.items.jsi_schema_module, subject[1])
75
82
  assert_equal([2], subject[1].as_json)
76
83
  end
77
84
  end
@@ -83,63 +90,173 @@ describe JSI::BaseArray do
83
90
  subject[2] = {'y' => 'z'}
84
91
 
85
92
  assert_equal({'y' => 'z'}, subject[2].as_json)
86
- assert_instance_of(JSI.class_for_schema(schema.schema_node['items'][2]), orig_2)
87
- assert_instance_of(JSI.class_for_schema(schema.schema_node['items'][2]), subject[2])
93
+ assert_is_a(schema.items[2].jsi_schema_module, orig_2)
94
+ assert_is_a(schema.items[2].jsi_schema_module, subject[2])
88
95
  end
89
96
  it 'modifies the instance, visible to other references to the same instance' do
90
- orig_instance = subject.instance
97
+ orig_instance = subject.jsi_instance
91
98
 
92
99
  subject[2] = {'y' => 'z'}
93
100
 
94
- assert_equal(orig_instance, subject.instance)
95
- assert_equal({'y' => 'z'}, orig_instance[2].as_json)
96
- assert_equal({'y' => 'z'}, subject.instance[2].as_json)
97
- assert_equal(orig_instance.class, subject.instance.class)
101
+ assert_equal(orig_instance, subject.jsi_instance)
102
+ assert_equal({'y' => 'z'}, orig_instance[2])
103
+ assert_equal({'y' => 'z'}, subject.jsi_instance[2])
104
+ assert_equal(orig_instance.class, subject.jsi_instance.class)
98
105
  end
99
106
  describe 'when the instance is not arraylike' do
100
107
  let(:instance) { nil }
101
108
  it 'errors' do
102
109
  err = assert_raises(NoMethodError) { subject[2] = 0 }
103
- assert_match(%r(\Aundefined method `\[\]=' for #<JSI::SchemaClasses::X.*>\z), err.message)
110
+ assert_equal("cannot assign subcript (using token: 2) to instance: nil", err.message)
111
+ end
112
+ end
113
+ describe '#inspect' do
114
+ it 'inspects' do
115
+ assert_equal("#[<JSI> \"foo\", \#{<JSI> \"lamp\" => [3]}, #[<JSI> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
116
+ end
117
+ end
118
+ describe '#pretty_print' do
119
+ it 'pretty_prints' do
120
+ assert_equal("#[<JSI> \"foo\", \#{<JSI> \"lamp\" => [3]}, #[<JSI> \"q\", \"r\"], {\"four\"=>4}]\n", subject.pretty_inspect)
121
+ end
122
+ end
123
+ describe '#inspect SortOfArray' do
124
+ let(:subject) { schema.new_jsi(SortOfArray.new(instance)) }
125
+ it 'inspects' do
126
+ assert_equal("#[<JSI SortOfArray> \"foo\", \#{<JSI> \"lamp\" => [3]}, #[<JSI> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
127
+ end
128
+ end
129
+ describe '#pretty_print SortOfArray' do
130
+ let(:subject) { schema.new_jsi(SortOfArray.new(instance)) }
131
+ it 'pretty_prints' do
132
+ assert_equal("#[<JSI SortOfArray>\n \"foo\",\n \#{<JSI> \"lamp\" => [3]},\n #[<JSI> \"q\", \"r\"],\n {\"four\"=>4}\n]\n", subject.pretty_inspect)
133
+ end
134
+ end
135
+ describe '#inspect named' do
136
+ let(:subject) { NamedArrayInstance.new(instance) }
137
+ it 'inspects' do
138
+ assert_equal("#[<NamedArrayInstance> \"foo\", \#{<JSI> \"lamp\" => [3]}, #[<JSI> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
139
+ end
140
+ end
141
+ describe '#pretty_print named' do
142
+ let(:subject) { NamedArrayInstance.new(instance) }
143
+ it 'inspects' do
144
+ assert_equal("#[<NamedArrayInstance>\n \"foo\",\n \#{<JSI> \"lamp\" => [3]},\n #[<JSI> \"q\", \"r\"],\n {\"four\"=>4}\n]\n", subject.pretty_inspect)
145
+ end
146
+ end
147
+ describe '#inspect named SortOfArray' do
148
+ let(:subject) { NamedArrayInstance.new(SortOfArray.new(instance)) }
149
+ it 'inspects' do
150
+ assert_equal("#[<NamedArrayInstance SortOfArray> \"foo\", \#{<JSI> \"lamp\" => [3]}, #[<JSI> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
151
+ end
152
+ end
153
+ describe '#pretty_print named SortOfArray' do
154
+ let(:subject) { NamedArrayInstance.new(SortOfArray.new(instance)) }
155
+ it 'inspects' do
156
+ assert_equal("#[<NamedArrayInstance SortOfArray>\n \"foo\",\n \#{<JSI> \"lamp\" => [3]},\n #[<JSI> \"q\", \"r\"],\n {\"four\"=>4}\n]\n", subject.pretty_inspect)
157
+ end
158
+ end
159
+ describe '#inspect named with id' do
160
+ let(:subject) { NamedIdArrayInstance.new(instance) }
161
+ it 'inspects' do
162
+ assert_equal("#[<NamedIdArrayInstance> \"foo\", \#{<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/1)> \"lamp\" => [3]}, #[<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/2)> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
163
+ end
164
+ end
165
+ describe '#pretty_print named with id' do
166
+ let(:subject) { NamedIdArrayInstance.new(instance) }
167
+ it 'inspects' do
168
+ assert_equal("#[<NamedIdArrayInstance>\n \"foo\",\n \#{<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/1)>\n \"lamp\" => [3]\n },\n #[<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/2)>\n \"q\",\n \"r\"\n ],\n {\"four\"=>4}\n]\n", subject.pretty_inspect)
169
+ end
170
+ end
171
+ describe '#inspect named with id SortOfArray' do
172
+ let(:subject) { NamedIdArrayInstance.new(SortOfArray.new(instance)) }
173
+ it 'inspects' do
174
+ assert_equal("#[<NamedIdArrayInstance SortOfArray> \"foo\", \#{<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/1)> \"lamp\" => [3]}, #[<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/2)> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
175
+ end
176
+ end
177
+ describe '#pretty_print named with id SortOfArray' do
178
+ let(:subject) { NamedIdArrayInstance.new(SortOfArray.new(instance)) }
179
+ it 'inspects' do
180
+ assert_equal("#[<NamedIdArrayInstance SortOfArray>\n \"foo\",\n \#{<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/1)>\n \"lamp\" => [3]\n },\n #[<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/2)>\n \"q\",\n \"r\"\n ],\n {\"four\"=>4}\n]\n", subject.pretty_inspect)
181
+ end
182
+ end
183
+ describe '#inspect with id' do
184
+ let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'items' => [{}, {}, {}]} }
185
+ let(:subject) { schema.new_jsi(instance) }
186
+ it 'inspects' do
187
+ assert_equal("#[<JSI (https://schemas.jsi.unth.net/test/withid#)> \"foo\", \#{<JSI (https://schemas.jsi.unth.net/test/withid#/items/1)> \"lamp\" => [3]}, #[<JSI (https://schemas.jsi.unth.net/test/withid#/items/2)> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
188
+ end
189
+ end
190
+ describe '#pretty_print with id' do
191
+ let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'items' => [{}, {}, {}]} }
192
+ let(:subject) { schema.new_jsi(instance) }
193
+ it 'inspects' do
194
+ assert_equal("#[<JSI (https://schemas.jsi.unth.net/test/withid#)>\n \"foo\",\n \#{<JSI (https://schemas.jsi.unth.net/test/withid#/items/1)> \"lamp\" => [3]},\n #[<JSI (https://schemas.jsi.unth.net/test/withid#/items/2)> \"q\", \"r\"],\n {\"four\"=>4}\n]\n", subject.pretty_inspect)
195
+ end
196
+ end
197
+ describe '#inspect with id SortOfArray' do
198
+ let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'items' => [{}, {}, {}]} }
199
+ let(:subject) { schema.new_jsi(SortOfArray.new(instance)) }
200
+ it 'inspects' do
201
+ assert_equal("#[<JSI (https://schemas.jsi.unth.net/test/withid#) SortOfArray> \"foo\", \#{<JSI (https://schemas.jsi.unth.net/test/withid#/items/1)> \"lamp\" => [3]}, #[<JSI (https://schemas.jsi.unth.net/test/withid#/items/2)> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
202
+ end
203
+ end
204
+ describe '#pretty_print with id SortOfArray' do
205
+ let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'items' => [{}, {}, {}]} }
206
+ let(:subject) { schema.new_jsi(SortOfArray.new(instance)) }
207
+ it 'inspects' do
208
+ assert_equal("#[<JSI (https://schemas.jsi.unth.net/test/withid#) SortOfArray>\n \"foo\",\n \#{<JSI (https://schemas.jsi.unth.net/test/withid#/items/1)> \"lamp\" => [3]},\n #[<JSI (https://schemas.jsi.unth.net/test/withid#/items/2)> \"q\", \"r\"],\n {\"four\"=>4}\n]\n", subject.pretty_inspect)
209
+ end
210
+ end
211
+ describe '#inspect Node' do
212
+ let(:subject) { schema.new_jsi(JSI::JSON::Node.new_doc(instance)) }
213
+ it 'inspects' do
214
+ assert_equal("#[<JSI JSI::JSON::ArrayNode fragment=\"#\"> \"foo\", \#{<JSI JSI::JSON::HashNode fragment=\"#/1\"> \"lamp\" => #[<JSI::JSON::ArrayNode fragment=\"#/1/lamp\"> 3]}, #[<JSI JSI::JSON::ArrayNode fragment=\"#/2\"> \"q\", \"r\"], \#{<JSI::JSON::HashNode fragment=\"#/3\"> \"four\" => 4}]", subject.inspect)
215
+ end
216
+ end
217
+ describe '#pretty_print Node' do
218
+ let(:subject) { schema.new_jsi(JSI::JSON::Node.new_doc(instance)) }
219
+ it 'pretty_prints' do
220
+ assert_equal("#[<JSI JSI::JSON::ArrayNode fragment=\"#\">\n \"foo\",\n \#{<JSI JSI::JSON::HashNode fragment=\"#/1\">\n \"lamp\" => #[<JSI::JSON::ArrayNode fragment=\"#/1/lamp\"> 3]\n },\n #[<JSI JSI::JSON::ArrayNode fragment=\"#/2\"> \"q\", \"r\"],\n \#{<JSI::JSON::HashNode fragment=\"#/3\"> \"four\" => 4}\n]\n", subject.pretty_inspect)
104
221
  end
105
222
  end
106
223
  end
107
224
  # these methods just delegate to Array so not going to test excessively
108
225
  describe 'index only methods' do
109
- it('#each_index') { assert_equal([0, 1, 2], subject.each_index.to_a) }
226
+ it('#each_index') { assert_equal([0, 1, 2, 3], subject.each_index.to_a) }
110
227
  it('#empty?') { assert_equal(false, subject.empty?) }
111
- it('#length') { assert_equal(3, subject.length) }
112
- it('#size') { assert_equal(3, subject.size) }
228
+ it('#length') { assert_equal(4, subject.length) }
229
+ it('#size') { assert_equal(4, subject.size) }
113
230
  end
114
231
  describe 'index + element methods' do
115
- it('#|') { assert_equal(['foo', subject[1], subject[2], 0], subject | [0]) }
232
+ it('#|') { assert_equal(['foo', subject[1], subject[2], subject[3], 0], subject | [0]) }
116
233
  it('#&') { assert_equal(['foo'], subject & ['foo']) }
117
234
  it('#*') { assert_equal(subject.to_a, subject * 1) }
118
235
  it('#+') { assert_equal(subject.to_a, subject + []) }
119
- it('#-') { assert_equal([subject[1], subject[2]], subject - ['foo']) }
236
+ it('#-') { assert_equal([subject[1], subject[2], subject[3]], subject - ['foo']) }
120
237
  it('#<=>') { assert_equal(1, subject <=> []) }
121
238
  it('#<=>') { assert_equal(-1, [] <=> subject) }
122
239
  require 'abbrev'
123
- it('#abbrev') { assert_equal({'a' => 'a'}, class_for_schema.new(['a']).abbrev) }
240
+ it('#abbrev') { assert_equal({'a' => 'a'}, schema.new_jsi(['a']).abbrev) }
124
241
  it('#assoc') { assert_equal(['q', 'r'], subject.assoc('q')) }
125
242
  it('#at') { assert_equal('foo', subject.at(0)) }
126
243
  it('#bsearch') { assert_equal(nil, subject.bsearch { false }) }
127
244
  it('#bsearch_index') { assert_equal(nil, subject.bsearch_index { false }) } if [].respond_to?(:bsearch_index)
128
- it('#combination') { assert_equal([['foo'], [subject[1]], [subject[2]]], subject.combination(1).to_a) }
245
+ it('#combination') { assert_equal([['foo'], [subject[1]], [subject[2]], [subject[3]]], subject.combination(1).to_a) }
129
246
  it('#count') { assert_equal(1, subject.count('foo')) }
130
247
  it('#cycle') { assert_equal(subject.to_a, subject.cycle(1).to_a) }
131
248
  it('#dig') { assert_equal(3, subject.dig(1, 'lamp', 0)) } if [].respond_to?(:dig)
132
- it('#drop') { assert_equal([subject[2]], subject.drop(2)) }
133
- it('#drop_while') { assert_equal([subject[1], subject[2]], subject.drop_while { |e| e == 'foo' }) }
249
+ it('#drop') { assert_equal([subject[2], subject[3]], subject.drop(2)) }
250
+ it('#drop_while') { assert_equal([subject[1], subject[2], subject[3]], subject.drop_while { |e| e == 'foo' }) }
134
251
  it('#fetch') { assert_equal('foo', subject.fetch(0)) }
135
252
  it('#find_index') { assert_equal(0, subject.find_index { true }) }
136
253
  it('#first') { assert_equal('foo', subject.first) }
137
254
  it('#include?') { assert_equal(true, subject.include?('foo')) }
138
255
  it('#index') { assert_equal(0, subject.index('foo')) }
139
- it('#join') { assert_equal('a b', class_for_schema.new(['a', 'b']).join(' ')) }
140
- it('#last') { assert_equal(subject[2], subject.last) }
141
- it('#pack') { assert_equal(' ', class_for_schema.new([32]).pack('c')) }
142
- it('#permutation') { assert_equal([['foo'], [subject[1]], [subject[2]]], subject.permutation(1).to_a) }
256
+ it('#join') { assert_equal('a b', schema.new_jsi(['a', 'b']).join(' ')) }
257
+ it('#last') { assert_equal(subject[3], subject.last) }
258
+ it('#pack') { assert_equal(' ', schema.new_jsi([32]).pack('c')) }
259
+ it('#permutation') { assert_equal([['foo'], [subject[1]], [subject[2]], [subject[3]]], subject.permutation(1).to_a) }
143
260
  it('#product') { assert_equal([], subject.product([])) }
144
261
  # due to differences in implementation between #assoc and #rassoc, the reason for which
145
262
  # I cannot begin to fathom, assoc works but rassoc does not because rassoc has different
@@ -147,25 +264,25 @@ describe JSI::BaseArray do
147
264
  # compare:
148
265
  # assoc: https://github.com/ruby/ruby/blob/v2_5_0/array.c#L3780-L3813
149
266
  # rassoc: https://github.com/ruby/ruby/blob/v2_5_0/array.c#L3815-L3847
150
- # for this reason, rassoc is NOT defined on Arraylike and #content must be called.
151
- it('#rassoc') { assert_equal(['q', 'r'], subject.instance.content.rassoc('r')) }
267
+ # for this reason, rassoc is NOT defined on Arraylike and we call #jsi_instance to use it.
268
+ it('#rassoc') { assert_equal(['q', 'r'], subject.jsi_instance.rassoc('r')) }
152
269
  it('#repeated_combination') { assert_equal([[]], subject.repeated_combination(0).to_a) }
153
270
  it('#repeated_permutation') { assert_equal([[]], subject.repeated_permutation(0).to_a) }
154
- it('#reverse') { assert_equal([subject[2], subject[1], 'foo'], subject.reverse) }
155
- it('#reverse_each') { assert_equal([subject[2], subject[1], 'foo'], subject.reverse_each.to_a) }
271
+ it('#reverse') { assert_equal([subject[3], subject[2], subject[1], 'foo'], subject.reverse) }
272
+ it('#reverse_each') { assert_equal([subject[3], subject[2], subject[1], 'foo'], subject.reverse_each.to_a) }
156
273
  it('#rindex') { assert_equal(0, subject.rindex('foo')) }
157
- it('#rotate') { assert_equal([subject[1], subject[2], 'foo'], subject.rotate) }
158
- it('#sample') { assert_equal('a', class_for_schema.new(['a']).sample) }
159
- it('#shelljoin') { assert_equal('a', class_for_schema.new(['a']).shelljoin) } if [].respond_to?(:shelljoin)
160
- it('#shuffle') { assert_equal(3, subject.shuffle.size) }
274
+ it('#rotate') { assert_equal([subject[1], subject[2], subject[3], 'foo'], subject.rotate) }
275
+ it('#sample') { assert_equal('a', schema.new_jsi(['a']).sample) }
276
+ it('#shelljoin') { assert_equal('a', schema.new_jsi(['a']).shelljoin) } if [].respond_to?(:shelljoin)
277
+ it('#shuffle') { assert_equal(4, subject.shuffle.size) }
161
278
  it('#slice') { assert_equal(['foo'], subject.slice(0, 1)) }
162
- it('#sort') { assert_equal(['a'], class_for_schema.new(['a']).sort) }
279
+ it('#sort') { assert_equal(['a'], schema.new_jsi(['a']).sort) }
163
280
  it('#take') { assert_equal(['foo'], subject.take(1)) }
164
281
  it('#take_while') { assert_equal([], subject.take_while { false }) }
165
- it('#transpose') { assert_equal([], class_for_schema.new([]).transpose) }
282
+ it('#transpose') { assert_equal([], schema.new_jsi([]).transpose) }
166
283
  it('#uniq') { assert_equal(subject.to_a, subject.uniq) }
167
284
  it('#values_at') { assert_equal(['foo'], subject.values_at(0)) }
168
- it('#zip') { assert_equal([['foo', 'foo'], [subject[1], subject[1]], [subject[2], subject[2]]], subject.zip(subject)) }
285
+ it('#zip') { assert_equal([['foo', 'foo'], [subject[1], subject[1]], [subject[2], subject[2]], [subject[3], subject[3]]], subject.zip(subject)) }
169
286
  end
170
287
  describe 'with an instance that has to_ary but not other ary instance methods' do
171
288
  let(:instance) { SortOfArray.new(['foo', {'lamp' => SortOfArray.new([3])}, SortOfArray.new(['q', 'r'])]) }
@@ -174,30 +291,27 @@ describe JSI::BaseArray do
174
291
  it('#size') { assert_equal(3, subject.size) }
175
292
  it('#count') { assert_equal(1, subject.count('foo')) }
176
293
  it('#slice') { assert_equal(['foo'], subject.slice(0, 1)) }
177
- it('#[]') { assert_equal(SortOfArray.new(['q', 'r']), subject[2].instance) }
294
+ it('#[]') { assert_equal(SortOfArray.new(['q', 'r']), subject[2].jsi_instance) }
178
295
  it('#as_json') { assert_equal(['foo', {'lamp' => [3]}, ['q', 'r']], subject.as_json) }
179
296
  end
180
297
  end
181
298
  describe 'modified copy methods' do
182
- it('#reject') { assert_equal(class_for_schema.new(JSI::JSON::ArrayNode.new(['foo'], pointer)), subject.reject { |e| e != 'foo' }) }
299
+ it('#reject') { assert_equal(schema.new_jsi(['foo']), subject.reject { |e| e != 'foo' }) }
183
300
  it('#reject block var') do
184
301
  subj_a = subject.to_a
185
302
  subject.reject { |e| assert_equal(e, subj_a.shift) }
186
303
  end
187
- it('#select') { assert_equal(class_for_schema.new(JSI::JSON::ArrayNode.new(['foo'], pointer)), subject.select { |e| e == 'foo' }) }
304
+ it('#select') { assert_equal(schema.new_jsi(['foo']), subject.select { |e| e == 'foo' }) }
188
305
  it('#select block var') do
189
306
  subj_a = subject.to_a
190
307
  subject.select { |e| assert_equal(e, subj_a.shift) }
191
308
  end
192
309
  it('#compact') { assert_equal(subject, subject.compact) }
193
310
  describe 'at a depth' do
194
- let(:document) { [['b', 'q'], {'c' => ['d', 'e']}] }
195
- let(:path) { ['1', 'c'] }
196
311
  it('#select') do
197
- selected = subject.select { |e| e == 'd' }
198
- equivalent_node = JSI::JSON::ArrayNode.new([['b', 'q'], {'c' => ['d']}], pointer)
199
- equivalent = class_for_schema.new(equivalent_node)
200
- assert_equal(equivalent, selected)
312
+ expected = schema.new_jsi(['foo', {'lamp' => [3]}, ['r'], {'four' => 4}])[2]
313
+ actual = subject[2].select { |e| e == 'r' }
314
+ assert_equal(expected, actual)
201
315
  end
202
316
  end
203
317
  end
@@ -1,14 +1,21 @@
1
1
  require_relative 'test_helper'
2
2
 
3
+ base = {
4
+ 'description' => 'named hash schema',
5
+ 'type' => 'object',
6
+ 'properties' => {
7
+ 'foo' => {'type' => 'object'},
8
+ 'bar' => {},
9
+ },
10
+ }
11
+ NamedHashInstance = JSI.class_for_schema(base)
12
+ NamedIdHashInstance = JSI.class_for_schema({'$id' => 'https://schemas.jsi.unth.net/test/base/named_hash_schema'}.merge(base))
13
+
3
14
  describe JSI::BaseHash do
4
- let(:document) do
5
- {'foo' => {'x' => 'y'}, 'bar' => [9], 'baz' => true}
6
- end
7
- let(:path) { [] }
8
- let(:pointer) { JSI::JSON::Pointer.new(path) }
9
- let(:instance) { JSI::JSON::Node.new_by_type(document, pointer) }
15
+ let(:instance) { {'foo' => {'x' => 'y'}, 'bar' => [9], 'baz' => [true]} }
10
16
  let(:schema_content) do
11
17
  {
18
+ 'description' => 'hash schema',
12
19
  'type' => 'object',
13
20
  'properties' => {
14
21
  'foo' => {'type' => 'object'},
@@ -17,10 +24,9 @@ describe JSI::BaseHash do
17
24
  }
18
25
  end
19
26
  let(:schema) { JSI::Schema.new(schema_content) }
20
- let(:class_for_schema) { JSI.class_for_schema(schema) }
21
- let(:subject) { class_for_schema.new(instance) }
27
+ let(:subject) { schema.new_jsi(instance) }
22
28
 
23
- describe '#[] with a default that is a basic type' do
29
+ describe '#[] with a schema default that is a basic type' do
24
30
  let(:schema_content) do
25
31
  {
26
32
  'type' => 'object',
@@ -30,26 +36,26 @@ describe JSI::BaseHash do
30
36
  }
31
37
  end
32
38
  describe 'default value' do
33
- let(:document) { {'bar' => 3} }
39
+ let(:instance) { {'bar' => 3} }
34
40
  it 'returns the default value' do
35
41
  assert_equal('foo', subject.foo)
36
42
  end
37
43
  end
38
44
  describe 'nondefault value (basic type)' do
39
- let(:document) { {'foo' => 'who'} }
45
+ let(:instance) { {'foo' => 'who'} }
40
46
  it 'returns the nondefault value' do
41
47
  assert_equal('who', subject.foo)
42
48
  end
43
49
  end
44
50
  describe 'nondefault value (nonbasic type)' do
45
- let(:document) { {'foo' => [2]} }
51
+ let(:instance) { {'foo' => [2]} }
46
52
  it 'returns the nondefault value' do
47
- assert_instance_of(JSI.class_for_schema(schema['properties']['foo']), subject.foo)
53
+ assert_is_a(schema.properties['foo'].jsi_schema_module, subject.foo)
48
54
  assert_equal([2], subject.foo.as_json)
49
55
  end
50
56
  end
51
57
  end
52
- describe '#[] with a default that is a nonbasic type' do
58
+ describe '#[] with a schema default that is a nonbasic type' do
53
59
  let(:schema_content) do
54
60
  {
55
61
  'type' => 'object',
@@ -59,26 +65,43 @@ describe JSI::BaseHash do
59
65
  }
60
66
  end
61
67
  describe 'default value' do
62
- let(:document) { {'bar' => 3} }
68
+ let(:instance) { {'bar' => 3} }
63
69
  it 'returns the default value' do
64
- assert_instance_of(JSI.class_for_schema(schema['properties']['foo']), subject.foo)
70
+ assert_is_a(schema.properties['foo'].jsi_schema_module, subject.foo)
65
71
  assert_equal({'foo' => 2}, subject.foo.as_json)
66
72
  end
67
73
  end
68
74
  describe 'nondefault value (basic type)' do
69
- let(:document) { {'foo' => 'who'} }
75
+ let(:instance) { {'foo' => 'who'} }
70
76
  it 'returns the nondefault value' do
71
77
  assert_equal('who', subject.foo)
72
78
  end
73
79
  end
74
80
  describe 'nondefault value (nonbasic type)' do
75
- let(:document) { {'foo' => [2]} }
81
+ let(:instance) { {'foo' => [2]} }
76
82
  it 'returns the nondefault value' do
77
- assert_instance_of(JSI.class_for_schema(schema['properties']['foo']), subject.foo)
83
+ assert_is_a(schema.properties['foo'].jsi_schema_module, subject.foo)
78
84
  assert_equal([2], subject.foo.as_json)
79
85
  end
80
86
  end
81
87
  end
88
+ describe '#[] with a hash default that is a nonbasic type' do
89
+ let(:schema_content) do
90
+ {
91
+ 'type' => 'object',
92
+ 'properties' => {
93
+ 'foo' => {},
94
+ },
95
+ }
96
+ end
97
+ describe 'default value' do
98
+ let(:instance) { Hash.new({'foo' => 2}).merge({'bar' => 3}) }
99
+ it 'returns the default value' do
100
+ assert_is_a(Hash, subject.foo)
101
+ assert_equal({'foo' => 2}, subject.foo)
102
+ end
103
+ end
104
+ end
82
105
  describe 'hashlike []=' do
83
106
  it 'sets a property' do
84
107
  orig_foo = subject['foo']
@@ -86,8 +109,8 @@ describe JSI::BaseHash do
86
109
  subject['foo'] = {'y' => 'z'}
87
110
 
88
111
  assert_equal({'y' => 'z'}, subject['foo'].as_json)
89
- assert_instance_of(JSI.class_for_schema(schema.schema_node['properties']['foo']), orig_foo)
90
- assert_instance_of(JSI.class_for_schema(schema.schema_node['properties']['foo']), subject['foo'])
112
+ assert_is_a(schema.properties['foo'].jsi_schema_module, orig_foo)
113
+ assert_is_a(schema.properties['foo'].jsi_schema_module, subject['foo'])
91
114
  end
92
115
  it 'sets a property to a schema instance with a different schema' do
93
116
  assert(subject['foo'])
@@ -97,11 +120,11 @@ describe JSI::BaseHash do
97
120
  # the content of the subscripts' instances is the same but the subscripts' classes are different
98
121
  assert_equal([9], subject['foo'].as_json)
99
122
  assert_equal([9], subject['bar'].as_json)
100
- assert_instance_of(JSI.class_for_schema(schema.schema_node['properties']['foo']), subject['foo'])
101
- assert_instance_of(JSI.class_for_schema(schema.schema_node['properties']['bar']), subject['bar'])
123
+ assert_is_a(schema.properties['foo'].jsi_schema_module, subject['foo'])
124
+ assert_is_a(schema.properties['bar'].jsi_schema_module, subject['bar'])
102
125
  end
103
126
  it 'sets a property to a schema instance with the same schema' do
104
- other_subject = class_for_schema.new(JSI::JSON::Node.new_doc({'foo' => {'x' => 'y'}, 'bar' => [9], 'baz' => true}))
127
+ other_subject = schema.new_jsi({'foo' => {'x' => 'y'}, 'bar' => [9], 'baz' => [true]})
105
128
  # Given
106
129
  assert_equal(other_subject, subject)
107
130
 
@@ -115,20 +138,130 @@ describe JSI::BaseHash do
115
138
  refute_equal(other_subject['foo'].object_id, subject['foo'].object_id)
116
139
  end
117
140
  it 'modifies the instance, visible to other references to the same instance' do
118
- orig_instance = subject.instance
141
+ orig_instance = subject.jsi_instance
119
142
 
120
143
  subject['foo'] = {'y' => 'z'}
121
144
 
122
- assert_equal(orig_instance, subject.instance)
123
- assert_equal({'y' => 'z'}, orig_instance['foo'].as_json)
124
- assert_equal({'y' => 'z'}, subject.instance['foo'].as_json)
125
- assert_equal(orig_instance.class, subject.instance.class)
145
+ assert_equal(orig_instance, subject.jsi_instance)
146
+ assert_equal({'y' => 'z'}, orig_instance['foo'])
147
+ assert_equal({'y' => 'z'}, subject.jsi_instance['foo'])
148
+ assert_equal(orig_instance.class, subject.jsi_instance.class)
126
149
  end
127
150
  describe 'when the instance is not hashlike' do
128
151
  let(:instance) { nil }
129
152
  it 'errors' do
130
153
  err = assert_raises(NoMethodError) { subject['foo'] = 0 }
131
- assert_match(%r(\Aundefined method `\[\]=' for #<JSI::SchemaClasses::.*>\z), err.message)
154
+ assert_equal('cannot assign subcript (using token: "foo") to instance: nil', err.message)
155
+ end
156
+ end
157
+ describe '#inspect' do
158
+ it 'inspects' do
159
+ assert_equal("\#{<JSI> \"foo\" => \#{<JSI> \"x\" => \"y\"}, \"bar\" => #[<JSI> 9], \"baz\" => [true]}", subject.inspect)
160
+ end
161
+ end
162
+ describe '#pretty_print' do
163
+ it 'pretty_prints' do
164
+ assert_equal("\#{<JSI> \"foo\" => \#{<JSI> \"x\" => \"y\"}, \"bar\" => #[<JSI> 9], \"baz\" => [true]}\n", subject.pretty_inspect)
165
+ end
166
+ end
167
+ describe '#inspect SortOfHash' do
168
+ let(:subject) { schema.new_jsi(SortOfHash.new(instance)) }
169
+ it 'inspects' do
170
+ assert_equal("\#{<JSI SortOfHash> \"foo\" => \#{<JSI> \"x\" => \"y\"}, \"bar\" => #[<JSI> 9], \"baz\" => [true]}", subject.inspect)
171
+ end
172
+ end
173
+ describe '#pretty_print SortOfHash' do
174
+ let(:subject) { schema.new_jsi(SortOfHash.new(instance)) }
175
+ it 'pretty_prints' do
176
+ assert_equal("\#{<JSI SortOfHash>\n \"foo\" => \#{<JSI> \"x\" => \"y\"},\n \"bar\" => #[<JSI> 9],\n \"baz\" => [true]\n}\n", subject.pretty_inspect)
177
+ end
178
+ end
179
+ describe '#inspect named' do
180
+ let(:subject) { NamedHashInstance.new(instance) }
181
+ it 'inspects' do
182
+ assert_equal("\#{<NamedHashInstance> \"foo\" => \#{<JSI> \"x\" => \"y\"}, \"bar\" => #[<JSI> 9], \"baz\" => [true]}", subject.inspect)
183
+ end
184
+ end
185
+ describe '#pretty_print named' do
186
+ let(:subject) { NamedHashInstance.new(instance) }
187
+ it 'inspects' do
188
+ assert_equal("\#{<NamedHashInstance>\n \"foo\" => \#{<JSI> \"x\" => \"y\"},\n \"bar\" => #[<JSI> 9],\n \"baz\" => [true]\n}\n", subject.pretty_inspect)
189
+ end
190
+ end
191
+ describe '#inspect named SortOfHash' do
192
+ let(:subject) { NamedHashInstance.new(SortOfHash.new(instance)) }
193
+ it 'inspects' do
194
+ assert_equal("\#{<NamedHashInstance SortOfHash> \"foo\" => \#{<JSI> \"x\" => \"y\"}, \"bar\" => #[<JSI> 9], \"baz\" => [true]}", subject.inspect)
195
+ end
196
+ end
197
+ describe '#pretty_print named SortOfHash' do
198
+ let(:subject) { NamedHashInstance.new(SortOfHash.new(instance)) }
199
+ it 'inspects' do
200
+ assert_equal("\#{<NamedHashInstance SortOfHash>\n \"foo\" => \#{<JSI> \"x\" => \"y\"},\n \"bar\" => #[<JSI> 9],\n \"baz\" => [true]\n}\n", subject.pretty_inspect)
201
+ end
202
+ end
203
+ describe '#inspect named with id' do
204
+ let(:subject) { NamedIdHashInstance.new(instance) }
205
+ it 'inspects' do
206
+ assert_equal("\#{<NamedIdHashInstance> \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/foo)> \"x\" => \"y\"}, \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/bar)> 9], \"baz\" => [true]}", subject.inspect)
207
+ end
208
+ end
209
+ describe '#pretty_print named with id' do
210
+ let(:subject) { NamedIdHashInstance.new(instance) }
211
+ it 'inspects' do
212
+ assert_equal("\#{<NamedIdHashInstance>\n \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/foo)>\n \"x\" => \"y\"\n },\n \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/bar)>\n 9\n ],\n \"baz\" => [true]\n}\n", subject.pretty_inspect)
213
+ end
214
+ end
215
+ describe '#inspect named SortOfHash with id' do
216
+ let(:subject) { NamedIdHashInstance.new(SortOfHash.new(instance)) }
217
+ it 'inspects' do
218
+ assert_equal("\#{<NamedIdHashInstance SortOfHash> \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/foo)> \"x\" => \"y\"}, \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/bar)> 9], \"baz\" => [true]}", subject.inspect)
219
+ end
220
+ end
221
+ describe '#pretty_print named with id SortOfHash' do
222
+ let(:subject) { NamedIdHashInstance.new(SortOfHash.new(instance)) }
223
+ it 'inspects' do
224
+ assert_equal("\#{<NamedIdHashInstance SortOfHash>\n \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/foo)>\n \"x\" => \"y\"\n },\n \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/bar)>\n 9\n ],\n \"baz\" => [true]\n}\n", subject.pretty_inspect)
225
+ end
226
+ end
227
+ describe '#inspect with id' do
228
+ let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'properties' => {'foo' => {}, 'bar' => {}}} }
229
+ let(:subject) { schema.new_jsi(instance) }
230
+ it 'inspects' do
231
+ assert_equal("\#{<JSI (https://schemas.jsi.unth.net/test/withid#)> \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/withid#/properties/foo)> \"x\" => \"y\"}, \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/withid#/properties/bar)> 9], \"baz\" => [true]}", subject.inspect)
232
+ end
233
+ end
234
+ describe '#pretty_print with id' do
235
+ let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'properties' => {'foo' => {}, 'bar' => {}}} }
236
+ let(:subject) { schema.new_jsi(instance) }
237
+ it 'inspects' do
238
+ assert_equal("\#{<JSI (https://schemas.jsi.unth.net/test/withid#)>\n \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/withid#/properties/foo)>\n \"x\" => \"y\"\n },\n \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/withid#/properties/bar)> 9\n ],\n \"baz\" => [true]\n}\n", subject.pretty_inspect)
239
+ end
240
+ end
241
+ describe '#inspect with id SortOfHash' do
242
+ let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'properties' => {'foo' => {}, 'bar' => {}}} }
243
+ let(:subject) { schema.new_jsi(SortOfHash.new(instance)) }
244
+ it 'inspects' do
245
+ assert_equal("\#{<JSI (https://schemas.jsi.unth.net/test/withid#) SortOfHash> \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/withid#/properties/foo)> \"x\" => \"y\"}, \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/withid#/properties/bar)> 9], \"baz\" => [true]}", subject.inspect)
246
+ end
247
+ end
248
+ describe '#pretty_print with id SortOfHash' do
249
+ let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'properties' => {'foo' => {}, 'bar' => {}}} }
250
+ let(:subject) { schema.new_jsi(SortOfHash.new(instance)) }
251
+ it 'inspects' do
252
+ assert_equal("\#{<JSI (https://schemas.jsi.unth.net/test/withid#) SortOfHash>\n \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/withid#/properties/foo)>\n \"x\" => \"y\"\n },\n \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/withid#/properties/bar)> 9\n ],\n \"baz\" => [true]\n}\n", subject.pretty_inspect)
253
+ end
254
+ end
255
+ describe '#inspect Node' do
256
+ let(:subject) { schema.new_jsi(JSI::JSON::Node.new_doc(instance)) }
257
+ it 'inspects' do
258
+ assert_equal("\#{<JSI JSI::JSON::HashNode fragment=\"#\"> \"foo\" => \#{<JSI JSI::JSON::HashNode fragment=\"#/foo\"> \"x\" => \"y\"}, \"bar\" => #[<JSI JSI::JSON::ArrayNode fragment=\"#/bar\"> 9], \"baz\" => #[<JSI::JSON::ArrayNode fragment=\"#/baz\"> true]}", subject.inspect)
259
+ end
260
+ end
261
+ describe '#pretty_print Node' do
262
+ let(:subject) { schema.new_jsi(JSI::JSON::Node.new_doc(instance)) }
263
+ it 'pretty_prints' do
264
+ assert_equal("\#{<JSI JSI::JSON::HashNode fragment=\"#\">\n \"foo\" => \#{<JSI JSI::JSON::HashNode fragment=\"#/foo\"> \"x\" => \"y\"},\n \"bar\" => #[<JSI JSI::JSON::ArrayNode fragment=\"#/bar\"> 9],\n \"baz\" => #[<JSI::JSON::ArrayNode fragment=\"#/baz\"> true]\n}\n", subject.pretty_inspect)
132
265
  end
133
266
  end
134
267
  end
@@ -145,36 +278,36 @@ describe JSI::BaseHash do
145
278
  it('#size') { assert_equal(3, subject.size) }
146
279
  end
147
280
  describe 'key + value methods' do
148
- it('#<') { assert_equal(true, subject < {'foo' => subject['foo'], 'bar' => subject['bar'], 'baz' => true, 'x' => 'y'}) } if {}.respond_to?(:<)
281
+ it('#<') { assert_equal(true, subject < {'foo' => subject['foo'], 'bar' => subject['bar'], 'baz' => subject['baz'], 'x' => 'y'}) } if {}.respond_to?(:<)
149
282
  it('#<=') { assert_equal(true, subject <= subject) } if {}.respond_to?(:<=)
150
283
  it('#>') { assert_equal(true, subject > {}) } if {}.respond_to?(:>)
151
284
  it('#>=') { assert_equal(false, subject >= {'foo' => 'bar'}) } if {}.respond_to?(:>=)
152
285
  it('#any?') { assert_equal(false, subject.any? { |k, v| v == 3 }) }
153
286
  it('#assoc') { assert_equal(['foo', subject['foo']], subject.assoc('foo')) }
154
287
  it('#dig') { assert_equal(9, subject.dig('bar', 0)) } if {}.respond_to?(:dig)
155
- it('#each_pair') { assert_equal([['foo', subject['foo']], ['bar', subject['bar']], ['baz', true]], subject.each_pair.to_a) }
156
- it('#each_value') { assert_equal([subject['foo'], subject['bar'], true], subject.each_value.to_a) }
157
- it('#fetch') { assert_equal(true, subject.fetch('baz')) }
158
- it('#fetch_values') { assert_equal([true], subject.fetch_values('baz')) } if {}.respond_to?(:fetch_values)
159
- it('#has_value?') { assert_equal(true, subject.has_value?(true)) }
160
- it('#invert') { assert_equal({subject['foo'] => 'foo', subject['bar'] => 'bar', true => 'baz'}, subject.invert) }
161
- it('#key') { assert_equal('baz', subject.key(true)) }
162
- it('#rassoc') { assert_equal(['baz', true], subject.rassoc(true)) }
163
- it('#to_h') { assert_equal({'foo' => subject['foo'], 'bar' => subject['bar'], 'baz' => true}, subject.to_h) }
164
- it('#to_proc') { assert_equal(true, subject.to_proc.call('baz')) } if {}.respond_to?(:to_proc)
288
+ it('#each_pair') { assert_equal([['foo', subject['foo']], ['bar', subject['bar']], ['baz', [true]]], subject.each_pair.to_a) }
289
+ it('#each_value') { assert_equal([subject['foo'], subject['bar'], [true]], subject.each_value.to_a) }
290
+ it('#fetch') { assert_equal([true], subject.fetch('baz')) }
291
+ it('#fetch_values') { assert_equal([[true]], subject.fetch_values('baz')) } if {}.respond_to?(:fetch_values)
292
+ it('#has_value?') { assert_equal(true, subject.has_value?([true])) }
293
+ it('#invert') { assert_equal({subject['foo'] => 'foo', subject['bar'] => 'bar', [true] => 'baz'}, subject.invert) }
294
+ it('#key') { assert_equal('baz', subject.key([true])) }
295
+ it('#rassoc') { assert_equal(['baz', [true]], subject.rassoc([true])) }
296
+ it('#to_h') { assert_equal({'foo' => subject['foo'], 'bar' => subject['bar'], 'baz' => [true]}, subject.to_h) }
297
+ it('#to_proc') { assert_equal([true], subject.to_proc.call('baz')) } if {}.respond_to?(:to_proc)
165
298
  if {}.respond_to?(:transform_values)
166
299
  it('#transform_values') { assert_equal({'foo' => nil, 'bar' => nil, 'baz' => nil}, subject.transform_values { |_| nil }) }
167
300
  end
168
301
  it('#value?') { assert_equal(false, subject.value?('0')) }
169
- it('#values') { assert_equal([subject['foo'], subject['bar'], true], subject.values) }
170
- it('#values_at') { assert_equal([true], subject.values_at('baz')) }
302
+ it('#values') { assert_equal([subject['foo'], subject['bar'], [true]], subject.values) }
303
+ it('#values_at') { assert_equal([[true]], subject.values_at('baz')) }
171
304
  end
172
305
  describe 'with an instance that has to_hash but not other hash instance methods' do
173
306
  let(:instance) { SortOfHash.new({'foo' => SortOfHash.new({'a' => 'b'})}) }
174
307
  describe 'delegating instance methods to #to_hash' do
175
308
  it('#each_key') { assert_equal(['foo'], subject.each_key.to_a) }
176
309
  it('#each_pair') { assert_equal([['foo', subject['foo']]], subject.each_pair.to_a) }
177
- it('#[]') { assert_equal(SortOfHash.new({'a' => 'b'}), subject['foo'].instance) }
310
+ it('#[]') { assert_equal(SortOfHash.new({'a' => 'b'}), subject['foo'].jsi_instance) }
178
311
  it('#as_json') { assert_equal({'foo' => {'a' => 'b'}}, subject.as_json) }
179
312
  end
180
313
  end
@@ -182,8 +315,8 @@ describe JSI::BaseHash do
182
315
  # I'm going to rely on the #merge test above to test the modified copy functionality and just do basic
183
316
  # tests of all the modified copy methods here
184
317
  it('#merge') { assert_equal(subject, subject.merge({})) }
185
- it('#reject') { assert_equal(class_for_schema.new(JSI::JSON::HashNode.new({}, pointer)), subject.reject { true }) }
186
- it('#select') { assert_equal(class_for_schema.new(JSI::JSON::HashNode.new({}, pointer)), subject.select { false }) }
318
+ it('#reject') { assert_equal(schema.new_jsi({}), subject.reject { true }) }
319
+ it('#select') { assert_equal(schema.new_jsi({}), subject.select { false }) }
187
320
  describe '#select' do
188
321
  it 'yields properly too' do
189
322
  subject.select do |k, v|