axiom 0.1.0 → 0.1.1

data/spec/unit/axiom/attribute/{class/class_methods/primitive_spec.rb → date_time/class_methods/type_spec.rb}

@@ -2,12 +2,12 @@
 
 require 'spec_helper'
 
-describe Attribute::Class, '.primitive' do
-  subject { object.primitive }
+describe Attribute::DateTime, '.type' do
+  subject { object.type }
 
   let(:object) { described_class }
 
   it_should_behave_like 'an idempotent method'
 
-  it { should equal(Class) }
+  it { should be(Types::DateTime) }
 end

data/spec/unit/axiom/attribute/decimal/class_methods/type_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Attribute::Decimal, '.type' do
+  subject { object.type }
+
+  let(:object) { described_class }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be(Types::Decimal) }
+end

data/spec/unit/axiom/attribute/eql_spec.rb

@@ -9,6 +9,10 @@ describe Attribute, '#eql?' do
   let(:name)            { :name                     }
   let(:object)          { described_class.new(name) }
 
+  before do
+    described_class.stub(type: Types::Object)
+  end
+
   context 'with the same object' do
     let(:other) { object }
 
@@ -50,7 +54,7 @@ describe Attribute, '#eql?' do
   end
 
   context 'with an object having a different required option' do
-    let(:other) { described_class.new(name, :required => false) }
+    let(:other) { described_class.new(name, required: false) }
 
     it { should be(false) }
 

data/spec/unit/axiom/attribute/equality_operator_spec.rb

@@ -9,6 +9,10 @@ describe Attribute, '#==' do
   let(:name)            { :name                     }
   let(:object)          { described_class.new(name) }
 
+  before do
+    described_class.stub(type: Types::Object)
+  end
+
   context 'with the same object' do
     let(:other) { object }
 
@@ -50,7 +54,7 @@ describe Attribute, '#==' do
   end
 
   context 'with an object having a different required option' do
-    let(:other) { described_class.new(name, :required => false) }
+    let(:other) { described_class.new(name, required: false) }
 
     it { should be(false) }
 

data/spec/unit/axiom/attribute/float/class_methods/type_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Attribute::Float, '.type' do
+  subject { object.type }
+
+  let(:object) { described_class }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be(Types::Float) }
+end

data/spec/unit/axiom/attribute/hash_spec.rb

@@ -8,10 +8,14 @@ describe Attribute, '#hash' do
   let(:described_class) { Class.new(Attribute)               }
   let(:name)            { :name                              }
   let(:required)        { true                               }
-  let(:options)         { { :required => required }          }
+  let(:options)         { { required: required }             }
   let(:object)          { described_class.new(name, options) }
 
+  before do
+    described_class.stub(type: Types::Object)
+  end
+
   it_should_behave_like 'a hash method'
 
-  it { should == described_class.hash ^ name.hash ^ required.hash }
+  it { should == described_class.hash ^ name.hash ^ object.type.hash ^ required.hash }
 end

data/spec/unit/axiom/attribute/{valid_value_predicate_spec.rb → include_predicate_spec.rb}

@@ -2,17 +2,13 @@
 
 require 'spec_helper'
 
-describe Attribute, '#valid_value?' do
-  subject { object.valid_value?(value) }
+describe Attribute, '#include?' do
+  subject { object.include?(value) }
 
   let(:described_class) { Class.new(Attribute) }
 
   before do
-    described_class.class_eval do
-      def self.primitive
-        ::Integer
-      end
-    end
+    described_class.stub(type: Types::Integer)
   end
 
   context 'when value is nil' do
@@ -25,7 +21,7 @@ describe Attribute, '#valid_value?' do
     end
 
     context 'and the attribute not required' do
-      let(:object) { described_class.new(:name, :required => false) }
+      let(:object) { described_class.new(:name, required: false) }
 
       it { should be(true) }
     end

data/spec/unit/axiom/attribute/integer/class_methods/type_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Attribute::Integer, '.type' do
+  subject { object.type }
+
+  let(:object) { described_class }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be(Types::Integer) }
+end

data/spec/unit/axiom/attribute/name_spec.rb

@@ -8,10 +8,14 @@ describe Attribute, '#name' do
   let(:described_class) { Class.new(Attribute)      }
   let(:object)          { described_class.new(name) }
 
+  before do
+    described_class.stub(type: Types::Object)
+  end
+
   context 'when name is a Symbol' do
     let(:name) { :name }
 
-    it { should equal(name) }
+    it { should be(name) }
   end
 
   context 'when name is a String' do

data/spec/unit/axiom/attribute/numeric/class_methods/type_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Attribute::Numeric, '.type' do
+  subject { object.type }
+
+  let(:object) { described_class }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be(Types::Numeric) }
+end

data/spec/unit/axiom/attribute/numeric/eql_spec.rb

@@ -50,7 +50,7 @@ describe Attribute::Numeric, '#eql?' do
   end
 
   context 'with an object having a different required option' do
-    let(:other) { described_class.new(name, :required => false) }
+    let(:other) { described_class.new(name, required: false) }
 
     it { should be(false) }
 
@@ -60,7 +60,7 @@ describe Attribute::Numeric, '#eql?' do
   end
 
   context 'with an object having a different size' do
-    let(:other) { described_class.new(name, :size => 0..100) }
+    let(:other) { described_class.new(name, size: 0..100) }
 
     it { should be(false) }
 

data/spec/unit/axiom/attribute/numeric/equality_operator_spec.rb

@@ -50,7 +50,7 @@ describe Attribute::Numeric, '#==' do
   end
 
   context 'with an object having a different required option' do
-    let(:other) { described_class.new(name, :required => false) }
+    let(:other) { described_class.new(name, required: false) }
 
     it { should be(false) }
 
@@ -60,7 +60,7 @@ describe Attribute::Numeric, '#==' do
   end
 
   context 'with an object having a different size' do
-    let(:other) { described_class.new(name, :size => 0..100) }
+    let(:other) { described_class.new(name, size: 0..100) }
 
     it { should be(false) }
 

data/spec/unit/axiom/attribute/numeric/hash_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Attribute::Numeric, '#hash' do
   subject { object.hash }
 
-  let(:object)     { described_class.new(name, options)       }
-  let(:name)       { :name                                    }
-  let(:options)    { { :required => required, :size => size } }
-  let(:required)   { true                                     }
-  let(:size)       { 0..10                                    }
+  let(:object)   { described_class.new(name, options) }
+  let(:name)     { :name                              }
+  let(:options)  { { required: required, size: size } }
+  let(:required) { true                               }
+  let(:size)     { 0..10                              }
 
   it_should_behave_like 'a hash method'
 
-  it { should == described_class.hash ^ name.hash ^ required.hash ^ size.hash }
+  it { should == described_class.hash ^ name.hash ^ object.type.hash ^ required.hash }
 end

data/spec/unit/axiom/attribute/numeric/{valid_value_predicate_spec.rb → include_predicate_spec.rb}

@@ -2,10 +2,10 @@
 
 require 'spec_helper'
 
-describe Attribute::Numeric, '#valid_value?' do
-  subject { object.valid_value?(value) }
+describe Attribute::Numeric, '#include?' do
+  subject { object.include?(value) }
 
-  let(:object) { described_class.new(:numeric, :size => 1..50) }
+  let(:object) { described_class.new(:numeric, size: 1..50) }
 
   context 'with a numeric value' do
     context 'that is within the allowed size range' do

data/spec/unit/axiom/attribute/object/class_methods/type_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Attribute::Object, '.type' do
+  subject { object.type }
+
+  let(:object) { described_class }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be(Types::Object) }
+end

data/spec/unit/axiom/attribute/optional_predicate_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Attribute, '#optional?' do
+  subject { object.optional? }
+
+  let(:described_class) { Class.new(Attribute) }
+
+  before do
+    described_class.stub(type: Types::Object)
+  end
+
+  context 'without :required option passed to constructor' do
+    let(:object) { described_class.new(:name) }
+
+    it { should be(false) }
+  end
+
+  context 'with required: true option passed to constructor' do
+    let(:object) { described_class.new(:name, required: true) }
+
+    it { should be(false) }
+  end
+
+  context 'with required: false option passed to constructor' do
+    let(:object) { described_class.new(:name, required: false) }
+
+    it { should be(true) }
+  end
+end

data/spec/unit/axiom/attribute/rename_spec.rb

@@ -5,13 +5,17 @@ require 'spec_helper'
 describe Attribute, '#rename' do
   subject { object.rename(name) }
 
-  let(:described_class) { Class.new(Attribute)                           }
-  let(:object)          { described_class.new(:name, :required => false) }
+  let(:described_class) { Class.new(Attribute)                        }
+  let(:object)          { described_class.new(:name, required: false) }
+
+  before do
+    described_class.stub(type: Types::Object)
+  end
 
   context 'when the new name is the same' do
     let(:name) { object.name }
 
-    it { should equal(object) }
+    it { should be(object) }
   end
 
   context 'when the new name is different' do
@@ -19,9 +23,9 @@ describe Attribute, '#rename' do
 
     it { should be_instance_of(described_class) }
 
-    it { should_not equal(object) }
+    it { should_not be(object) }
 
-    its(:name) { should equal(name) }
+    its(:name) { should be(name) }
 
     its(:required?) { should be(false) }
   end

data/spec/unit/axiom/attribute/required_predicate_spec.rb

@@ -7,20 +7,24 @@ describe Attribute, '#required?' do
 
   let(:described_class) { Class.new(Attribute) }
 
+  before do
+    described_class.stub(type: Types::Object)
+  end
+
   context 'without :required option passed to constructor' do
     let(:object) { described_class.new(:name) }
 
     it { should be(true) }
   end
 
-  context 'with :required => true option passed to constructor' do
-    let(:object) { described_class.new(:name, :required => true) }
+  context 'with required: true option passed to constructor' do
+    let(:object) { described_class.new(:name, required: true) }
 
     it { should be(true) }
   end
 
-  context 'with :required => false option passed to constructor' do
-    let(:object) { described_class.new(:name, :required => false) }
+  context 'with required: false option passed to constructor' do
+    let(:object) { described_class.new(:name, required: false) }
 
     it { should be(false) }
   end

data/spec/unit/axiom/attribute/string/class_methods/type_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Attribute::String, '.type' do
+  subject { object.type }
+
+  let(:object) { described_class }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be(Types::String) }
+end

data/spec/unit/axiom/attribute/string/eql_spec.rb

@@ -50,7 +50,7 @@ describe Attribute::String, '#eql?' do
   end
 
   context 'with an object having a different required option' do
-    let(:other) { described_class.new(name, :required => false) }
+    let(:other) { described_class.new(name, required: false) }
 
     it { should be(false) }
 
@@ -59,8 +59,8 @@ describe Attribute::String, '#eql?' do
     end
   end
 
-  context 'with an object having a different min_length' do
-    let(:other) { described_class.new(name, :min_length => 1) }
+  context 'with an object having a different minimum_length' do
+    let(:other) { described_class.new(name, minimum_length: 1) }
 
     it { should be(false) }
 
@@ -69,8 +69,8 @@ describe Attribute::String, '#eql?' do
     end
   end
 
-  context 'with an object having a different max_length' do
-    let(:other) { described_class.new(name, :max_length => 100) }
+  context 'with an object having a different maximum_length' do
+    let(:other) { described_class.new(name, maximum_length: 100) }
 
     it { should be(false) }
 

data/spec/unit/axiom/attribute/string/equality_operator_spec.rb

@@ -50,7 +50,7 @@ describe Attribute::String, '#==' do
   end
 
   context 'with an object having a different required option' do
-    let(:other) { described_class.new(name, :required => false) }
+    let(:other) { described_class.new(name, required: false) }
 
     it { should be(false) }
 
@@ -59,8 +59,8 @@ describe Attribute::String, '#==' do
     end
   end
 
-  context 'with an object having a different min_length' do
-    let(:other) { described_class.new(name, :min_length => 1) }
+  context 'with an object having a different minimum_length' do
+    let(:other) { described_class.new(name, minimum_length: 1) }
 
     it { should be(false) }
 
@@ -69,8 +69,8 @@ describe Attribute::String, '#==' do
     end
   end
 
-  context 'with an object having a different max_length' do
-    let(:other) { described_class.new(name, :max_length => 100) }
+  context 'with an object having a different maximum_length' do
+    let(:other) { described_class.new(name, maximum_length: 100) }
 
     it { should be(false) }
 

data/spec/unit/axiom/attribute/string/hash_spec.rb

@@ -5,21 +5,21 @@ require 'spec_helper'
 describe Attribute::String, '#hash' do
   subject { object.hash }
 
-  let(:object)     { described_class.new(name, options) }
-  let(:name)       { :name                              }
-  let(:required)   { true                               }
-  let(:min_length) { 0                                  }
-  let(:max_length) { 50                                 }
+  let(:object)         { described_class.new(name, options) }
+  let(:name)           { :name                              }
+  let(:required)       { true                               }
+  let(:minimum_length) { 0                                  }
+  let(:maximum_length) { 50                                 }
 
   let(:options) do
     {
-      :required   => required,
-      :min_length => min_length,
-      :max_length => max_length,
+      required:       required,
+      minimum_length: minimum_length,
+      maximum_length: maximum_length,
     }
   end
 
   it_should_behave_like 'a hash method'
 
-  it { should == described_class.hash ^ name.hash ^ required.hash ^ min_length.hash ^ max_length.hash }
+  it { should == described_class.hash ^ name.hash ^ object.type.hash ^ required.hash }
 end