membrane 0.0.2 → 0.0.4

data/spec/{list_schema_spec.rb → schemas/list_spec.rb}

@@ -1,29 +1,29 @@
 require "spec_helper"
 
-describe Membrane::Schema::List do
+describe Membrane::Schemas::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)
+      schema = Membrane::Schemas::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")
+      item_schema = double("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 = Membrane::Schemas::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)
+    item_schema = Membrane::Schemas::Class.new(Integer)
+    list_schema = Membrane::Schemas::List.new(item_schema)
 
     errors = nil
 
@@ -38,8 +38,8 @@ describe Membrane::Schema::List do
   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)
+    item_schema = Membrane::Schemas::Class.new(Integer)
+    list_schema = Membrane::Schemas::List.new(item_schema)
 
     list_schema.validate([1, 2, 3]).should be_nil
   end

data/spec/schemas/record_spec.rb

@@ -0,0 +1,108 @@
+require "spec_helper"
+
+describe Membrane::Schemas::Record do
+  describe "#validate" do
+    it "should return an error if the validated object isn't a hash" do
+      schema = Membrane::Schemas::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::Schemas::Any.new }
+      rec_schema = Membrane::Schemas::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" => double("foo"),
+        "bar" => double("bar"),
+      }
+
+      key_schemas.each { |k, m| m.should_receive(:validate).with(data[k]) }
+
+      rec_schema = Membrane::Schemas::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::Schemas::Any.new,
+        "bar" => Membrane::Schemas::Class.new(String),
+      }
+
+      rec_schema = Membrane::Schemas::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
+
+    context "when strict checking" do
+      it "raises an error if there are extra keys that are not matched in the schema" do
+        data = {
+          "key" => "value",
+          "other_key" => 2,
+        }
+
+        rec_schema = Membrane::Schemas::Record.new({
+          "key" => Membrane::Schemas::Class.new(String)
+        }, [], true)
+
+        expect {
+          rec_schema.validate(data)
+        }.to raise_error(/other_key .* was not specified/)
+      end
+    end
+
+    context "when not strict checking" do
+      it "doesnt raise an error" do
+        data = {
+          "key" => "value",
+          "other_key" => 2,
+        }
+
+        rec_schema = Membrane::Schemas::Record.new({
+          "key" => Membrane::Schemas::Class.new(String)
+        })
+
+        expect {
+          rec_schema.validate(data)
+        }.to_not raise_error
+      end
+    end
+  end
+
+  describe "#parse" do
+    it "allows chaining/inheritance of schemas" do
+      base_schema = Membrane::SchemaParser.parse{{
+        "key" => String
+      }}
+
+      specific_schema = base_schema.parse{{
+        "another_key" => String
+      }}
+
+      input_hash = {
+        "key" => "value",
+        "another_key" => "another value",
+      }
+      specific_schema.validate(input_hash).should == nil
+    end
+  end
+end

data/spec/{regexp_schema_spec.rb → schemas/regexp_spec.rb}

@@ -1,7 +1,7 @@
 require "spec_helper"
 
-describe Membrane::Schema::Regexp do
-  let(:schema) { Membrane::Schema::Regexp.new(/bar/) }
+describe Membrane::Schemas::Regexp do
+  let(:schema) { Membrane::Schemas::Regexp.new(/bar/) }
 
   describe "#validate" do
     it "should raise an error if the validated object isn't a string" do

data/spec/{tuple_schema_spec.rb → schemas/tuple_spec.rb}

@@ -1,10 +1,10 @@
 require "spec_helper"
 
-describe Membrane::Schema::Tuple do
+describe Membrane::Schemas::Tuple do
   let(:schema) do
-    Membrane::Schema::Tuple.new(Membrane::Schema::Class.new(String),
-                                Membrane::Schema::ANY,
-                                Membrane::Schema::Class.new(Integer))
+    Membrane::Schemas::Tuple.new(Membrane::Schemas::Class.new(String),
+                                Membrane::Schemas::Any.new,
+                                Membrane::Schemas::Class.new(Integer))
   end
 
   describe "#validate" do

data/spec/{value_schema_spec.rb → schemas/value_spec.rb}

@@ -1,9 +1,9 @@
 require "spec_helper"
 
 
-describe Membrane::Schema::Value do
+describe Membrane::Schemas::Value do
   describe "#validate" do
-    let(:schema) { Membrane::Schema::Value.new("test") }
+    let(:schema) { Membrane::Schemas::Value.new("test") }
 
     it "should return nil for values that are equal" do
       schema.validate("test").should be_nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: membrane
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -68,41 +68,43 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE
+- NOTICE
 - README.md
 - Rakefile
 - lib/membrane.rb
 - lib/membrane/errors.rb
-- lib/membrane/schema.rb
-- lib/membrane/schema/any.rb
-- lib/membrane/schema/base.rb
-- lib/membrane/schema/bool.rb
-- lib/membrane/schema/class.rb
-- lib/membrane/schema/dictionary.rb
-- lib/membrane/schema/enum.rb
-- lib/membrane/schema/list.rb
-- lib/membrane/schema/record.rb
-- lib/membrane/schema/regexp.rb
-- lib/membrane/schema/tuple.rb
-- lib/membrane/schema/value.rb
 - lib/membrane/schema_parser.rb
+- lib/membrane/schemas.rb
+- lib/membrane/schemas/any.rb
+- lib/membrane/schemas/base.rb
+- lib/membrane/schemas/bool.rb
+- lib/membrane/schemas/class.rb
+- lib/membrane/schemas/dictionary.rb
+- lib/membrane/schemas/enum.rb
+- lib/membrane/schemas/list.rb
+- lib/membrane/schemas/record.rb
+- lib/membrane/schemas/regexp.rb
+- lib/membrane/schemas/tuple.rb
+- lib/membrane/schemas/value.rb
 - lib/membrane/version.rb
 - membrane.gemspec
-- spec/any_schema_spec.rb
-- spec/base_schema_spec.rb
-- spec/bool_schema_spec.rb
-- spec/class_schema_spec.rb
 - spec/complex_schema_spec.rb
-- spec/dictionary_schema_spec.rb
-- spec/enum_schema_spec.rb
-- spec/list_schema_spec.rb
-- spec/record_schema_spec.rb
-- spec/regexp_schema_spec.rb
 - spec/schema_parser_spec.rb
+- spec/schemas/any_spec.rb
+- spec/schemas/base_spec.rb
+- spec/schemas/bool_spec.rb
+- spec/schemas/class_spec.rb
+- spec/schemas/dictionary_spec.rb
+- spec/schemas/enum_spec.rb
+- spec/schemas/list_spec.rb
+- spec/schemas/record_spec.rb
+- spec/schemas/regexp_spec.rb
+- spec/schemas/tuple_spec.rb
+- spec/schemas/value_spec.rb
 - spec/spec_helper.rb
-- spec/tuple_schema_spec.rb
-- spec/value_schema_spec.rb
 homepage: http://www.cloudfoundry.org
 licenses: []
 post_install_message: 
@@ -128,17 +130,17 @@ signing_key:
 specification_version: 3
 summary: A DSL for validating data.
 test_files:
-- spec/any_schema_spec.rb
-- spec/base_schema_spec.rb
-- spec/bool_schema_spec.rb
-- spec/class_schema_spec.rb
 - spec/complex_schema_spec.rb
-- spec/dictionary_schema_spec.rb
-- spec/enum_schema_spec.rb
-- spec/list_schema_spec.rb
-- spec/record_schema_spec.rb
-- spec/regexp_schema_spec.rb
 - spec/schema_parser_spec.rb
+- spec/schemas/any_spec.rb
+- spec/schemas/base_spec.rb
+- spec/schemas/bool_spec.rb
+- spec/schemas/class_spec.rb
+- spec/schemas/dictionary_spec.rb
+- spec/schemas/enum_spec.rb
+- spec/schemas/list_spec.rb
+- spec/schemas/record_spec.rb
+- spec/schemas/regexp_spec.rb
+- spec/schemas/tuple_spec.rb
+- spec/schemas/value_spec.rb
 - spec/spec_helper.rb
-- spec/tuple_schema_spec.rb
-- spec/value_schema_spec.rb

data/lib/membrane/schema/any.rb

@@ -1,13 +0,0 @@
-require "membrane/errors"
-require "membrane/schema/base"
-
-module Membrane
-  module Schema
-  end
-end
-
-class Membrane::Schema::Any < Membrane::Schema::Base
-  def validate(object)
-    nil
-  end
-end

data/lib/membrane/schema/bool.rb

@@ -1,20 +0,0 @@
-require "set"
-
-require "membrane/errors"
-require "membrane/schema/base"
-
-module Membrane
-  module Schema
-  end
-end
-
-class Membrane::Schema::Bool < Membrane::Schema::Base
-  TRUTH_VALUES = Set.new([true, false])
-
-  def validate(object)
-    if !TRUTH_VALUES.include?(object)
-      emsg = "Expected instance of true or false, given #{object}"
-      raise Membrane::SchemaValidationError.new(emsg)
-    end
-  end
-end

data/lib/membrane/schema/class.rb

@@ -1,24 +0,0 @@
-require "membrane/errors"
-require "membrane/schema/base"
-
-module Membrane
-  module Schema
-  end
-end
-
-class Membrane::Schema::Class < Membrane::Schema::Base
-  attr_reader :klass
-
-  def initialize(klass)
-    @klass = klass
-  end
-
-  # Validates whether or not the supplied object is derived from klass
-  def validate(object)
-    if !object.kind_of?(@klass)
-      emsg = "Expected instance of #{@klass}," \
-             + " given an instance of #{object.class}"
-      raise Membrane::SchemaValidationError.new(emsg)
-    end
-  end
-end

data/lib/membrane/schema/dictionary.rb

@@ -1,40 +0,0 @@
-require "membrane/errors"
-require "membrane/schema/base"
-
-module Membrane
-  module Schema
-  end
-end
-
-class Membrane::Schema::Dictionary < Membrane::Schema::Base
-  attr_reader :key_schema
-  attr_reader :value_schema
-
-  def initialize(key_schema, value_schema)
-    @key_schema = key_schema
-    @value_schema = value_schema
-  end
-
-  def validate(object)
-    if !object.kind_of?(Hash)
-      emsg = "Expected instance of Hash, given instance of #{object.class}."
-      raise Membrane::SchemaValidationError.new(emsg)
-    end
-
-    errors = {}
-
-    object.each do |k, v|
-      begin
-        @key_schema.validate(k)
-        @value_schema.validate(v)
-      rescue Membrane::SchemaValidationError => e
-        errors[k] = e.to_s
-      end
-    end
-
-    if errors.size > 0
-      emsg = "{ " + errors.map { |k, e| "#{k} => #{e}" }.join(", ") + " }"
-      raise Membrane::SchemaValidationError.new(emsg)
-    end
-  end
-end

data/lib/membrane/schema/enum.rb

@@ -1,30 +0,0 @@
-require "membrane/errors"
-require "membrane/schema/base"
-
-module Membrane
-  module Schema
-  end
-end
-
-class Membrane::Schema::Enum < Membrane::Schema::Base
-  attr_reader :elem_schemas
-
-  def initialize(*elem_schemas)
-    @elem_schemas = elem_schemas
-    @elem_schema_str = elem_schemas.map { |s| s.to_s }.join(", ")
-  end
-
-  def validate(object)
-    @elem_schemas.each do |schema|
-      begin
-        schema.validate(object)
-        return nil
-      rescue Membrane::SchemaValidationError
-      end
-    end
-
-    emsg = "Object #{object} doesn't validate" \
-           + " against any of #{@elem_schema_str}"
-    raise Membrane::SchemaValidationError.new(emsg)
-  end
-end

data/lib/membrane/schema/list.rb

@@ -1,37 +0,0 @@
-require "membrane/errors"
-require "membrane/schema/base"
-
-module Membrane
-  module Schema
-  end
-end
-
-class Membrane::Schema::List < Membrane::Schema::Base
-  attr_reader :elem_schema
-
-  def initialize(elem_schema)
-    @elem_schema = elem_schema
-  end
-
-  def validate(object)
-    if !object.kind_of?(Array)
-      emsg = "Expected instance of Array, given instance of #{object.class}"
-      raise Membrane::SchemaValidationError.new(emsg)
-    end
-
-    errors = {}
-
-    object.each_with_index do |elem, ii|
-      begin
-        @elem_schema.validate(elem)
-      rescue Membrane::SchemaValidationError => e
-        errors[ii] = e.to_s
-      end
-    end
-
-    if errors.size > 0
-      emsg = errors.map { |ii, e| "At index #{ii}: #{e}" }.join(", ")
-      raise Membrane::SchemaValidationError.new(emsg)
-    end
-  end
-end

data/lib/membrane/schema/record.rb

@@ -1,45 +0,0 @@
-require "set"
-
-require "membrane/errors"
-require "membrane/schema/base"
-
-module Membrane
-  module Schema
-  end
-end
-
-class Membrane::Schema::Record < Membrane::Schema::Base
-  attr_reader :schemas
-  attr_reader :optional_keys
-
-  def initialize(schemas, optional_keys = [])
-    @optional_keys = Set.new(optional_keys)
-    @schemas = schemas
-  end
-
-  def validate(object)
-    unless object.kind_of?(Hash)
-      emsg = "Expected instance of Hash, given instance of #{object.class}"
-      raise Membrane::SchemaValidationError.new(emsg)
-    end
-
-    key_errors = {}
-
-    @schemas.each do |k, schema|
-      if object.has_key?(k)
-        begin
-          schema.validate(object[k])
-        rescue Membrane::SchemaValidationError => e
-          key_errors[k] = e.to_s
-        end
-      elsif !@optional_keys.include?(k)
-        key_errors[k] = "Missing key"
-      end
-    end
-
-    if key_errors.size > 0
-      emsg = "{ " + key_errors.map { |k, e| "#{k} => #{e}" }.join(", ") + " }"
-      raise Membrane::SchemaValidationError.new(emsg)
-    end
-  end
-end

data/lib/membrane/schema/regexp.rb

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

data/lib/membrane/schema/tuple.rb

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

data/lib/membrane/schema/value.rb

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

data/lib/membrane/schema.rb

@@ -1,17 +0,0 @@
-require "membrane/schema/any"
-require "membrane/schema/base"
-require "membrane/schema/bool"
-require "membrane/schema/class"
-require "membrane/schema/dictionary"
-require "membrane/schema/enum"
-require "membrane/schema/list"
-require "membrane/schema/record"
-require "membrane/schema/regexp"
-require "membrane/schema/tuple"
-require "membrane/schema/value"
-
-module Membrane
-  module Schema
-    ANY = Membrane::Schema::Any.new
-  end
-end

data/spec/record_schema_spec.rb

@@ -1,56 +0,0 @@
-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