schematic 0.0.4 → 0.0.5

data/lib/schematic/serializers/xsd.rb

@@ -7,75 +7,125 @@ module Schematic
         end
       end
 
-      def to_xsd(options = {}, builder = nil)
-        if builder.nil?
-          output = ""
-          builder = Builder::XmlMarkup.new(:target => output)
-          builder.instruct!
-          builder.xs :schema, "xmlns:xs" => "http://www.w3.org/2001/XMLSchema" do |schema|
-            schema.xs :element, "name" => xsd_element_collection_name, "type" => xsd_type_collection_name
-            self.to_xsd(options, schema)
-          end
-          output
-        else
-          xsd_nested_attributes.each do |nested_attribute|
-            nested_attribute.klass.to_xsd(options, builder)
+      def to_xsd(options = {})
+        output = ""
+        builder = Builder::XmlMarkup.new(:target => output)
+        builder.instruct!
+        builder.xs :schema, "xmlns:xs" => "http://www.w3.org/2001/XMLSchema" do |schema|
+          schema.xs :element, "name" => xsd_element_collection_name, "type" => xsd_type_collection_name
+          generate_xsd(options, schema, self)
+        end
+        output
+      end
+
+      def map_column_type_to_xsd_type(column)
+        {
+          :integer => "xs:integer",
+          :float => "xs:float",
+          :string => "xs:string",
+          :text => "xs:string",
+          :datetime => "xs:dateTime",
+          :date => "xs:date",
+          :boolean => "xs:boolean"
+        }[column.type]
+      end
+
+      def xsd_minimum_occurrences_for_column(column)
+        self._validators[column.name.to_sym].each do |column_validation|
+          next unless column_validation.is_a?  ActiveModel::Validations::PresenceValidator
+          return "1" if column_validation.options[:allow_blank] != true && column_validation.options[:if].nil?
+        end
+        "0"
+      end
+
+      def xsd_element_collection_name
+        xsd_element_name.pluralize
+      end
+
+      def xsd_type_collection_name
+        xsd_type_name.pluralize
+      end
+
+      def xsd_type_name
+        self.name.demodulize
+      end
+
+      def xsd_element_name
+        xsd_type_name.underscore.dasherize
+      end
+
+      def generate_xsd(options, builder, klass)
+        xsd_nested_attributes.each do |nested_attribute|
+          next if nested_attribute.klass == klass || nested_attribute.klass == klass.superclass
+
+          nested_attribute.klass.generate_xsd(options, builder, klass)
+        end
+
+        generate_xsd_complex_type_for_collection(builder)
+        generate_xsd_complex_type_for_model(options, builder)
+      end
+
+      private
+
+      def generate_xsd_complex_type_for_collection(builder)
+        builder.xs :complexType, "name" => xsd_type_collection_name do |complex_type|
+          complex_type.xs :sequence do |sequence|
+            sequence.xs :element, "name" => xsd_element_name, "type" => xsd_type_name, "minOccurs" => "0", "maxOccurs" => "unbounded"
           end
-          builder.xs :complexType, "name" => xsd_type_collection_name do |complex_type|
-            complex_type.xs :sequence do |sequence|
-              sequence.xs :element, "name" => xsd_element_name, "type" => xsd_type_name, "minOccurs" => "0", "maxOccurs" => "unbounded"
+          complex_type.xs :attribute, "name" => "type", "type" => "xs:string", "fixed" => "array"
+        end
+      end
+
+      def generate_xsd_complex_type_for_model(options, builder)
+        builder.xs :complexType, "name" => xsd_type_name do |complex_type|
+          additional_methods = xsd_methods.merge(options[:methods] || {})
+          ignored_methods = xsd_ignore_methods | (options[:exclude] || [])
+          complex_type.xs :all do |all|
+            generate_xsd_column_elements(all, additional_methods, ignored_methods)
+
+            xsd_nested_attributes.each do |nested_attribute|
+              all.xs :element, "name" => "#{nested_attribute.name.to_s.dasherize}-attributes", "type" => nested_attribute.klass.xsd_type_collection_name, "minOccurs" => "0", "maxOccurs" => "1"
             end
-            complex_type.xs :attribute, "name" => "type", "type" => "xs:string", "fixed" => "array"
+
+            generate_xsd_additional_methods(all, additional_methods)
           end
-          builder.xs :complexType, "name" => xsd_type_name do |complex_type|
-            additional_methods = xsd_methods.merge(options[:methods] || {})
-            ignored_methods = xsd_ignore_methods | (options[:exclude] || [])
-            complex_type.xs :all do |all|
-              xsd_columns.each do |column|
-                next if additional_methods.keys.map(&:to_s).include?(column.name) || ignored_methods.map(&:to_s).include?(column.name)
-
-                all.xs :element, "name" => column.name.dasherize, "minOccurs" => xsd_minimum_occurrences_for_column(column), "maxOccurs" => "1" do |field|
-                  field.xs :complexType do |complex_type|
-                    complex_type.xs :simpleContent do |simple_content|
-                      simple_content.xs :extension, "base" => map_column_type_to_xsd_type(column) do |extension|
-                        extension.xs :attribute, "name" => "type", "type" => "xs:string", "use" => "optional"
-                      end
-                    end
-                  end
-                end
-              end
-              xsd_nested_attributes.each do |nested_attribute|
-                all.xs :element, "name" => "#{nested_attribute.name.to_s.dasherize}-attributes", "type" => nested_attribute.klass.xsd_type_collection_name, "minOccurs" => "0", "maxOccurs" => "1"
-              end
-              additional_methods.each do |method_name, values|
-                method_xsd_name = method_name.to_s.dasherize
-                if values.present?
-                  all.xs :element, "name" => method_xsd_name, "minOccurs" => "0", "maxOccurs" => "1" do |element|
-                    element.xs :complexType do |complex_type|
-                      complex_type.xs :all do |nested_all|
-                        values.each do |value|
-                          nested_all.xs :element, "name" => value.to_s.dasherize, "minOccurs" => "0"
-                        end
-                      end
-                      complex_type.xs :attribute, "name" => "type", "type" => "xs:string", "fixed" => "array", "use" => "optional"
-                    end
-                  end
-                else
-                  all.xs :element, "name" => method_xsd_name, "minOccurs" => "0", "maxOccurs" => "1"
+        end
+      end
+
+      def generate_xsd_column_elements(builder, additional_methods, ignored_methods)
+        xsd_columns.each do |column|
+          next if additional_methods.keys.map(&:to_s).include?(column.name) || ignored_methods.map(&:to_s).include?(column.name)
+
+          builder.xs :element, "name" => column.name.dasherize, "minOccurs" => xsd_minimum_occurrences_for_column(column), "maxOccurs" => "1" do |field|
+            field.xs :complexType do |complex_type|
+              complex_type.xs :simpleContent do |simple_content|
+                simple_content.xs :extension, "base" => map_column_type_to_xsd_type(column) do |extension|
+                  extension.xs :attribute, "name" => "type", "type" => "xs:string", "use" => "optional"
                 end
               end
             end
           end
-          builder
         end
       end
 
-      def xsd_minimum_occurrences_for_column(column)
-        self._validators[column.name.to_sym].each do |column_validation|
-          next unless column_validation.is_a?  ActiveModel::Validations::PresenceValidator
-          return "1" if column_validation.options[:allow_blank] != true
+      def generate_xsd_additional_methods(builder, additional_methods)
+        additional_methods.each do |method_name, values|
+          method_xsd_name = method_name.to_s.dasherize
+          if values.present?
+            builder.xs :element, "name" => method_xsd_name, "minOccurs" => "0", "maxOccurs" => "1" do |element|
+              element.xs :complexType do |complex_type|
+                complex_type.xs :all do |nested_all|
+                  values.each do |value|
+                    nested_all.xs :element, "name" => value.to_s.dasherize, "minOccurs" => "0"
+                  end
+                end
+                complex_type.xs :attribute, "name" => "type", "type" => "xs:string", "fixed" => "array", "use" => "optional"
+              end
+            end
+          else
+            builder.xs :element, "name" => method_xsd_name, "minOccurs" => "0", "maxOccurs" => "1"
+          end
         end
-        "0"
       end
 
       def xsd_methods
@@ -96,33 +146,7 @@ module Schematic
         self.columns
       end
 
-      def map_column_type_to_xsd_type(column)
-        {
-          :integer => "xs:integer",
-          :float => "xs:float",
-          :string => "xs:string",
-          :text => "xs:string",
-          :datetime => "xs:dateTime",
-          :date => "xs:date",
-          :boolean => "xs:boolean"
-        }[column.type]
-      end
-
-      def xsd_type_name
-        self.name.demodulize
-      end
 
-      def xsd_type_collection_name
-        xsd_type_name.pluralize
-      end
-
-      def xsd_element_name
-        xsd_type_name.underscore.dasherize
-      end
-
-      def xsd_element_collection_name
-        xsd_element_name.pluralize
-      end
     end
   end
 end

data/lib/schematic/version.rb

@@ -1,3 +1,3 @@
 module Schematic
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/spec/schematic_serializers_xsd_spec.rb

@@ -59,13 +59,7 @@ describe Schematic::Serializers::Xsd do
 
         end
         it "should generate a valid XSD" do
-          xsd_schema_file = File.join(File.dirname(__FILE__), "xsd", "XMLSchema.xsd")
-          meta_xsd = Nokogiri::XML::Schema(File.open(xsd_schema_file))
-
-          doc = Nokogiri::XML.parse(subject)
-          meta_xsd.validate(doc).each do |error|
-            error.message.should be_nil
-          end
+          validate_xsd(subject)
         end
       end
 
@@ -93,14 +87,69 @@ describe Schematic::Serializers::Xsd do
         end
 
         it "should generate a valid XSD" do
-          xsd_schema_file = File.join(File.dirname(__FILE__), "xsd", "XMLSchema.xsd")
-          meta_xsd = Nokogiri::XML::Schema(File.open(xsd_schema_file))
+          validate_xsd(subject)
+        end
+      end
+
+      context "when the model has a nested attribute on a subclass with a reference to the superclass" do
+        with_model :parent do
+          table {}
+          model do
+            has_many :children
+            accepts_nested_attributes_for :children
+          end
+        end
+
+        with_model :child do
+          table do |t|
+            t.integer :parent_id
+          end
+
+          model do
+            belongs_to :parent
+          end
+        end
+
+        before do
+          module Namespace; end
+          class Namespace::Child < Child
+            accepts_nested_attributes_for :parent
+          end
+        end
+
+        subject { Namespace::Child.to_xsd }
+
+        it "should generate a valid XSD" do
+          validate_xsd(subject)
+        end
+      end
+
+      context "when the model has a circular nested attribute reference" do
+        with_model :blog do
+          table {}
+          model do
+            has_many :posts
+            accepts_nested_attributes_for :posts
+          end
+        end
 
-          doc = Nokogiri::XML.parse(subject)
-          meta_xsd.validate(doc).each do |error|
-            error.message.should be_nil
+        with_model :post do
+          table do |t|
+            t.integer :blog_id
           end
+
+          model do
+            belongs_to :blog
+            accepts_nested_attributes_for :blog
+          end
+        end
+
+        subject { Post.to_xsd }
+
+        it "should generate a valid XSD" do
+          validate_xsd(subject)
         end
+
       end
     end
 
@@ -255,6 +304,36 @@ describe Schematic::Serializers::Xsd do
             subject.should == sanitize_xml(xsd)
           end
         end
+
+        context "when there is a condition" do
+          with_model :some_model do
+            table :id => false do |t|
+              t.string "title"
+            end
+
+            model do
+              validates :title, :presence => true, :if => lambda { |model| false }
+            end
+          end
+
+          it "should mark that the field minimum occurrences is 0" do
+            xsd = generate_xsd_for_model(SomeModel) do
+              <<-XML
+              <xs:element name="title" minOccurs="0" maxOccurs="1">
+                <xs:complexType>
+                  <xs:simpleContent>
+                    <xs:extension base="xs:string">
+                      <xs:attribute name="type" type="xs:string" use="optional"/>
+                    </xs:extension>
+                  </xs:simpleContent>
+                </xs:complexType>
+              </xs:element>
+              XML
+            end
+
+            subject.should == sanitize_xml(xsd)
+          end
+        end
       end
 
       describe "length validation" do
@@ -368,6 +447,16 @@ describe Schematic::Serializers::Xsd do
 
   private
 
+  def validate_xsd(xml)
+    xsd_schema_file = File.join(File.dirname(__FILE__), "xsd", "XMLSchema.xsd")
+    meta_xsd = Nokogiri::XML::Schema(File.open(xsd_schema_file))
+
+    doc = Nokogiri::XML.parse(xml)
+    meta_xsd.validate(doc).each do |error|
+      error.message.should be_nil
+    end
+  end
+
   def sanitize_xml(xml)
     xml.split("\n").map(&:strip).join("")
   end

metadata

@@ -2,7 +2,7 @@
 name: schematic
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors: 
 - Case Commons, LLC