schematic 0.6.2 → 0.7.0

data/spec/schematic/generator/restrictions/length_spec.rb

@@ -1,30 +1,31 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe Schematic::Generator::Restrictions::Length do
+describe "Schematic::Generator::Restrictions::Length" do
   describe ".to_xsd" do
     context "with a model with range length validations" do
       subject { sanitize_xml(LengthModelRange.to_xsd) }
       with_model :length_model_range do
         table :id => false do |t|
-          t.string "title"
+          t.string 'title'
         end
 
         model do
+          self.primary_key = :title
           validates :title, :length => { :within => 10..20 }
         end
       end
 
       it "should validate against it's own XSD" do
-        invalid_instance = LengthModelRange.new(:title => "A" * 9)
+        invalid_instance = LengthModelRange.new(:title => 'A' * 9)
         xml = [invalid_instance].to_xml
-        lambda {
+        expect {
           validate_xml_against_xsd(xml, subject)
-        }.should raise_error
-        invalid_instance = LengthModelRange.new(:title => "A" * 21)
+        }.to raise_error
+        invalid_instance = LengthModelRange.new(:title => 'A' * 21)
         xml = [invalid_instance].to_xml
-        lambda {
+        expect {
           validate_xml_against_xsd(xml, subject)
-        }.should raise_error
+        }.to raise_error
       end
     end
 
@@ -36,21 +37,22 @@ describe Schematic::Generator::Restrictions::Length do
         end
 
         model do
+          self.primary_key = :title
           validates :title, :length => { :in => 10..20 }
         end
       end
 
       it "should validate against it's own XSD" do
-        invalid_instance = LengthModelRange.new(:title => "A" * 9)
+        invalid_instance = LengthModelRange.new(:title => 'A' * 9)
         xml = [invalid_instance].to_xml
-        lambda {
+        expect {
           validate_xml_against_xsd(xml, subject)
-        }.should raise_error
-        invalid_instance = LengthModelRange.new(:title => "A" * 21)
+        }.to raise_error
+        invalid_instance = LengthModelRange.new(:title => 'A' * 21)
         xml = [invalid_instance].to_xml
-        lambda {
+        expect {
           validate_xml_against_xsd(xml, subject)
-        }.should raise_error
+        }.to raise_error
       end
     end
 
@@ -58,20 +60,21 @@ describe Schematic::Generator::Restrictions::Length do
       subject { sanitize_xml(LengthModelMinimum.to_xsd) }
       with_model :length_model_minimum do
         table :id => false do |t|
-          t.string "title"
+          t.string 'title'
         end
 
         model do
+          self.primary_key = :title
           validates :title, :length => { :minimum => 10 }
         end
       end
 
       it "should validate against it's own XSD" do
-        invalid_instance = LengthModelMinimum.new(:title => "A" * 9)
+        invalid_instance = LengthModelMinimum.new(:title => 'A' * 9)
         xml = [invalid_instance].to_xml
-        lambda {
+        expect {
           validate_xml_against_xsd(xml, subject)
-        }.should raise_error
+        }.to raise_error
       end
     end
 
@@ -80,20 +83,21 @@ describe Schematic::Generator::Restrictions::Length do
       context "when allow blank is true" do
         with_model :length_model_one do
           table :id => false do |t|
-            t.string "title"
+            t.string 'title'
           end
 
           model do
+            self.primary_key = :title
             validates :title, :length => { :maximum => 100 }, :allow_blank => true
           end
         end
 
         it "should validate against it's own XSD" do
-          invalid_instance = LengthModelOne.new(:title => "A" * 201)
+          invalid_instance = LengthModelOne.new(:title => 'A' * 201)
           xml = [invalid_instance].to_xml
-          lambda {
+          expect {
             validate_xml_against_xsd(xml, subject)
-          }.should raise_error
+          }.to raise_error
         end
 
         it "should mark that the field minimum occurrences is 0 but still list the length" do
@@ -111,7 +115,7 @@ describe Schematic::Generator::Restrictions::Length do
             XML
           end
 
-          subject.should == xsd
+          expect(subject).to eq(xsd)
         end
       end
 
@@ -119,11 +123,12 @@ describe Schematic::Generator::Restrictions::Length do
         subject { sanitize_xml(LengthModelTwo.to_xsd) }
         with_model :length_model_two do
           table :id => false do |t|
-            t.string "title"
+            t.string 'title'
           end
 
           model do
-            validates :title, :length => { :maximum => 100 }, :allow_blank => false
+            self.primary_key = :title
+            validates :title, :length => { :maximum => 100 }
           end
         end
 
@@ -142,7 +147,7 @@ describe Schematic::Generator::Restrictions::Length do
             XML
           end
 
-          subject.should == xsd
+          expect(subject).to eq(xsd)
         end
       end
 
@@ -150,10 +155,11 @@ describe Schematic::Generator::Restrictions::Length do
         subject { sanitize_xml(LengthModelThree.to_xsd) }
         with_model :length_model_three do
           table :id => false do |t|
-            t.string "title"
+            t.string 'title'
           end
 
           model do
+            self.primary_key = :title
             validates :title, :length => { :maximum => 100 }, :if => lambda { |model| false }
           end
         end
@@ -172,10 +178,9 @@ describe Schematic::Generator::Restrictions::Length do
             XML
           end
 
-          subject.should == xsd
+          expect(subject).to eq(xsd)
         end
       end
     end
   end
 end
-

data/spec/schematic/generator/restrictions/mixin_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe "Schematic::Generator::Restrictions::Mixin" do
   describe ".to_xsd" do
@@ -7,7 +7,7 @@ describe "Schematic::Generator::Restrictions::Mixin" do
         class MixedInRestriction < Schematic::Generator::Restrictions::Base
           def generate(builder)
             for_validator ActiveModel::BlockValidator do |validator|
-              builder.xs(:enumeration, "value" => "cheese")
+              builder.xs(:enumeration, 'value' => 'cheese')
             end
           end
         end
@@ -16,26 +16,27 @@ describe "Schematic::Generator::Restrictions::Mixin" do
       subject { sanitize_xml(TestModel.to_xsd) }
       with_model :test_model do
         table :id => false do |t|
-          t.string "title"
+          t.string 'title'
         end
 
         model do
+          self.primary_key = :title
           validates_each :title do |object, attr, value|
           end
         end
       end
 
       it "should validate against it's own XSD" do
-        invalid_instance = TestModel.new(:title => "cake")
+        invalid_instance = TestModel.new(:title => 'cake')
         xml = [invalid_instance].to_xml
-        lambda {
+        expect {
           validate_xml_against_xsd(xml, subject)
-        }.should raise_error
-        valid_instance = TestModel.new(:title => "cheese")
+        }.to raise_error
+        valid_instance = TestModel.new(:title => 'cheese')
         xml = [valid_instance].to_xml
-        lambda {
+        expect {
           validate_xml_against_xsd(xml, subject)
-        }.should_not raise_error
+        }.not_to raise_error
       end
 
       it "should mark that the field with the allowed values" do
@@ -53,13 +54,8 @@ describe "Schematic::Generator::Restrictions::Mixin" do
           XML
         end
 
-        subject.should == xsd
+        expect(subject).to eq(xsd)
       end
     end
   end
 end
-
-
-
-
-

data/spec/schematic/generator/restrictions/numericality_spec.rb

@@ -1,30 +1,31 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe Schematic::Generator::Restrictions::Numericality do
+describe "Schematic::Generator::Restrictions::Numericality" do
   describe ".to_xsd" do
     context "with a model with numericality validations" do
       subject { sanitize_xml(TestModel.to_xsd) }
       with_model :test_model do
         table :id => false do |t|
-          t.string "some_field"
+          t.string 'some_field'
         end
 
         model do
+          self.primary_key = :some_field
           validates :some_field, :numericality => true
         end
       end
 
       it "should validate against it's own XSD" do
-        invalid_instance = TestModel.new(:some_field => "1a2")
+        invalid_instance = TestModel.new(:some_field => '1a2')
         xml = [invalid_instance].to_xml
-        lambda {
+        expect {
           validate_xml_against_xsd(xml, subject)
-        }.should raise_error
-        valid_instance = TestModel.new(:some_field => "123")
+        }.to raise_error
+        valid_instance = TestModel.new(:some_field => '123')
         xml = [valid_instance].to_xml
-        lambda {
+        expect {
           validate_xml_against_xsd(xml, subject)
-        }.should_not raise_error
+        }.not_to raise_error
       end
 
       it "should mark that the field with the allowed values" do
@@ -42,9 +43,8 @@ describe Schematic::Generator::Restrictions::Numericality do
           XML
         end
 
-        subject.should == xsd
+        expect(subject).to eq(xsd)
       end
     end
   end
 end
-

data/spec/schematic/generator/restrictions/pattern_spec.rb

@@ -1,6 +1,6 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe Schematic::Generator::Restrictions::Pattern do
+describe "Schematic::Generator::Restrictions::Pattern" do
   describe ".to_xsd" do
     context "with a model with format validations" do
       subject { sanitize_xml(PatternModel.to_xsd) }
@@ -10,21 +10,22 @@ describe Schematic::Generator::Restrictions::Pattern do
         end
 
         model do
+          self.primary_key = :title
           validates :title, :format => { :with => /[a-z]#[0-9]/ }
         end
       end
 
       it "should validate against it's own XSD" do
-        invalid_instance = PatternModel.new(:title => "1-2")
+        invalid_instance = PatternModel.new(:title => '1-2')
         xml = [invalid_instance].to_xml
-        lambda {
+        expect {
           validate_xml_against_xsd(xml, subject)
-        }.should raise_error
-        valid_instance = PatternModel.new(:title => "a#5")
+        }.to raise_error
+        valid_instance = PatternModel.new(:title => 'a#5')
         xml = [valid_instance].to_xml
-        lambda {
+        expect {
           validate_xml_against_xsd(xml, subject)
-        }.should_not raise_error
+        }.not_to raise_error
       end
 
       it "should mark that the field with the allowed values" do
@@ -42,7 +43,7 @@ describe Schematic::Generator::Restrictions::Pattern do
           XML
         end
 
-        subject.should == xsd
+        expect(subject).to eq(xsd)
       end
     end
 
@@ -55,31 +56,29 @@ describe Schematic::Generator::Restrictions::Pattern do
         end
 
         model do
+          self.primary_key = :email
           validates :email, :format => { :with => /\A([\w\.%\+\-`']+)@([\w\-]+\.)+([\w]{2,})\Z/ }
           validates :money, :format => { :with =>  /\$?[,0-9]+(?:\.\d+)?/ }
         end
       end
 
       it "should validate against it's own XSD" do
-        invalid_instance = PatternModel.new(:email => "@blah")
+        invalid_instance = PatternModel.new(:email => '@blah')
         xml = [invalid_instance].to_xml
-        lambda {
+        expect {
           validate_xml_against_xsd(xml, subject)
-        }.should raise_error
-        invalid_instance = PatternModel.new(:money => "whatever")
+        }.to raise_error
+        invalid_instance = PatternModel.new(:money => 'whatever')
         xml = [invalid_instance].to_xml
-        lambda {
+        expect {
           validate_xml_against_xsd(xml, subject)
-        }.should raise_error
-        valid_instance = PatternModel.new(:email => "foo@bar.com", :money => "$99.95")
+        }.to raise_error
+        valid_instance = PatternModel.new(:email => 'foo@bar.com', :money => '$99.95')
         xml = [valid_instance].to_xml
-        lambda {
+        expect {
           validate_xml_against_xsd(xml, subject)
-        }.should_not raise_error
+        }.not_to raise_error
       end
     end
   end
 end
-
-
-

data/spec/schematic/generator/sandbox_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Schematic::Generator::Sandbox do
   subject { Schematic::Generator::Sandbox.new(klass) }
@@ -10,15 +10,15 @@ describe Schematic::Generator::Sandbox do
         subject.run do
           ignore :foo
         end
-        subject.ignored_elements.should include(:foo)
+        expect(subject.ignored_elements).to include(:foo)
       end
 
       it "accepts multiple fields" do
         subject.run do
           ignore :foo, :bar
         end
-        subject.ignored_elements.should include(:foo)
-        subject.ignored_elements.should include(:bar)
+        expect(subject.ignored_elements).to include(:foo)
+        expect(subject.ignored_elements).to include(:bar)
       end
     end
 
@@ -27,7 +27,7 @@ describe Schematic::Generator::Sandbox do
         subject.run do
           ignore :foo => [:bar]
         end
-        subject.ignored_elements[:foo].should == [:bar]
+        expect(subject.ignored_elements[:foo]).to eq([:bar])
       end
     end
   end
@@ -38,7 +38,7 @@ describe Schematic::Generator::Sandbox do
         subject.run do
           add :foo
         end
-        subject.added_elements.keys.should include(:foo)
+        expect(subject.added_elements.keys).to include(:foo)
       end
     end
 
@@ -47,7 +47,7 @@ describe Schematic::Generator::Sandbox do
         subject.run do
           add :foo => { :bar => nil }
         end
-        subject.added_elements[:foo].should == { :bar => nil }
+        expect(subject.added_elements[:foo]).to eq({ :bar => nil })
       end
     end
 
@@ -56,7 +56,7 @@ describe Schematic::Generator::Sandbox do
         subject.run do
           add :foo => [:bar]
         end
-        subject.added_elements[:foo].should == [:bar]
+        expect(subject.added_elements[:foo]).to eq([:bar])
       end
     end
   end
@@ -66,15 +66,15 @@ describe Schematic::Generator::Sandbox do
       subject.run do
         required :foo
       end
-      subject.required_elements.should include(:foo)
+      expect(subject.required_elements).to include(:foo)
     end
 
     it "accepts multiple fields" do
       subject.run do
         required :foo, :bar
       end
-      subject.required_elements.should include(:foo)
-      subject.required_elements.should include(:bar)
+      expect(subject.required_elements).to include(:foo)
+      expect(subject.required_elements).to include(:bar)
     end
   end
 
@@ -83,26 +83,26 @@ describe Schematic::Generator::Sandbox do
       subject.run do
         not_required :foo
       end
-      subject.non_required_elements.should include(:foo)
+      expect(subject.non_required_elements).to include(:foo)
     end
 
     it "accepts multiple fields" do
       subject.run do
         not_required :foo, :bar
       end
-      subject.non_required_elements.should include(:foo)
-      subject.non_required_elements.should include(:bar)
+      expect(subject.non_required_elements).to include(:foo)
+      expect(subject.non_required_elements).to include(:bar)
     end
   end
 
   describe "setting the root" do
     it "should change the root element name" do
       subject.run do
-        root "my_new_root"
+        root 'my_new_root'
       end
 
-      subject.xsd_generator.names.element.should == "my-new-root"
-      subject.xsd_generator.names.element_collection.should == "my-new-roots"
+      expect(subject.xsd_generator.names.element).to eq('my-new-root')
+      expect(subject.xsd_generator.names.element_collection).to eq('my-new-roots')
     end
   end
 end