membrane 0.0.1

data/spec/any_schema_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+describe Membrane::Schema::Any do
+  describe "#validate" do
+    it "should always return nil" do
+      schema = Membrane::Schema::Any.new
+      # Smoke test more than anything. Cannot validate this with 100%
+      # certainty.
+      [1, "hi", :test, {}, []].each do |o|
+        schema.validate(o).should be_nil
+      end
+    end
+  end
+end

data/spec/bool_schema_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+
+describe Membrane::Schema::Bool do
+  describe "#validate" do
+    let(:schema) { Membrane::Schema::Bool.new }
+
+    it "should return nil for {true, false}" do
+      [true, false].each { |v| schema.validate(v).should be_nil }
+    end
+
+    it "should return an error for values not in {true, false}" do
+      ["a", 1].each do |v|
+        expect_validation_failure(schema, v, /true or false/)
+      end
+    end
+  end
+end

data/spec/class_schema_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+
+describe Membrane::Schema::Class do
+  describe "#validate" do
+    let(:schema) { Membrane::Schema::Class.new(String) }
+
+    it "should return nil for instances of the supplied class" do
+      schema.validate("test").should be_nil
+    end
+
+    it "should return nil for subclasses of the supplied class" do
+      class StrTest < String; end
+
+      schema.validate(StrTest.new("hi")).should be_nil
+    end
+
+    it "should return an error for non class instances" do
+      expect_validation_failure(schema, 10, /instance of String/)
+    end
+  end
+end

data/spec/complex_schema_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+describe Membrane do
+  let(:schema) do
+    Membrane::SchemaParser.parse do
+      { "ints"       => [Integer],
+        "tf"         => bool,
+        "any"        => any,
+        "1_or_2"     => enum(1, 2),
+        "str_to_str_to_int" => dict(String, dict(String, Integer)),
+        optional("optional") => bool,
+      }
+    end
+  end
+
+  let(:valid) do
+    { "ints"       => [1, 2],
+      "tf"         => false,
+      "any"        => nil,
+      "1_or_2"     => 2,
+      "optional"   => true,
+      "str_to_str_to_int" => { "ten" => { "twenty" => 20 } },
+    }
+  end
+
+  it "should work with complex nested schemas" do
+    schema.validate(valid).should be_nil
+  end
+
+  it "should complain about missing keys" do
+    required_keys = schema.schemas.keys.dup
+    required_keys.delete("optional")
+
+    required_keys.each do |k|
+      invalid = valid.dup
+
+      invalid.delete(k)
+
+      expect_validation_failure(schema, invalid, /#{k} => Missing key/)
+    end
+  end
+
+  it "should validate nested maps" do
+    invalid = valid.dup
+
+    invalid["str_to_str_to_int"]["ten"]["twenty"] = "invalid"
+
+    expect_validation_failure(schema, invalid, /twenty => Expected/)
+  end
+end

data/spec/dictionary_schema_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe Membrane::Schema::Dictionary do
+  describe "#validate" do
+    let (:data) { { "foo" => 1, "bar" => 2 } }
+
+    it "should return an error if supplied with a non-hash" do
+      schema = Membrane::Schema::Dictionary.new(nil, nil)
+
+      expect_validation_failure(schema, "test", /instance of Hash/)
+    end
+
+    it "should validate each key against the supplied key schema" do
+      key_schema = mock("key_schema")
+
+      data.keys.each { |k| key_schema.should_receive(:validate).with(k) }
+
+      dict_schema = Membrane::Schema::Dictionary.new(key_schema,
+                                                     Membrane::Schema::Any.new)
+
+      dict_schema.validate(data)
+    end
+
+    it "should validate the value for each valid key" do
+      key_schema = Membrane::Schema::Class.new(String)
+      val_schema = mock("val_schema")
+
+      data.values.each { |v| val_schema.should_receive(:validate).with(v) }
+
+      dict_schema = Membrane::Schema::Dictionary.new(key_schema, val_schema)
+
+      dict_schema.validate(data)
+    end
+
+    it "should return any errors for keys or values that didn't validate" do
+      bad_data = {
+        "foo" => "bar",
+        :bar  => 2,
+      }
+
+      key_schema = Membrane::Schema::Class.new(String)
+      val_schema = Membrane::Schema::Class.new(Integer)
+      dict_schema = Membrane::Schema::Dictionary.new(key_schema, val_schema)
+
+      errors = nil
+
+      begin
+        dict_schema.validate(bad_data)
+      rescue Membrane::SchemaValidationError => e
+        errors = e.to_s
+      end
+
+      errors.should match(/foo/)
+      errors.should match(/bar/)
+    end
+  end
+end

data/spec/enum_schema_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe Membrane::Schema::Enum do
+  describe "#validate" do
+    let (:int_schema) { Membrane::Schema::Class.new(Integer) }
+    let (:str_schema) { Membrane::Schema::Class.new(String) }
+    let (:enum_schema) { Membrane::Schema::Enum.new(int_schema, str_schema) }
+
+    it "should return an error if none of the schemas validate" do
+      expect_validation_failure(enum_schema, :sym, /doesn't validate/)
+    end
+
+    it "should return nil if any of the schemas validate" do
+      enum_schema.validate("foo").should be_nil
+    end
+  end
+end

data/spec/list_schema_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+
+describe Membrane::Schema::List do
+  describe "#validate" do
+    it "should return an error if the validated object isn't an array" do
+      schema = Membrane::Schema::List.new(nil)
+
+      expect_validation_failure(schema, "hi", /instance of Array/)
+    end
+
+    it "should invoke validate each list item against the supplied schema" do
+      item_schema = mock("item_schema")
+
+      data = [0, 1, 2]
+
+      data.each { |x| item_schema.should_receive(:validate).with(x) }
+
+      list_schema = Membrane::Schema::List.new(item_schema)
+
+      list_schema.validate(data)
+    end
+  end
+
+  it "should return an error if any items fail to validate" do
+    item_schema = Membrane::Schema::Class.new(Integer)
+    list_schema = Membrane::Schema::List.new(item_schema)
+
+    errors = nil
+
+    begin
+      list_schema.validate([1, 2, "hi", 3, :there])
+    rescue Membrane::SchemaValidationError => e
+      errors = e.to_s
+    end
+
+    errors.should match(/index 2/)
+    errors.should match(/index 4/)
+  end
+
+  it "should return nil if all items validate" do
+    item_schema = Membrane::Schema::Class.new(Integer)
+    list_schema = Membrane::Schema::List.new(item_schema)
+
+    list_schema.validate([1, 2, 3]).should be_nil
+  end
+end

data/spec/record_schema_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+describe Membrane::Schema::Record do
+  describe "#validate" do
+    it "should return an error if the validated object isn't a hash" do
+      schema = Membrane::Schema::Record.new(nil)
+
+      expect_validation_failure(schema, "test", /instance of Hash/)
+    end
+
+    it "should return an error for missing keys" do
+      key_schemas = { "foo" => Membrane::Schema::ANY }
+      rec_schema = Membrane::Schema::Record.new(key_schemas)
+
+      expect_validation_failure(rec_schema, {}, /foo => Missing/)
+    end
+
+    it "should validate the value for each key" do
+      data = {
+        "foo" => 1,
+        "bar" => 2,
+      }
+
+      key_schemas = {
+        "foo" => mock("foo"),
+        "bar" => mock("bar"),
+      }
+
+      key_schemas.each { |k, m| m.should_receive(:validate).with(data[k]) }
+
+      rec_schema = Membrane::Schema::Record.new(key_schemas)
+
+      rec_schema.validate(data)
+    end
+
+    it "should return all errors for keys or values that didn't validate" do
+      key_schemas = {
+        "foo" => Membrane::Schema::ANY,
+        "bar" => Membrane::Schema::Class.new(String),
+      }
+
+      rec_schema = Membrane::Schema::Record.new(key_schemas)
+
+      errors = nil
+
+      begin
+        rec_schema.validate({ "bar" => 2 })
+      rescue Membrane::SchemaValidationError => e
+        errors = e.to_s
+      end
+
+      errors.should match(/foo => Missing key/)
+      errors.should match(/bar/)
+    end
+  end
+end

data/spec/regexp_schema_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe Membrane::Schema::Regexp do
+  let(:schema) { Membrane::Schema::Regexp.new(/bar/) }
+
+  describe "#validate" do
+    it "should raise an error if the validated object isn't a string" do
+      expect_validation_failure(schema, 5, /instance of String/)
+    end
+
+    it "should raise an error if the validated object doesn't match" do
+      expect_validation_failure(schema, "invalid", /match regex/)
+    end
+
+    it "should return nil if the validated object matches" do
+      schema.validate("barbar").should be_nil
+    end
+  end
+end

data/spec/schema_parser_spec.rb

@@ -0,0 +1,249 @@
+require "spec_helper"
+
+describe Membrane::SchemaParser do
+  let(:parser) { Membrane::SchemaParser.new }
+
+  describe "#deparse" do
+    it "should call inspect on the value of a Value schema" do
+      val = "test"
+      val.should_receive(:inspect).twice
+      schema = Membrane::Schema::Value.new(val)
+
+      parser.deparse(schema).should == val.inspect
+    end
+
+    it "should return 'any' for instance of Membrane::Schema::Any" do
+      schema = Membrane::Schema::Any.new
+
+      parser.deparse(schema).should == "any"
+    end
+
+    it "should return 'bool' for instances of Membrane::Schema::Bool" do
+      schema = Membrane::Schema::Bool.new
+
+      parser.deparse(schema).should == "bool"
+    end
+
+    it "should call inspect on the class of a Membrane::Schema::Class schema" do
+      klass = String
+      klass.should_receive(:inspect).twice
+      schema = Membrane::Schema::Class.new(klass)
+
+      parser.deparse(schema).should == klass.inspect
+    end
+
+    it "should deparse the k/v schemas of a Membrane::Schema::Dictionary schema" do
+      key_schema = Membrane::Schema::Class.new(String)
+      val_schema = Membrane::Schema::Class.new(Integer)
+
+      dict_schema = Membrane::Schema::Dictionary.new(key_schema, val_schema)
+
+      parser.deparse(dict_schema).should == "dict(String, Integer)"
+    end
+
+    it "should deparse the element schemas of a Membrane::Schema::Enum schema" do
+      schemas =
+        [String, Integer, Float].map { |c| Membrane::Schema::Class.new(c) }
+
+      enum_schema = Membrane::Schema::Enum.new(*schemas)
+
+      parser.deparse(enum_schema).should == "enum(String, Integer, Float)"
+    end
+
+    it "should deparse the element schema of a Membrane::Schema::List schema" do
+      key_schema = Membrane::Schema::Class.new(String)
+      val_schema = Membrane::Schema::Class.new(Integer)
+      item_schema = Membrane::Schema::Dictionary.new(key_schema, val_schema)
+
+      list_schema = Membrane::Schema::List.new(item_schema)
+
+      parser.deparse(list_schema).should == "[dict(String, Integer)]"
+    end
+
+    it "should deparse elem schemas of a Membrane::Schema::Record schema" do
+      str_schema = Membrane::Schema::Class.new(String)
+      int_schema = Membrane::Schema::Class.new(Integer)
+      dict_schema = Membrane::Schema::Dictionary.new(str_schema, int_schema)
+
+      int_rec_schema = Membrane::Schema::Record.new({:str => str_schema,
+                                                      :dict => dict_schema})
+
+      rec_schema = Membrane::Schema::Record.new({"str" => str_schema,
+                                                  "rec" => int_rec_schema,
+                                                  "int" => int_schema})
+      exp_deparse =<<EOT
+{
+"str" => String,
+"rec" => {
+  :str => String,
+  :dict => dict(String, Integer),
+  },
+"int" => Integer,
+}
+EOT
+      parser.deparse(rec_schema).should == exp_deparse.strip
+    end
+
+    it "should call inspect on regexps for Membrane::Schema::Regexp" do
+      schema = Membrane::Schema::Regexp.new(/test/)
+      schema.regexp.should_receive(:inspect)
+      parser.deparse(schema)
+    end
+
+    it "should deparse the element schemas of a Membrane::Schema::Tuple schema" do
+      schemas = [String, Integer].map { |c| Membrane::Schema::Class.new(c) }
+      schemas << Membrane::Schema::Value.new("test")
+
+      enum_schema = Membrane::Schema::Tuple.new(*schemas)
+
+      parser.deparse(enum_schema).should == 'tuple(String, Integer, "test")'
+    end
+
+    it "should raise an error if given a non-schema" do
+      expect do
+        parser.deparse({})
+      end.to raise_error(ArgumentError, /Expected instance/)
+    end
+  end
+
+  describe "#parse" do
+    it "should leave instances derived from Membrane::Schema::Base unchanged" do
+      old_schema = Membrane::Schema::ANY
+
+      parser.parse { old_schema }.should == old_schema
+    end
+
+    it "should translate 'any' into Membrane::Schema::Any" do
+      schema = parser.parse { any }
+
+      schema.class.should == Membrane::Schema::Any
+    end
+
+    it "should translate 'bool' into Membrane::Schema::Bool" do
+      schema = parser.parse { bool }
+
+      schema.class.should == Membrane::Schema::Bool
+    end
+
+    it "should translate 'enum' into Membrane::Schema::Enum" do
+      schema = parser.parse { enum(bool, any) }
+
+      schema.class.should == Membrane::Schema::Enum
+
+      schema.elem_schemas.length.should == 2
+
+      elem_schema_classes = schema.elem_schemas.map { |es| es.class }
+
+      expected_classes = [Membrane::Schema::Bool, Membrane::Schema::Any]
+      elem_schema_classes.should == expected_classes
+    end
+
+    it "should translate 'dict' into Membrane::Schema::Dictionary" do
+      schema = parser.parse { dict(String, Integer) }
+
+      schema.class.should == Membrane::Schema::Dictionary
+
+      schema.key_schema.class.should == Membrane::Schema::Class
+      schema.key_schema.klass.should == String
+
+      schema.value_schema.class.should == Membrane::Schema::Class
+      schema.value_schema.klass.should == Integer
+    end
+
+    it "should translate 'tuple' into Membrane::Schema::Tuple" do
+      schema = parser.parse { tuple(String, any, Integer) }
+
+      schema.class.should == Membrane::Schema::Tuple
+
+      schema.elem_schemas[0].class.should == Membrane::Schema::Class
+      schema.elem_schemas[0].klass.should == String
+
+      schema.elem_schemas[1].class == Membrane::Schema::Any
+
+      schema.elem_schemas[2].class.should == Membrane::Schema::Class
+      schema.elem_schemas[2].klass.should == Integer
+    end
+
+    it "should translate classes into Membrane::Schema::Class" do
+      schema = parser.parse { String }
+
+      schema.class.should == Membrane::Schema::Class
+
+      schema.klass.should == String
+    end
+
+    it "should translate regexps into Membrane::Schema::Regexp" do
+      regexp = /foo/
+
+      schema = parser.parse { regexp }
+
+      schema.class.should == Membrane::Schema::Regexp
+
+      schema.regexp.should == regexp
+    end
+
+    it "should fall back to Membrane::Schema::Value" do
+      schema = parser.parse { 5 }
+
+      schema.class.should == Membrane::Schema::Value
+      schema.value.should == 5
+    end
+
+    describe "when parsing a list" do
+      it "should raise an error when no element schema is supplied" do
+        expect do
+          parser.parse { [] }
+        end.to raise_error(ArgumentError, /must supply/)
+      end
+
+      it "should raise an error when supplied > 1 element schema" do
+        expect do
+          parser.parse { [String, String] }
+        end.to raise_error(ArgumentError, /single schema/)
+      end
+
+      it "should parse '[<expr>]' into Membrane::Schema::List" do
+        schema = parser.parse { [String] }
+
+        schema.class.should == Membrane::Schema::List
+
+        schema.elem_schema.class.should == Membrane::Schema::Class
+        schema.elem_schema.klass.should == String
+      end
+    end
+
+    describe "when parsing a record" do
+      it "should raise an error if the record is empty" do
+        expect do
+          parser.parse { {} }
+        end.to raise_error(ArgumentError, /must supply/)
+      end
+
+      it "should parse '{ <key> => <schema> }' into Membrane::Schema::Record" do
+        schema = parser.parse do
+          { "string" => String,
+            "ints"   => [Integer],
+          }
+        end
+
+        schema.class.should == Membrane::Schema::Record
+
+        str_schema = schema.schemas["string"]
+        str_schema.class.should == Membrane::Schema::Class
+        str_schema.klass.should == String
+
+        ints_schema = schema.schemas["ints"]
+        ints_schema.class.should == Membrane::Schema::List
+        ints_schema.elem_schema.class.should == Membrane::Schema::Class
+        ints_schema.elem_schema.klass.should == Integer
+      end
+
+      it "should handle keys marked with 'optional()'" do
+        schema = parser.parse { { optional("test") => Integer } }
+
+        schema.class.should == Membrane::Schema::Record
+        schema.optional_keys.to_a.should == ["test"]
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require "membrane"
+
+def expect_validation_failure(schema, object, regex)
+  expect do
+    schema.validate(object)
+  end.to raise_error(Membrane::SchemaValidationError, regex)
+end

data/spec/tuple_schema_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe Membrane::Schema::Tuple do
+  let(:schema) do
+    Membrane::Schema::Tuple.new(Membrane::Schema::Class.new(String),
+                                Membrane::Schema::ANY,
+                                Membrane::Schema::Class.new(Integer))
+  end
+
+  describe "#validate" do
+    it "should raise an error if the validated object isn't an array" do
+      expect_validation_failure(schema, {}, /Array/)
+    end
+
+    it "should raise an error if the validated object has too many/few items" do
+      expect_validation_failure(schema, ["foo", 2], /element/)
+      expect_validation_failure(schema, ["foo", 2, "bar", 3], /element/)
+    end
+
+    it "should raise an error if any of the items do not validate" do
+      expect_validation_failure(schema, [5, 2, 0], /0 =>/)
+      expect_validation_failure(schema, ["foo", 2, "foo"], /2 =>/)
+    end
+
+    it "should return nil when validation succeeds" do
+      schema.validate(["foo", "bar", 5]).should be_nil
+    end
+  end
+end

data/spec/value_schema_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+
+describe Membrane::Schema::Value do
+  describe "#validate" do
+    let(:schema) { Membrane::Schema::Value.new("test") }
+
+    it "should return nil for values that are equal" do
+      schema.validate("test").should be_nil
+    end
+
+    it "should return an error for values that are not equal" do
+      expect_validation_failure(schema, "tast", /Expected test/)
+    end
+  end
+end