membrane 0.0.2 → 0.0.4

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 (45) hide show
  1. data/.gitignore +1 -0
  2. data/.travis.yml +6 -0
  3. data/LICENSE +58 -6869
  4. data/NOTICE +10 -0
  5. data/README.md +130 -30
  6. data/lib/membrane/schema_parser.rb +25 -24
  7. data/lib/membrane/schemas/any.rb +8 -0
  8. data/lib/membrane/{schema → schemas}/base.rb +1 -6
  9. data/lib/membrane/schemas/bool.rb +31 -0
  10. data/lib/membrane/schemas/class.rb +35 -0
  11. data/lib/membrane/schemas/dictionary.rb +69 -0
  12. data/lib/membrane/schemas/enum.rb +49 -0
  13. data/lib/membrane/schemas/list.rb +63 -0
  14. data/lib/membrane/schemas/record.rb +96 -0
  15. data/lib/membrane/schemas/regexp.rb +60 -0
  16. data/lib/membrane/schemas/tuple.rb +90 -0
  17. data/lib/membrane/schemas/value.rb +37 -0
  18. data/lib/membrane/schemas.rb +5 -0
  19. data/lib/membrane/version.rb +1 -1
  20. data/lib/membrane.rb +1 -1
  21. data/spec/schema_parser_spec.rb +79 -75
  22. data/spec/{any_schema_spec.rb → schemas/any_spec.rb} +2 -2
  23. data/spec/{base_schema_spec.rb → schemas/base_spec.rb} +2 -2
  24. data/spec/{bool_schema_spec.rb → schemas/bool_spec.rb} +2 -3
  25. data/spec/{class_schema_spec.rb → schemas/class_spec.rb} +2 -2
  26. data/spec/{dictionary_schema_spec.rb → schemas/dictionary_spec.rb} +11 -11
  27. data/spec/{enum_schema_spec.rb → schemas/enum_spec.rb} +4 -4
  28. data/spec/{list_schema_spec.rb → schemas/list_spec.rb} +8 -8
  29. data/spec/schemas/record_spec.rb +108 -0
  30. data/spec/{regexp_schema_spec.rb → schemas/regexp_spec.rb} +2 -2
  31. data/spec/{tuple_schema_spec.rb → schemas/tuple_spec.rb} +4 -4
  32. data/spec/{value_schema_spec.rb → schemas/value_spec.rb} +2 -2
  33. metadata +37 -35
  34. data/lib/membrane/schema/any.rb +0 -13
  35. data/lib/membrane/schema/bool.rb +0 -20
  36. data/lib/membrane/schema/class.rb +0 -24
  37. data/lib/membrane/schema/dictionary.rb +0 -40
  38. data/lib/membrane/schema/enum.rb +0 -30
  39. data/lib/membrane/schema/list.rb +0 -37
  40. data/lib/membrane/schema/record.rb +0 -45
  41. data/lib/membrane/schema/regexp.rb +0 -29
  42. data/lib/membrane/schema/tuple.rb +0 -48
  43. data/lib/membrane/schema/value.rb +0 -22
  44. data/lib/membrane/schema.rb +0 -17
  45. data/spec/record_schema_spec.rb +0 -56
@@ -0,0 +1,60 @@
1
+ require "membrane/errors"
2
+ require "membrane/schemas/base"
3
+
4
+ module Membrane
5
+ module Schema
6
+ end
7
+ end
8
+
9
+ class Membrane::Schemas::Regexp < Membrane::Schemas::Base
10
+ attr_reader :regexp
11
+
12
+ def initialize(regexp)
13
+ @regexp = regexp
14
+ end
15
+
16
+ def validate(object)
17
+ StringValidator.new(object).validate
18
+ MatchValidator.new(@regexp, object).validate
19
+
20
+ nil
21
+ end
22
+
23
+ class StringValidator
24
+
25
+ def initialize(object)
26
+ @object = object
27
+ end
28
+
29
+ def validate
30
+ fail! if !@object.kind_of?(String)
31
+ end
32
+
33
+ private
34
+
35
+ def fail!
36
+ emsg = "Expected instance of String, given instance of #{@object.class}"
37
+ raise Membrane::SchemaValidationError.new(emsg)
38
+ end
39
+
40
+ end
41
+
42
+ class MatchValidator
43
+
44
+ def initialize(regexp, object)
45
+ @regexp = regexp
46
+ @object = object
47
+ end
48
+
49
+ def validate
50
+ fail! if !@regexp.match(@object)
51
+ end
52
+
53
+ private
54
+
55
+ def fail!
56
+ emsg = "Value #{@object} doesn't match regexp #{@regexp}"
57
+ raise Membrane::SchemaValidationError.new(emsg)
58
+ end
59
+ end
60
+ end
@@ -0,0 +1,90 @@
1
+ require "membrane/errors"
2
+ require "membrane/schemas/base"
3
+
4
+ module Membrane
5
+ module Schema
6
+ end
7
+ end
8
+
9
+ class Membrane::Schemas::Tuple < Membrane::Schemas::Base
10
+ attr_reader :elem_schemas
11
+
12
+ def initialize(*elem_schemas)
13
+ @elem_schemas = elem_schemas
14
+ end
15
+
16
+ def validate(object)
17
+ ArrayValidator.new(object).validate
18
+ LengthValidator.new(@elem_schemas, object).validate
19
+ MemberValidator.new(@elem_schemas, object).validate
20
+
21
+ nil
22
+ end
23
+
24
+ class ArrayValidator
25
+ def initialize(object)
26
+ @object = object
27
+ end
28
+
29
+ def validate
30
+ fail! if !@object.kind_of?(Array)
31
+ end
32
+
33
+ private
34
+
35
+ def fail!
36
+ emsg = "Expected instance of Array, given instance of #{@object.class}"
37
+ raise Membrane::SchemaValidationError.new(emsg)
38
+ end
39
+ end
40
+
41
+ class LengthValidator
42
+ def initialize(elem_schemas, object)
43
+ @elem_schemas = elem_schemas
44
+ @object = object
45
+ end
46
+
47
+ def validate
48
+ expected = @elem_schemas.length
49
+ actual = @object.length
50
+
51
+ fail!(expected, actual) if actual != expected
52
+ end
53
+
54
+ private
55
+
56
+ def fail!(expected, actual)
57
+ emsg = "Expected #{expected} element(s), given #{actual}"
58
+ raise Membrane::SchemaValidationError.new(emsg)
59
+ end
60
+ end
61
+
62
+ class MemberValidator
63
+ def initialize(elem_schemas, object)
64
+ @elem_schemas = elem_schemas
65
+ @object = object
66
+ end
67
+
68
+ def validate
69
+ errors = {}
70
+
71
+ @elem_schemas.each_with_index do |schema, ii|
72
+ begin
73
+ schema.validate(@object[ii])
74
+ rescue Membrane::SchemaValidationError => e
75
+ errors[ii] = e
76
+ end
77
+ end
78
+
79
+ fail!(errors) if errors.size > 0
80
+ end
81
+
82
+ private
83
+
84
+ def fail!(errors)
85
+ emsg = "There were errors at the following indices: " \
86
+ + errors.map { |ii, err| "#{ii} => #{err}" }.join(", ")
87
+ raise Membrane::SchemaValidationError.new(emsg)
88
+ end
89
+ end
90
+ end
@@ -0,0 +1,37 @@
1
+ require "membrane/errors"
2
+ require "membrane/schemas/base"
3
+
4
+ module Membrane
5
+ module Schema
6
+ end
7
+ end
8
+
9
+ class Membrane::Schemas::Value < Membrane::Schemas::Base
10
+ attr_reader :value
11
+
12
+ def initialize(value)
13
+ @value = value
14
+ end
15
+
16
+ def validate(object)
17
+ ValueValidator.new(@value, object).validate
18
+ end
19
+
20
+ class ValueValidator
21
+ def initialize(value, object)
22
+ @value = value
23
+ @object = object
24
+ end
25
+
26
+ def validate
27
+ fail!(@value, @object) if @object != @value
28
+ end
29
+
30
+ private
31
+
32
+ def fail!(expected, given)
33
+ emsg = "Expected #{expected}, given #{given}"
34
+ raise Membrane::SchemaValidationError.new(emsg)
35
+ end
36
+ end
37
+ end
@@ -0,0 +1,5 @@
1
+ module Membrane
2
+ module Schemas; end
3
+ end
4
+
5
+ Dir[File.dirname(__FILE__) + '/schemas/*.rb'].each { |file| require file }
@@ -1,3 +1,3 @@
1
1
  module Membrane
2
- VERSION = "0.0.2"
2
+ VERSION = "0.0.4"
3
3
  end
data/lib/membrane.rb CHANGED
@@ -1,4 +1,4 @@
1
1
  require "membrane/errors"
2
- require "membrane/schema"
2
+ require "membrane/schemas"
3
3
  require "membrane/schema_parser"
4
4
  require "membrane/version"
@@ -7,100 +7,104 @@ describe Membrane::SchemaParser do
7
7
  it "should call inspect on the value of a Value schema" do
8
8
  val = "test"
9
9
  val.should_receive(:inspect).twice
10
- schema = Membrane::Schema::Value.new(val)
10
+ schema = Membrane::Schemas::Value.new(val)
11
11
 
12
12
  parser.deparse(schema).should == val.inspect
13
13
  end
14
14
 
15
- it "should return 'any' for instance of Membrane::Schema::Any" do
16
- schema = Membrane::Schema::Any.new
15
+ it "should return 'any' for instance of Membrane::Schemas::Any" do
16
+ schema = Membrane::Schemas::Any.new
17
17
 
18
18
  parser.deparse(schema).should == "any"
19
19
  end
20
20
 
21
- it "should return 'bool' for instances of Membrane::Schema::Bool" do
22
- schema = Membrane::Schema::Bool.new
21
+ it "should return 'bool' for instances of Membrane::Schemas::Bool" do
22
+ schema = Membrane::Schemas::Bool.new
23
23
 
24
24
  parser.deparse(schema).should == "bool"
25
25
  end
26
26
 
27
- it "should call name on the class of a Membrane::Schema::Class schema" do
27
+ it "should call name on the class of a Membrane::Schemas::Class schema" do
28
28
  klass = String
29
29
  klass.should_receive(:name).twice
30
- schema = Membrane::Schema::Class.new(klass)
30
+ schema = Membrane::Schemas::Class.new(klass)
31
31
 
32
32
  parser.deparse(schema).should == klass.name
33
33
  end
34
34
 
35
- it "should deparse the k/v schemas of a Membrane::Schema::Dictionary schema" do
36
- key_schema = Membrane::Schema::Class.new(String)
37
- val_schema = Membrane::Schema::Class.new(Integer)
35
+ it "should deparse the k/v schemas of a Membrane::Schemas::Dictionary schema" do
36
+ key_schema = Membrane::Schemas::Class.new(String)
37
+ val_schema = Membrane::Schemas::Class.new(Integer)
38
38
 
39
- dict_schema = Membrane::Schema::Dictionary.new(key_schema, val_schema)
39
+ dict_schema = Membrane::Schemas::Dictionary.new(key_schema, val_schema)
40
40
 
41
41
  parser.deparse(dict_schema).should == "dict(String, Integer)"
42
42
  end
43
43
 
44
- it "should deparse the element schemas of a Membrane::Schema::Enum schema" do
44
+ it "should deparse the element schemas of a Membrane::Schemas::Enum schema" do
45
45
  schemas =
46
- [String, Integer, Float].map { |c| Membrane::Schema::Class.new(c) }
46
+ [String, Integer, Float].map { |c| Membrane::Schemas::Class.new(c) }
47
47
 
48
- enum_schema = Membrane::Schema::Enum.new(*schemas)
48
+ enum_schema = Membrane::Schemas::Enum.new(*schemas)
49
49
 
50
50
  parser.deparse(enum_schema).should == "enum(String, Integer, Float)"
51
51
  end
52
52
 
53
- it "should deparse the element schema of a Membrane::Schema::List schema" do
54
- key_schema = Membrane::Schema::Class.new(String)
55
- val_schema = Membrane::Schema::Class.new(Integer)
56
- item_schema = Membrane::Schema::Dictionary.new(key_schema, val_schema)
53
+ it "should deparse the element schema of a Membrane::Schemas::List schema" do
54
+ key_schema = Membrane::Schemas::Class.new(String)
55
+ val_schema = Membrane::Schemas::Class.new(Integer)
56
+ item_schema = Membrane::Schemas::Dictionary.new(key_schema, val_schema)
57
57
 
58
- list_schema = Membrane::Schema::List.new(item_schema)
58
+ list_schema = Membrane::Schemas::List.new(item_schema)
59
59
 
60
60
  parser.deparse(list_schema).should == "[dict(String, Integer)]"
61
61
  end
62
62
 
63
- it "should deparse elem schemas of a Membrane::Schema::Record schema" do
64
- str_schema = Membrane::Schema::Class.new(String)
65
- int_schema = Membrane::Schema::Class.new(Integer)
66
- dict_schema = Membrane::Schema::Dictionary.new(str_schema, int_schema)
67
-
68
- int_rec_schema = Membrane::Schema::Record.new({:str => str_schema,
69
- :dict => dict_schema})
70
-
71
- rec_schema = Membrane::Schema::Record.new({"str" => str_schema,
63
+ it "should deparse elem schemas of a Membrane::Schemas::Record schema" do
64
+ str_schema = Membrane::Schemas::Class.new(String)
65
+ int_schema = Membrane::Schemas::Class.new(Integer)
66
+ dict_schema = Membrane::Schemas::Dictionary.new(str_schema, int_schema)
67
+
68
+ int_rec_schema = Membrane::Schemas::Record.new({
69
+ :str => str_schema,
70
+ :dict => dict_schema
71
+ })
72
+ rec_schema = Membrane::Schemas::Record.new({
73
+ "str" => str_schema,
72
74
  "rec" => int_rec_schema,
73
- "int" => int_schema})
75
+ "int" => int_schema
76
+ })
77
+
74
78
  exp_deparse =<<EOT
75
79
  {
76
- "str" => String,
77
- "rec" => {
78
- :str => String,
79
- :dict => dict(String, Integer),
80
+ "str" => String,
81
+ "rec" => {
82
+ :str => String,
83
+ :dict => dict(String, Integer),
80
84
  },
81
- "int" => Integer,
85
+ "int" => Integer,
82
86
  }
83
87
  EOT
84
88
  parser.deparse(rec_schema).should == exp_deparse.strip
85
89
  end
86
90
 
87
- it "should call inspect on regexps for Membrane::Schema::Regexp" do
88
- schema = Membrane::Schema::Regexp.new(/test/)
91
+ it "should call inspect on regexps for Membrane::Schemas::Regexp" do
92
+ schema = Membrane::Schemas::Regexp.new(/test/)
89
93
  schema.regexp.should_receive(:inspect)
90
94
  parser.deparse(schema)
91
95
  end
92
96
 
93
- it "should deparse the element schemas of a Membrane::Schema::Tuple schema" do
94
- schemas = [String, Integer].map { |c| Membrane::Schema::Class.new(c) }
95
- schemas << Membrane::Schema::Value.new("test")
97
+ it "should deparse the element schemas of a Membrane::Schemas::Tuple schema" do
98
+ schemas = [String, Integer].map { |c| Membrane::Schemas::Class.new(c) }
99
+ schemas << Membrane::Schemas::Value.new("test")
96
100
 
97
- enum_schema = Membrane::Schema::Tuple.new(*schemas)
101
+ enum_schema = Membrane::Schemas::Tuple.new(*schemas)
98
102
 
99
103
  parser.deparse(enum_schema).should == 'tuple(String, Integer, "test")'
100
104
  end
101
105
 
102
- it "should call inspect on a Membrane::Schema::Base schema" do
103
- schema = Membrane::Schema::Base.new
106
+ it "should call inspect on a Membrane::Schemas::Base schema" do
107
+ schema = Membrane::Schemas::Base.new
104
108
  parser.deparse(schema).should == schema.inspect
105
109
  end
106
110
 
@@ -112,85 +116,85 @@ EOT
112
116
  end
113
117
 
114
118
  describe "#parse" do
115
- it "should leave instances derived from Membrane::Schema::Base unchanged" do
116
- old_schema = Membrane::Schema::ANY
119
+ it "should leave instances derived from Membrane::Schemas::Base unchanged" do
120
+ old_schema = Membrane::Schemas::Any.new
117
121
 
118
122
  parser.parse { old_schema }.should == old_schema
119
123
  end
120
124
 
121
- it "should translate 'any' into Membrane::Schema::Any" do
125
+ it "should translate 'any' into Membrane::Schemas::Any" do
122
126
  schema = parser.parse { any }
123
127
 
124
- schema.class.should == Membrane::Schema::Any
128
+ schema.class.should == Membrane::Schemas::Any
125
129
  end
126
130
 
127
- it "should translate 'bool' into Membrane::Schema::Bool" do
131
+ it "should translate 'bool' into Membrane::Schemas::Bool" do
128
132
  schema = parser.parse { bool }
129
133
 
130
- schema.class.should == Membrane::Schema::Bool
134
+ schema.class.should == Membrane::Schemas::Bool
131
135
  end
132
136
 
133
- it "should translate 'enum' into Membrane::Schema::Enum" do
137
+ it "should translate 'enum' into Membrane::Schemas::Enum" do
134
138
  schema = parser.parse { enum(bool, any) }
135
139
 
136
- schema.class.should == Membrane::Schema::Enum
140
+ schema.class.should == Membrane::Schemas::Enum
137
141
 
138
142
  schema.elem_schemas.length.should == 2
139
143
 
140
144
  elem_schema_classes = schema.elem_schemas.map { |es| es.class }
141
145
 
142
- expected_classes = [Membrane::Schema::Bool, Membrane::Schema::Any]
146
+ expected_classes = [Membrane::Schemas::Bool, Membrane::Schemas::Any]
143
147
  elem_schema_classes.should == expected_classes
144
148
  end
145
149
 
146
- it "should translate 'dict' into Membrane::Schema::Dictionary" do
150
+ it "should translate 'dict' into Membrane::Schemas::Dictionary" do
147
151
  schema = parser.parse { dict(String, Integer) }
148
152
 
149
- schema.class.should == Membrane::Schema::Dictionary
153
+ schema.class.should == Membrane::Schemas::Dictionary
150
154
 
151
- schema.key_schema.class.should == Membrane::Schema::Class
155
+ schema.key_schema.class.should == Membrane::Schemas::Class
152
156
  schema.key_schema.klass.should == String
153
157
 
154
- schema.value_schema.class.should == Membrane::Schema::Class
158
+ schema.value_schema.class.should == Membrane::Schemas::Class
155
159
  schema.value_schema.klass.should == Integer
156
160
  end
157
161
 
158
- it "should translate 'tuple' into Membrane::Schema::Tuple" do
162
+ it "should translate 'tuple' into Membrane::Schemas::Tuple" do
159
163
  schema = parser.parse { tuple(String, any, Integer) }
160
164
 
161
- schema.class.should == Membrane::Schema::Tuple
165
+ schema.class.should == Membrane::Schemas::Tuple
162
166
 
163
- schema.elem_schemas[0].class.should == Membrane::Schema::Class
167
+ schema.elem_schemas[0].class.should == Membrane::Schemas::Class
164
168
  schema.elem_schemas[0].klass.should == String
165
169
 
166
- schema.elem_schemas[1].class == Membrane::Schema::Any
170
+ schema.elem_schemas[1].class == Membrane::Schemas::Any
167
171
 
168
- schema.elem_schemas[2].class.should == Membrane::Schema::Class
172
+ schema.elem_schemas[2].class.should == Membrane::Schemas::Class
169
173
  schema.elem_schemas[2].klass.should == Integer
170
174
  end
171
175
 
172
- it "should translate classes into Membrane::Schema::Class" do
176
+ it "should translate classes into Membrane::Schemas::Class" do
173
177
  schema = parser.parse { String }
174
178
 
175
- schema.class.should == Membrane::Schema::Class
179
+ schema.class.should == Membrane::Schemas::Class
176
180
 
177
181
  schema.klass.should == String
178
182
  end
179
183
 
180
- it "should translate regexps into Membrane::Schema::Regexp" do
184
+ it "should translate regexps into Membrane::Schemas::Regexp" do
181
185
  regexp = /foo/
182
186
 
183
187
  schema = parser.parse { regexp }
184
188
 
185
- schema.class.should == Membrane::Schema::Regexp
189
+ schema.class.should == Membrane::Schemas::Regexp
186
190
 
187
191
  schema.regexp.should == regexp
188
192
  end
189
193
 
190
- it "should fall back to Membrane::Schema::Value" do
194
+ it "should fall back to Membrane::Schemas::Value" do
191
195
  schema = parser.parse { 5 }
192
196
 
193
- schema.class.should == Membrane::Schema::Value
197
+ schema.class.should == Membrane::Schemas::Value
194
198
  schema.value.should == 5
195
199
  end
196
200
 
@@ -207,12 +211,12 @@ EOT
207
211
  end.to raise_error(ArgumentError, /single schema/)
208
212
  end
209
213
 
210
- it "should parse '[<expr>]' into Membrane::Schema::List" do
214
+ it "should parse '[<expr>]' into Membrane::Schemas::List" do
211
215
  schema = parser.parse { [String] }
212
216
 
213
- schema.class.should == Membrane::Schema::List
217
+ schema.class.should == Membrane::Schemas::List
214
218
 
215
- schema.elem_schema.class.should == Membrane::Schema::Class
219
+ schema.elem_schema.class.should == Membrane::Schemas::Class
216
220
  schema.elem_schema.klass.should == String
217
221
  end
218
222
  end
@@ -224,29 +228,29 @@ EOT
224
228
  end.to raise_error(ArgumentError, /must supply/)
225
229
  end
226
230
 
227
- it "should parse '{ <key> => <schema> }' into Membrane::Schema::Record" do
231
+ it "should parse '{ <key> => <schema> }' into Membrane::Schemas::Record" do
228
232
  schema = parser.parse do
229
233
  { "string" => String,
230
234
  "ints" => [Integer],
231
235
  }
232
236
  end
233
237
 
234
- schema.class.should == Membrane::Schema::Record
238
+ schema.class.should == Membrane::Schemas::Record
235
239
 
236
240
  str_schema = schema.schemas["string"]
237
- str_schema.class.should == Membrane::Schema::Class
241
+ str_schema.class.should == Membrane::Schemas::Class
238
242
  str_schema.klass.should == String
239
243
 
240
244
  ints_schema = schema.schemas["ints"]
241
- ints_schema.class.should == Membrane::Schema::List
242
- ints_schema.elem_schema.class.should == Membrane::Schema::Class
245
+ ints_schema.class.should == Membrane::Schemas::List
246
+ ints_schema.elem_schema.class.should == Membrane::Schemas::Class
243
247
  ints_schema.elem_schema.klass.should == Integer
244
248
  end
245
249
 
246
250
  it "should handle keys marked with 'optional()'" do
247
251
  schema = parser.parse { { optional("test") => Integer } }
248
252
 
249
- schema.class.should == Membrane::Schema::Record
253
+ schema.class.should == Membrane::Schemas::Record
250
254
  schema.optional_keys.to_a.should == ["test"]
251
255
  end
252
256
  end
@@ -1,9 +1,9 @@
1
1
  require "spec_helper"
2
2
 
3
- describe Membrane::Schema::Any do
3
+ describe Membrane::Schemas::Any do
4
4
  describe "#validate" do
5
5
  it "should always return nil" do
6
- schema = Membrane::Schema::Any.new
6
+ schema = Membrane::Schemas::Any.new
7
7
  # Smoke test more than anything. Cannot validate this with 100%
8
8
  # certainty.
9
9
  [1, "hi", :test, {}, []].each do |o|
@@ -1,9 +1,9 @@
1
1
  require "spec_helper"
2
2
 
3
3
 
4
- describe Membrane::Schema::Base do
4
+ describe Membrane::Schemas::Base do
5
5
  describe "#validate" do
6
- let(:schema) { Membrane::Schema::Base.new }
6
+ let(:schema) { Membrane::Schemas::Base.new }
7
7
 
8
8
  it "should raise error" do
9
9
  expect { schema.validate }.to raise_error
@@ -1,9 +1,8 @@
1
1
  require "spec_helper"
2
2
 
3
-
4
- describe Membrane::Schema::Bool do
3
+ describe Membrane::Schemas::Bool do
5
4
  describe "#validate" do
6
- let(:schema) { Membrane::Schema::Bool.new }
5
+ let(:schema) { Membrane::Schemas::Bool.new }
7
6
 
8
7
  it "should return nil for {true, false}" do
9
8
  [true, false].each { |v| schema.validate(v).should be_nil }
@@ -1,9 +1,9 @@
1
1
  require "spec_helper"
2
2
 
3
3
 
4
- describe Membrane::Schema::Class do
4
+ describe Membrane::Schemas::Class do
5
5
  describe "#validate" do
6
- let(:schema) { Membrane::Schema::Class.new(String) }
6
+ let(:schema) { Membrane::Schemas::Class.new(String) }
7
7
 
8
8
  it "should return nil for instances of the supplied class" do
9
9
  schema.validate("test").should be_nil
@@ -1,33 +1,33 @@
1
1
  require "spec_helper"
2
2
 
3
- describe Membrane::Schema::Dictionary do
3
+ describe Membrane::Schemas::Dictionary do
4
4
  describe "#validate" do
5
5
  let (:data) { { "foo" => 1, "bar" => 2 } }
6
6
 
7
7
  it "should return an error if supplied with a non-hash" do
8
- schema = Membrane::Schema::Dictionary.new(nil, nil)
8
+ schema = Membrane::Schemas::Dictionary.new(nil, nil)
9
9
 
10
10
  expect_validation_failure(schema, "test", /instance of Hash/)
11
11
  end
12
12
 
13
13
  it "should validate each key against the supplied key schema" do
14
- key_schema = mock("key_schema")
14
+ key_schema = double("key_schema")
15
15
 
16
16
  data.keys.each { |k| key_schema.should_receive(:validate).with(k) }
17
17
 
18
- dict_schema = Membrane::Schema::Dictionary.new(key_schema,
19
- Membrane::Schema::Any.new)
18
+ dict_schema = Membrane::Schemas::Dictionary.new(key_schema,
19
+ Membrane::Schemas::Any.new)
20
20
 
21
21
  dict_schema.validate(data)
22
22
  end
23
23
 
24
24
  it "should validate the value for each valid key" do
25
- key_schema = Membrane::Schema::Class.new(String)
26
- val_schema = mock("val_schema")
25
+ key_schema = Membrane::Schemas::Class.new(String)
26
+ val_schema = double("val_schema")
27
27
 
28
28
  data.values.each { |v| val_schema.should_receive(:validate).with(v) }
29
29
 
30
- dict_schema = Membrane::Schema::Dictionary.new(key_schema, val_schema)
30
+ dict_schema = Membrane::Schemas::Dictionary.new(key_schema, val_schema)
31
31
 
32
32
  dict_schema.validate(data)
33
33
  end
@@ -38,9 +38,9 @@ describe Membrane::Schema::Dictionary do
38
38
  :bar => 2,
39
39
  }
40
40
 
41
- key_schema = Membrane::Schema::Class.new(String)
42
- val_schema = Membrane::Schema::Class.new(Integer)
43
- dict_schema = Membrane::Schema::Dictionary.new(key_schema, val_schema)
41
+ key_schema = Membrane::Schemas::Class.new(String)
42
+ val_schema = Membrane::Schemas::Class.new(Integer)
43
+ dict_schema = Membrane::Schemas::Dictionary.new(key_schema, val_schema)
44
44
 
45
45
  errors = nil
46
46
 
@@ -1,10 +1,10 @@
1
1
  require "spec_helper"
2
2
 
3
- describe Membrane::Schema::Enum do
3
+ describe Membrane::Schemas::Enum do
4
4
  describe "#validate" do
5
- let (:int_schema) { Membrane::Schema::Class.new(Integer) }
6
- let (:str_schema) { Membrane::Schema::Class.new(String) }
7
- let (:enum_schema) { Membrane::Schema::Enum.new(int_schema, str_schema) }
5
+ let (:int_schema) { Membrane::Schemas::Class.new(Integer) }
6
+ let (:str_schema) { Membrane::Schemas::Class.new(String) }
7
+ let (:enum_schema) { Membrane::Schemas::Enum.new(int_schema, str_schema) }
8
8
 
9
9
  it "should return an error if none of the schemas validate" do
10
10
  expect_validation_failure(enum_schema, :sym, /doesn't validate/)