schematic 0.1.9 → 0.2.1

data/lib/schematic/generator/column.rb

@@ -19,6 +19,7 @@ module Schematic
                 Restrictions::Length.new(@klass, @column).generate(restriction)
                 Restrictions::Enumeration.new(@klass, @column).generate(restriction)
                 Restrictions::Pattern.new(@klass, @column).generate(restriction)
+                Restrictions::Numericality.new(@klass, @column).generate(restriction)
                 Restrictions::Custom.new(@klass, @column).generate(restriction)
               end
             end

data/lib/schematic/generator/restrictions/base.rb

@@ -10,7 +10,7 @@ module Schematic
         def for_validator(validator_klass)
           validators_for_column.each do |column_validation|
             next unless column_validation.is_a? validator_klass
-            next unless column_validation.options[:if].nil?
+            next unless column_validation.options[:if].nil? || column_validation.options[:unless].nil?
             yield(column_validation)
             return
           end

data/lib/schematic/generator/restrictions/numericality.rb

@@ -0,0 +1,13 @@
+module Schematic
+  module Generator
+    module Restrictions
+      class Numericality < Base
+        def generate(builder)
+          for_validator ActiveModel::Validations::NumericalityValidator do |validator|
+            builder.xs(:pattern, "value" => "\\d+")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schematic/generator/restrictions/uniqueness.rb

@@ -0,0 +1,26 @@
+module Schematic
+  module Generator
+    module Restrictions
+      class Uniqueness < Base
+        def generate(builder)
+          for_validator ActiveRecord::Validations::UniquenessValidator do |validator|
+            unique_name = validator.attributes.first.to_s.dasherize
+            additional_fields = (validator.options[:scope] || []).map(&:to_s).map(&:dasherize)
+
+            names = Schematic::Generator::Names.new(@klass)
+            builder.xs :unique, "name" => "#{unique_name}-must-be-unique" do |unique|
+              unique.xs :selector, "xpath" => "./#{names.element}"
+              unique.xs :field, "xpath" => unique_name
+              additional_fields.each do |additional_field|
+                unique.xs :field, "xpath" => additional_field
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+
+

data/lib/schematic/generator/xsd.rb

@@ -23,7 +23,9 @@ module Schematic
       end
 
       def element_for_klass(builder)
-        builder.xs :element, "name" => @names.element_collection, "type" => @names.collection_type
+        builder.xs :element, "name" => @names.element_collection, "type" => @names.collection_type do |element|
+          generate_uniqueness_constraints(element)
+        end
       end
 
       def generate(builder, klass)
@@ -68,6 +70,12 @@ module Schematic
         end
       end
 
+      def generate_uniqueness_constraints(builder)
+        @klass.columns.each do |column|
+           Restrictions::Uniqueness.new(@klass, column).generate(builder)
+        end
+      end
+
       def generate_additional_methods(builder, additional_methods)
         additional_methods.each do |method_name, values|
           method_xsd_name = method_name.to_s.dasherize

data/lib/schematic/version.rb

@@ -1,3 +1,3 @@
 module Schematic
-  VERSION = "0.1.9"
+  VERSION = "0.2.1"
 end

data/lib/schematic.rb

@@ -17,6 +17,8 @@ module Schematic
       autoload :Enumeration, 'schematic/generator/restrictions/enumeration'
       autoload :Length, 'schematic/generator/restrictions/length'
       autoload :Pattern, 'schematic/generator/restrictions/pattern'
+      autoload :Numericality, 'schematic/generator/restrictions/numericality'
+      autoload :Uniqueness, 'schematic/generator/restrictions/uniqueness'
     end
   end
   module Serializers

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

@@ -165,6 +165,7 @@ describe Schematic::Generator::Restrictions::Length do
                 <xs:complexType>
                   <xs:simpleContent>
                     <xs:restriction base="String">
+                      <xs:maxLength value="100"/>
                     </xs:restriction>
                   </xs:simpleContent>
                 </xs:complexType>

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

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+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"
+        end
+
+        model do
+          validates :some_field, :numericality => true
+        end
+      end
+
+      it "should validate against it's own XSD" do
+        invalid_instance = TestModel.new(:some_field => "1a2")
+        xml = [invalid_instance].to_xml
+        lambda {
+          validate_xml_against_xsd(xml, subject)
+        }.should raise_error
+        valid_instance = TestModel.new(:some_field => "123")
+        xml = [valid_instance].to_xml
+        lambda {
+          validate_xml_against_xsd(xml, subject)
+        }.should_not raise_error
+      end
+
+      it "should mark that the field with the allowed values" do
+        xsd = generate_xsd_for_model(TestModel) do
+          <<-XML
+              <xs:element name="some-field" minOccurs="0" maxOccurs="1">
+                <xs:complexType>
+                  <xs:simpleContent>
+                    <xs:restriction base="String">
+                      <xs:pattern value="\\d+"/>
+                    </xs:restriction>
+                  </xs:simpleContent>
+                </xs:complexType>
+              </xs:element>
+          XML
+        end
+
+        subject.should == xsd
+      end
+    end
+  end
+end
+

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

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe Schematic::Generator::Restrictions::Enumeration 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) }

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

@@ -0,0 +1,123 @@
+require "spec_helper"
+
+describe Schematic::Generator::Restrictions::Uniqueness do
+  describe ".to_xsd" do
+    context "with a model with a uniqueness validation" do
+      subject { sanitize_xml(TestModel.to_xsd) }
+      with_model :test_model do
+        table :id => false do |t|
+          t.string "some_field"
+        end
+
+        model do
+          validates :some_field, :uniqueness => true
+        end
+      end
+
+      it "should validate against it's own XSD" do
+        first_instance = TestModel.new(:some_field => "first")
+        another_instance = TestModel.new(:some_field => "second")
+        duplicate_instance = TestModel.new(:some_field => "first")
+        xml = [first_instance, duplicate_instance, another_instance].to_xml
+        lambda {
+          validate_xml_against_xsd(xml, subject)
+        }.should raise_error
+        xml = [first_instance, another_instance].to_xml
+        lambda {
+          validate_xml_against_xsd(xml, subject)
+        }.should_not raise_error
+      end
+
+      it "should mark that the field with the allowed values" do
+        header_element = <<-XML
+          <xs:unique name="some-field-must-be-unique">
+            <xs:selector xpath="./test-model"/>
+            <xs:field xpath="some-field"/>
+          </xs:unique>
+        XML
+        xsd = generate_xsd_for_model(TestModel, header_element) do
+          <<-XML
+            <xs:element name="some-field" minOccurs="0" maxOccurs="1">
+              <xs:complexType>
+                <xs:simpleContent>
+                  <xs:restriction base="String">
+                  </xs:restriction>
+                </xs:simpleContent>
+              </xs:complexType>
+            </xs:element>
+          XML
+        end
+
+        subject.should == xsd
+      end
+    end
+
+    context "for a model with a column with uniqueness with scope" do
+      subject { sanitize_xml(TestModel.to_xsd) }
+      with_model :test_model do
+        table :id => false do |t|
+          t.string "some_field"
+          t.string "other_field"
+        end
+
+        model do
+          validates :some_field, :uniqueness => { :scope => [:other_field] }
+        end
+      end
+
+      it "should validate against it's own XSD" do
+        first_instance = TestModel.new(:some_field => "first", :other_field => "unique")
+        another_instance = TestModel.new(:some_field => "first", :other_field => "alsounique")
+        duplicate_instance = TestModel.new(:some_field => "first", :other_field => "unique")
+        xml = [first_instance, duplicate_instance, another_instance].to_xml
+        lambda {
+          validate_xml_against_xsd(xml, subject)
+        }.should raise_error
+        xml = [first_instance, another_instance].to_xml
+        lambda {
+          validate_xml_against_xsd(xml, subject)
+        }.should_not raise_error
+      end
+    end
+
+    context "for a model with mutiple columns seperately having uniqueness" do
+      subject { sanitize_xml(TestModel.to_xsd) }
+      with_model :test_model do
+        table :id => false do |t|
+          t.string "some_field"
+          t.string "other_field"
+        end
+
+        model do
+          validates :some_field, :uniqueness => true
+          validates :other_field, :uniqueness => true
+        end
+      end
+
+      it "should validate against it's own XSD" do
+        first_instance = TestModel.new(:some_field => "first", :other_field => "unique")
+        another_instance = TestModel.new(:some_field => "another", :other_field => "alsounique")
+        duplicate_instance = TestModel.new(:some_field => "first", :other_field => "duplicate")
+        other_duplicate_instance = TestModel.new(:some_field => "fourth", :other_field => "unique")
+
+        xml = [first_instance, duplicate_instance, another_instance].to_xml
+        lambda {
+          validate_xml_against_xsd(xml, subject)
+        }.should raise_error
+
+        xml = [first_instance, other_duplicate_instance, another_instance].to_xml
+        lambda {
+          validate_xml_against_xsd(xml, subject)
+        }.should raise_error
+
+        xml = [first_instance, another_instance].to_xml
+        lambda {
+          validate_xml_against_xsd(xml, subject)
+        }.should_not raise_error
+      end
+    end
+
+  end
+end
+
+

data/spec/schematic_serializers_xsd_spec.rb

@@ -212,7 +212,8 @@ describe Schematic::Serializers::Xsd do
             </xs:extension>
             </xs:simpleContent>
             </xs:complexType>
-            <xs:element name="empty-models" type="EmptyModels"/>
+            <xs:element name="empty-models" type="EmptyModels">
+            </xs:element>
             <xs:complexType name="EmptyModels">
               <xs:sequence>
                 <xs:element name="empty-model" type="EmptyModel" minOccurs="0" maxOccurs="unbounded"/>

data/spec/spec_helper.rb

@@ -39,7 +39,7 @@ def sanitize_xml(xml)
   xml.split("\n").reject(&:blank?).map(&:strip).join("\n")
 end
 
-def generate_xsd_for_model(model)
+def generate_xsd_for_model(model, header_element = nil)
   output = <<-XML
 <?xml version="1.0" encoding="UTF-8"?>
 <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
@@ -92,7 +92,9 @@ def generate_xsd_for_model(model)
   </xs:extension>
   </xs:simpleContent>
   </xs:complexType>
-  <xs:element name="#{model.xsd_generator.names.element_collection}" type="#{model.xsd_generator.names.collection_type}"/>
+  <xs:element name="#{model.xsd_generator.names.element_collection}" type="#{model.xsd_generator.names.collection_type}">
+  #{header_element}
+  </xs:element>
   <xs:complexType name="#{model.xsd_generator.names.collection_type}">
     <xs:sequence>
       <xs:element name="#{model.xsd_generator.names.element}" type="#{model.xsd_generator.names.type}" minOccurs="0" maxOccurs="unbounded"/>

metadata

@@ -2,7 +2,7 @@
 name: schematic
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.9
+  version: 0.2.1
 platform: ruby
 authors: 
 - Case Commons, LLC
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-16 00:00:00 Z
+date: 2011-05-25 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -115,7 +115,9 @@ files:
 - lib/schematic/generator/restrictions/custom.rb
 - lib/schematic/generator/restrictions/enumeration.rb
 - lib/schematic/generator/restrictions/length.rb
+- lib/schematic/generator/restrictions/numericality.rb
 - lib/schematic/generator/restrictions/pattern.rb
+- lib/schematic/generator/restrictions/uniqueness.rb
 - lib/schematic/generator/types.rb
 - lib/schematic/generator/xsd.rb
 - lib/schematic/serializers/xsd.rb
@@ -124,7 +126,9 @@ files:
 - spec/schematic/generator/restrictions/custom_spec.rb
 - spec/schematic/generator/restrictions/enumeration_spec.rb
 - spec/schematic/generator/restrictions/length_spec.rb
+- spec/schematic/generator/restrictions/numericality_spec.rb
 - spec/schematic/generator/restrictions/pattern_spec.rb
+- spec/schematic/generator/restrictions/uniqueness_spec.rb
 - spec/schematic/serializers/xsd_extend_spec.rb
 - spec/schematic/serializers/xsd_validation_presence_spec.rb
 - spec/schematic/serializers/xsd_xsd_ignore_methods_spec.rb
@@ -165,7 +169,9 @@ test_files:
 - spec/schematic/generator/restrictions/custom_spec.rb
 - spec/schematic/generator/restrictions/enumeration_spec.rb
 - spec/schematic/generator/restrictions/length_spec.rb
+- spec/schematic/generator/restrictions/numericality_spec.rb
 - spec/schematic/generator/restrictions/pattern_spec.rb
+- spec/schematic/generator/restrictions/uniqueness_spec.rb
 - spec/schematic/serializers/xsd_extend_spec.rb
 - spec/schematic/serializers/xsd_validation_presence_spec.rb
 - spec/schematic/serializers/xsd_xsd_ignore_methods_spec.rb