membrane 0.0.2 → 0.0.4

data/lib/membrane/schemas/regexp.rb

@@ -0,0 +1,60 @@
+require "membrane/errors"
+require "membrane/schemas/base"
+
+module Membrane
+  module Schema
+  end
+end
+
+class Membrane::Schemas::Regexp < Membrane::Schemas::Base
+  attr_reader :regexp
+
+  def initialize(regexp)
+    @regexp = regexp
+  end
+
+  def validate(object)
+    StringValidator.new(object).validate
+    MatchValidator.new(@regexp, object).validate
+
+    nil
+  end
+
+  class StringValidator
+
+    def initialize(object)
+      @object = object
+    end
+
+    def validate
+      fail! if !@object.kind_of?(String)
+    end
+
+    private
+
+    def fail!
+      emsg = "Expected instance of String, given instance of #{@object.class}"
+      raise Membrane::SchemaValidationError.new(emsg)
+    end
+
+  end
+
+  class MatchValidator
+
+    def initialize(regexp, object)
+      @regexp = regexp
+      @object = object
+    end
+
+    def validate
+      fail! if !@regexp.match(@object)
+    end
+
+    private
+
+    def fail!
+      emsg = "Value #{@object} doesn't match regexp #{@regexp}"
+      raise Membrane::SchemaValidationError.new(emsg)
+    end
+  end
+end

data/lib/membrane/schemas/tuple.rb

@@ -0,0 +1,90 @@
+require "membrane/errors"
+require "membrane/schemas/base"
+
+module Membrane
+  module Schema
+  end
+end
+
+class Membrane::Schemas::Tuple < Membrane::Schemas::Base
+  attr_reader :elem_schemas
+
+  def initialize(*elem_schemas)
+    @elem_schemas = elem_schemas
+  end
+
+  def validate(object)
+    ArrayValidator.new(object).validate
+    LengthValidator.new(@elem_schemas, object).validate
+    MemberValidator.new(@elem_schemas, object).validate
+
+    nil
+  end
+
+  class ArrayValidator
+    def initialize(object)
+      @object = object
+    end
+
+    def validate
+      fail! if !@object.kind_of?(Array)
+    end
+
+    private
+
+    def fail!
+      emsg = "Expected instance of Array, given instance of #{@object.class}"
+      raise Membrane::SchemaValidationError.new(emsg)
+    end
+  end
+
+  class LengthValidator
+    def initialize(elem_schemas, object)
+      @elem_schemas = elem_schemas
+      @object = object
+    end
+
+    def validate
+      expected = @elem_schemas.length
+      actual = @object.length
+
+      fail!(expected, actual) if actual != expected
+    end
+
+    private
+
+    def fail!(expected, actual)
+      emsg = "Expected #{expected} element(s), given #{actual}"
+      raise Membrane::SchemaValidationError.new(emsg)
+    end
+  end
+
+  class MemberValidator
+    def initialize(elem_schemas, object)
+      @elem_schemas = elem_schemas
+      @object = object
+    end
+
+    def validate
+      errors = {}
+
+      @elem_schemas.each_with_index do |schema, ii|
+        begin
+          schema.validate(@object[ii])
+        rescue Membrane::SchemaValidationError => e
+          errors[ii] = e
+        end
+      end
+
+      fail!(errors) if errors.size > 0
+    end
+
+    private
+
+    def fail!(errors)
+      emsg = "There were errors at the following indices: " \
+             + errors.map { |ii, err| "#{ii} => #{err}" }.join(", ")
+      raise Membrane::SchemaValidationError.new(emsg)
+    end
+  end
+end

data/lib/membrane/schemas/value.rb

@@ -0,0 +1,37 @@
+require "membrane/errors"
+require "membrane/schemas/base"
+
+module Membrane
+  module Schema
+  end
+end
+
+class Membrane::Schemas::Value < Membrane::Schemas::Base
+  attr_reader :value
+
+  def initialize(value)
+    @value = value
+  end
+
+  def validate(object)
+    ValueValidator.new(@value, object).validate
+  end
+
+  class ValueValidator
+    def initialize(value, object)
+      @value = value
+      @object = object
+    end
+
+    def validate
+      fail!(@value, @object) if @object != @value
+    end
+
+    private
+
+    def fail!(expected, given)
+      emsg = "Expected #{expected}, given #{given}"
+      raise Membrane::SchemaValidationError.new(emsg)
+    end
+  end
+end

data/lib/membrane/schemas.rb

@@ -0,0 +1,5 @@
+module Membrane
+  module Schemas; end
+end
+
+Dir[File.dirname(__FILE__) + '/schemas/*.rb'].each { |file| require file }

data/lib/membrane/version.rb

@@ -1,3 +1,3 @@
 module Membrane
-  VERSION = "0.0.2"
+  VERSION = "0.0.4"
 end

data/lib/membrane.rb

@@ -1,4 +1,4 @@
 require "membrane/errors"
-require "membrane/schema"
+require "membrane/schemas"
 require "membrane/schema_parser"
 require "membrane/version"

data/spec/schema_parser_spec.rb

@@ -7,100 +7,104 @@ describe Membrane::SchemaParser 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)
+      schema = Membrane::Schemas::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
+    it "should return 'any' for instance of Membrane::Schemas::Any" do
+      schema = Membrane::Schemas::Any.new
 
       parser.deparse(schema).should == "any"
     end
 
-    it "should return 'bool' for instances of Membrane::Schema::Bool" do
-      schema = Membrane::Schema::Bool.new
+    it "should return 'bool' for instances of Membrane::Schemas::Bool" do
+      schema = Membrane::Schemas::Bool.new
 
       parser.deparse(schema).should == "bool"
     end
 
-    it "should call name on the class of a Membrane::Schema::Class schema" do
+    it "should call name on the class of a Membrane::Schemas::Class schema" do
       klass = String
       klass.should_receive(:name).twice
-      schema = Membrane::Schema::Class.new(klass)
+      schema = Membrane::Schemas::Class.new(klass)
 
       parser.deparse(schema).should == klass.name
     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)
+    it "should deparse the k/v schemas of a Membrane::Schemas::Dictionary schema" do
+      key_schema = Membrane::Schemas::Class.new(String)
+      val_schema = Membrane::Schemas::Class.new(Integer)
 
-      dict_schema = Membrane::Schema::Dictionary.new(key_schema, val_schema)
+      dict_schema = Membrane::Schemas::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
+    it "should deparse the element schemas of a Membrane::Schemas::Enum schema" do
       schemas =
-        [String, Integer, Float].map { |c| Membrane::Schema::Class.new(c) }
+        [String, Integer, Float].map { |c| Membrane::Schemas::Class.new(c) }
 
-      enum_schema = Membrane::Schema::Enum.new(*schemas)
+      enum_schema = Membrane::Schemas::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)
+    it "should deparse the element schema of a Membrane::Schemas::List schema" do
+      key_schema = Membrane::Schemas::Class.new(String)
+      val_schema = Membrane::Schemas::Class.new(Integer)
+      item_schema = Membrane::Schemas::Dictionary.new(key_schema, val_schema)
 
-      list_schema = Membrane::Schema::List.new(item_schema)
+      list_schema = Membrane::Schemas::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,
+    it "should deparse elem schemas of a Membrane::Schemas::Record schema" do
+      str_schema = Membrane::Schemas::Class.new(String)
+      int_schema = Membrane::Schemas::Class.new(Integer)
+      dict_schema = Membrane::Schemas::Dictionary.new(str_schema, int_schema)
+
+      int_rec_schema = Membrane::Schemas::Record.new({
+                                                     :str => str_schema,
+                                                     :dict => dict_schema
+                                                    })
+      rec_schema = Membrane::Schemas::Record.new({
+                                                  "str" => str_schema,
                                                   "rec" => int_rec_schema,
-                                                  "int" => int_schema})
+                                                  "int" => int_schema
+                                                })
+
       exp_deparse =<<EOT
 {
-"str" => String,
-"rec" => {
-  :str => String,
-  :dict => dict(String, Integer),
+  "str" => String,
+  "rec" => {
+    :str => String,
+    :dict => dict(String, Integer),
   },
-"int" => 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/)
+    it "should call inspect on regexps for Membrane::Schemas::Regexp" do
+      schema = Membrane::Schemas::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")
+    it "should deparse the element schemas of a Membrane::Schemas::Tuple schema" do
+      schemas = [String, Integer].map { |c| Membrane::Schemas::Class.new(c) }
+      schemas << Membrane::Schemas::Value.new("test")
 
-      enum_schema = Membrane::Schema::Tuple.new(*schemas)
+      enum_schema = Membrane::Schemas::Tuple.new(*schemas)
 
       parser.deparse(enum_schema).should == 'tuple(String, Integer, "test")'
     end
 
-    it "should call inspect on a Membrane::Schema::Base schema" do
-      schema = Membrane::Schema::Base.new
+    it "should call inspect on a Membrane::Schemas::Base schema" do
+      schema = Membrane::Schemas::Base.new
       parser.deparse(schema).should == schema.inspect
     end
 
@@ -112,85 +116,85 @@ EOT
   end
 
   describe "#parse" do
-    it "should leave instances derived from Membrane::Schema::Base unchanged" do
-      old_schema = Membrane::Schema::ANY
+    it "should leave instances derived from Membrane::Schemas::Base unchanged" do
+      old_schema = Membrane::Schemas::Any.new
 
       parser.parse { old_schema }.should == old_schema
     end
 
-    it "should translate 'any' into Membrane::Schema::Any" do
+    it "should translate 'any' into Membrane::Schemas::Any" do
       schema = parser.parse { any }
 
-      schema.class.should == Membrane::Schema::Any
+      schema.class.should == Membrane::Schemas::Any
     end
 
-    it "should translate 'bool' into Membrane::Schema::Bool" do
+    it "should translate 'bool' into Membrane::Schemas::Bool" do
       schema = parser.parse { bool }
 
-      schema.class.should == Membrane::Schema::Bool
+      schema.class.should == Membrane::Schemas::Bool
     end
 
-    it "should translate 'enum' into Membrane::Schema::Enum" do
+    it "should translate 'enum' into Membrane::Schemas::Enum" do
       schema = parser.parse { enum(bool, any) }
 
-      schema.class.should == Membrane::Schema::Enum
+      schema.class.should == Membrane::Schemas::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]
+      expected_classes = [Membrane::Schemas::Bool, Membrane::Schemas::Any]
       elem_schema_classes.should == expected_classes
     end
 
-    it "should translate 'dict' into Membrane::Schema::Dictionary" do
+    it "should translate 'dict' into Membrane::Schemas::Dictionary" do
       schema = parser.parse { dict(String, Integer) }
 
-      schema.class.should == Membrane::Schema::Dictionary
+      schema.class.should == Membrane::Schemas::Dictionary
 
-      schema.key_schema.class.should == Membrane::Schema::Class
+      schema.key_schema.class.should == Membrane::Schemas::Class
       schema.key_schema.klass.should == String
 
-      schema.value_schema.class.should == Membrane::Schema::Class
+      schema.value_schema.class.should == Membrane::Schemas::Class
       schema.value_schema.klass.should == Integer
     end
 
-    it "should translate 'tuple' into Membrane::Schema::Tuple" do
+    it "should translate 'tuple' into Membrane::Schemas::Tuple" do
       schema = parser.parse { tuple(String, any, Integer) }
 
-      schema.class.should == Membrane::Schema::Tuple
+      schema.class.should == Membrane::Schemas::Tuple
 
-      schema.elem_schemas[0].class.should == Membrane::Schema::Class
+      schema.elem_schemas[0].class.should == Membrane::Schemas::Class
       schema.elem_schemas[0].klass.should == String
 
-      schema.elem_schemas[1].class == Membrane::Schema::Any
+      schema.elem_schemas[1].class == Membrane::Schemas::Any
 
-      schema.elem_schemas[2].class.should == Membrane::Schema::Class
+      schema.elem_schemas[2].class.should == Membrane::Schemas::Class
       schema.elem_schemas[2].klass.should == Integer
     end
 
-    it "should translate classes into Membrane::Schema::Class" do
+    it "should translate classes into Membrane::Schemas::Class" do
       schema = parser.parse { String }
 
-      schema.class.should == Membrane::Schema::Class
+      schema.class.should == Membrane::Schemas::Class
 
       schema.klass.should == String
     end
 
-    it "should translate regexps into Membrane::Schema::Regexp" do
+    it "should translate regexps into Membrane::Schemas::Regexp" do
       regexp = /foo/
 
       schema = parser.parse { regexp }
 
-      schema.class.should == Membrane::Schema::Regexp
+      schema.class.should == Membrane::Schemas::Regexp
 
       schema.regexp.should == regexp
     end
 
-    it "should fall back to Membrane::Schema::Value" do
+    it "should fall back to Membrane::Schemas::Value" do
       schema = parser.parse { 5 }
 
-      schema.class.should == Membrane::Schema::Value
+      schema.class.should == Membrane::Schemas::Value
       schema.value.should == 5
     end
 
@@ -207,12 +211,12 @@ EOT
         end.to raise_error(ArgumentError, /single schema/)
       end
 
-      it "should parse '[<expr>]' into Membrane::Schema::List" do
+      it "should parse '[<expr>]' into Membrane::Schemas::List" do
         schema = parser.parse { [String] }
 
-        schema.class.should == Membrane::Schema::List
+        schema.class.should == Membrane::Schemas::List
 
-        schema.elem_schema.class.should == Membrane::Schema::Class
+        schema.elem_schema.class.should == Membrane::Schemas::Class
         schema.elem_schema.klass.should == String
       end
     end
@@ -224,29 +228,29 @@ EOT
         end.to raise_error(ArgumentError, /must supply/)
       end
 
-      it "should parse '{ <key> => <schema> }' into Membrane::Schema::Record" do
+      it "should parse '{ <key> => <schema> }' into Membrane::Schemas::Record" do
         schema = parser.parse do
           { "string" => String,
             "ints"   => [Integer],
           }
         end
 
-        schema.class.should == Membrane::Schema::Record
+        schema.class.should == Membrane::Schemas::Record
 
         str_schema = schema.schemas["string"]
-        str_schema.class.should == Membrane::Schema::Class
+        str_schema.class.should == Membrane::Schemas::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.class.should == Membrane::Schemas::List
+        ints_schema.elem_schema.class.should == Membrane::Schemas::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.class.should == Membrane::Schemas::Record
         schema.optional_keys.to_a.should == ["test"]
       end
     end

data/spec/{any_schema_spec.rb → schemas/any_spec.rb}

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

data/spec/{base_schema_spec.rb → schemas/base_spec.rb}

@@ -1,9 +1,9 @@
 require "spec_helper"
 
 
-describe Membrane::Schema::Base do
+describe Membrane::Schemas::Base do
   describe "#validate" do
-    let(:schema) { Membrane::Schema::Base.new }
+    let(:schema) { Membrane::Schemas::Base.new }
 
     it "should raise error" do
       expect { schema.validate }.to raise_error

data/spec/{bool_schema_spec.rb → schemas/bool_spec.rb}

@@ -1,9 +1,8 @@
 require "spec_helper"
 
-
-describe Membrane::Schema::Bool do
+describe Membrane::Schemas::Bool do
   describe "#validate" do
-    let(:schema) { Membrane::Schema::Bool.new }
+    let(:schema) { Membrane::Schemas::Bool.new }
 
     it "should return nil for {true, false}" do
       [true, false].each { |v| schema.validate(v).should be_nil }

data/spec/{class_schema_spec.rb → schemas/class_spec.rb}

@@ -1,9 +1,9 @@
 require "spec_helper"
 
 
-describe Membrane::Schema::Class do
+describe Membrane::Schemas::Class do
   describe "#validate" do
-    let(:schema) { Membrane::Schema::Class.new(String) }
+    let(:schema) { Membrane::Schemas::Class.new(String) }
 
     it "should return nil for instances of the supplied class" do
       schema.validate("test").should be_nil

data/spec/{dictionary_schema_spec.rb → schemas/dictionary_spec.rb}

@@ -1,33 +1,33 @@
 require "spec_helper"
 
-describe Membrane::Schema::Dictionary do
+describe Membrane::Schemas::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)
+      schema = Membrane::Schemas::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")
+      key_schema = double("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 = Membrane::Schemas::Dictionary.new(key_schema,
+                                                     Membrane::Schemas::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")
+      key_schema = Membrane::Schemas::Class.new(String)
+      val_schema = double("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 = Membrane::Schemas::Dictionary.new(key_schema, val_schema)
 
       dict_schema.validate(data)
     end
@@ -38,9 +38,9 @@ describe Membrane::Schema::Dictionary do
         :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)
+      key_schema = Membrane::Schemas::Class.new(String)
+      val_schema = Membrane::Schemas::Class.new(Integer)
+      dict_schema = Membrane::Schemas::Dictionary.new(key_schema, val_schema)
 
       errors = nil
 

data/spec/{enum_schema_spec.rb → schemas/enum_spec.rb}

@@ -1,10 +1,10 @@
 require "spec_helper"
 
-describe Membrane::Schema::Enum do
+describe Membrane::Schemas::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) }
+    let (:int_schema) { Membrane::Schemas::Class.new(Integer) }
+    let (:str_schema) { Membrane::Schemas::Class.new(String) }
+    let (:enum_schema) { Membrane::Schemas::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/)