schematic 0.0.8 → 0.1.2

data/.rspec

@@ -0,0 +1 @@
+--color

data/README.rdoc

@@ -31,7 +31,7 @@ You can include additional elements by defining a ".xsd_methods" on your class:
     end
   end
 
-You can exclude elements bby defining a ".xsd_ignore_methods" on your class:
+You can exclude elements by defining a ".xsd_ignore_methods" on your class:
 
   class Post < ActiveRecord::Base
     def self.xsd_ignore_methods

data/TODO

@@ -0,0 +1,5 @@
+* Support numericality validation as pattern restriction
+* Support exclusion validation as a pattern restriction
+* Support exact length validation with length? or is min/max okay?
+* Support uniqueness constraint on primary keys and uniqness validations using unique or key tag?
+

data/lib/schematic.rb

@@ -10,6 +10,9 @@ require "builder"
 
 require 'active_support/inflector/inflections'
 require 'active_support/inflections'
-require "schematic/serializers/xsd"
+
+Dir[File.join(File.dirname(__FILE__), "schematic/**/*.rb")].each do |file|
+  require file.gsub(/\/.rb$/,'')
+end
 
 ActiveRecord::Base.send(:extend, Schematic::Serializers::Xsd)

data/lib/schematic/generator/column.rb

@@ -0,0 +1,47 @@
+module Schematic
+  module Generator
+    class Column
+
+      def initialize(klass, column, additional_methods = {}, ignored_methods = {})
+        @klass = klass
+        @column = column
+        @additional_methods = additional_methods
+        @ignored_methods = ignored_methods
+      end
+
+      def generate(builder)
+        return if skip_generation?
+
+        builder.xs :element, "name" => @column.name.dasherize, "minOccurs" => minimum_occurrences_for_column, "maxOccurs" => "1" do |field|
+          field.xs :complexType do |complex_type|
+            complex_type.xs :simpleContent do |simple_content|
+              simple_content.xs :restriction, "base" => map_type(@column) do |restriction|
+                Restrictions::Length.new(@klass, @column).generate(restriction)
+                Restrictions::Enumeration.new(@klass, @column).generate(restriction)
+                Restrictions::Pattern.new(@klass, @column).generate(restriction)
+              end
+            end
+          end
+        end
+      end
+
+      def minimum_occurrences_for_column
+        @klass._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 map_type(column)
+        Types::COMPLEX[column.type][:complex_type]
+      end
+
+      def skip_generation?
+        @additional_methods.keys.map(&:to_s).include?(@column.name) ||
+          @ignored_methods.map(&:to_s).include?(@column.name)
+      end
+    end
+  end
+end

data/lib/schematic/generator/names.rb

@@ -0,0 +1,27 @@
+module Schematic
+  module Generator
+    class Names
+
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def type
+        @klass.name.demodulize
+      end
+
+      def element
+        type.underscore.dasherize
+      end
+
+      def element_collection
+        element.pluralize
+      end
+
+      def collection_type
+        type.pluralize
+      end
+
+    end
+  end
+end

data/lib/schematic/generator/namespaces.rb

@@ -0,0 +1,11 @@
+module Schematic
+  module Generator
+    class Namespaces
+      PROVIDERS = {
+        :w3 => {
+          :schema => "http://www.w3.org/2001/XMLSchema"
+        }
+      }
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Schematic
+  module Generator
+    module Restrictions
+      class Base
+        def initialize(klass, column)
+          @klass = klass
+          @column = column
+        end
+
+        def for_validator(validator_klass)
+          @klass._validators[@column.name.to_sym].each do |column_validation|
+            next unless column_validation.is_a? validator_klass
+            next unless column_validation.options[:if].nil?
+            yield(column_validation)
+            return
+          end
+        end
+
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,21 @@
+module Schematic
+  module Generator
+    module Restrictions
+      class Enumeration < Base
+        def initialize(klass, column)
+          @klass = klass
+          @column = column
+        end
+
+        def generate(builder)
+          for_validator ActiveModel::Validations::InclusionValidator do |validator|
+            validator.options[:in].each do |value|
+              builder.xs(:enumeration, "value" => value)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,19 @@
+module Schematic
+  module Generator
+    module Restrictions
+      class Length < Base
+        def initialize(klass, column)
+          @klass = klass
+          @column = column
+        end
+
+        def generate(builder)
+          for_validator ActiveModel::Validations::LengthValidator do |validator|
+            builder.xs(:maxLength, "value" => validator.options[:maximum]) if validator.options[:maximum]
+            builder.xs(:minLength, "value" => validator.options[:minimum]) if validator.options[:minimum]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Schematic
+  module Generator
+    module Restrictions
+      class Pattern < Base
+        def initialize(klass, column)
+          @klass = klass
+          @column = column
+        end
+
+        def generate(builder)
+          for_validator ActiveModel::Validations::FormatValidator do |validator|
+            builder.xs(:pattern, "value" => validator.options[:with].source) if validator.options[:with]
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/schematic/generator/types.rb

@@ -0,0 +1,29 @@
+module Schematic
+  module Generator
+    class Types
+      COMPLEX = {
+        :integer => { :complex_type => "Integer", :xsd_type => "xs:integer" },
+        :float => { :complex_type => "Float", :xsd_type => "xs:float" },
+        :string => { :complex_type => "String", :xsd_type => "xs:string" },
+        :text => { :complex_type => "Text", :xsd_type => "xs:string" },
+        :datetime => { :complex_type => "DateTime", :xsd_type => "xs:dateTime" },
+        :date => { :complex_type => "Date", :xsd_type => "xs:date" },
+        :boolean => { :complex_type => "Boolean", :xsd_type => "xs:boolean" },
+      }
+
+      def self.xsd(builder)
+        Types::COMPLEX.each do |key, value|
+          complex_type_name = value[:complex_type]
+          xsd_type = value[:xsd_type]
+          builder.xs :complexType, "name" => complex_type_name do |complex_type|
+            complex_type.xs :simpleContent do |simple_content|
+              simple_content.xs :extension, "base" => xsd_type do |extension|
+                extension.xs :attribute, "name" => "type", "type" => "xs:string", "use" => "optional"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schematic/generator/xsd.rb

@@ -0,0 +1,111 @@
+module Schematic
+  module Generator
+    class Xsd
+      attr_reader :output, :names
+      attr_accessor :options
+
+      def initialize(klass, options = {})
+        @klass = klass
+        @names = Names.new(klass)
+        @options = options
+      end
+
+      def header(builder)
+        builder.instruct!
+      end
+
+      def schema(builder)
+        builder.xs :schema, ns("xs", :w3, :schema) do |schema|
+          Types.xsd(schema)
+          element_for_klass(schema)
+          generate(schema, @klass)
+        end
+      end
+
+      def element_for_klass(builder)
+        builder.xs :element, "name" => @names.element_collection, "type" => @names.collection_type
+      end
+
+      def generate(builder, klass)
+        nested_attributes.each do |nested_attribute|
+          next if nested_attribute.klass == klass || nested_attribute.klass == klass.superclass
+
+          nested_attribute.klass.generate_xsd(builder, klass, @options)
+        end
+
+        generate_complex_type_for_collection(builder)
+        generate_complex_type_for_model(builder)
+      end
+
+      def generate_complex_type_for_collection(builder)
+        builder.xs :complexType, "name" => @names.collection_type do |complex_type|
+          complex_type.xs :sequence do |sequence|
+            sequence.xs :element, "name" => @names.element, "type" => @names.type, "minOccurs" => "0", "maxOccurs" => "unbounded"
+          end
+          complex_type.xs :attribute, "name" => "type", "type" => "xs:string", "fixed" => "array"
+        end
+      end
+
+      def generate_complex_type_for_model(builder)
+        builder.xs :complexType, "name" => @names.type do |complex_type|
+          additional_methods = @klass.xsd_methods.merge(@options[:methods] || {})
+          ignored_methods = @klass.xsd_ignore_methods | (@options[:exclude] || [])
+          complex_type.xs :all do |all|
+            generate_column_elements(all, additional_methods, ignored_methods)
+
+            nested_attributes.each do |nested_attribute|
+              all.xs :element, "name" => "#{nested_attribute.name.to_s.dasherize}-attributes", "type" => nested_attribute.klass.xsd_generator.names.collection_type, "minOccurs" => "0", "maxOccurs" => "1"
+            end
+
+            generate_additional_methods(all, additional_methods)
+          end
+        end
+      end
+
+      def generate_column_elements(builder, additional_methods, ignored_methods)
+        @klass.columns.each do |column|
+          Column.new(@klass, column, additional_methods, ignored_methods).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
+          if values.present?
+            builder.xs :element, "name" => method_xsd_name, "minOccurs" => "0", "maxOccurs" => "1" do |element|
+              element.xs :complexType do |complex_type|
+                if values.is_a?(Array)
+                  complex_type.xs :sequence do |nested_sequence|
+                    values.each do |value|
+                      nested_sequence.xs :element, "name" => value.to_s.dasherize, "minOccurs" => "0", "maxOccurs" => "unbounded"
+                    end
+                  end
+                elsif values.is_a?(Hash)
+                  complex_type.xs :all do |nested_all|
+                    generate_additional_methods(nested_all, values)
+                  end
+                else
+                  raise "Additional methods must be a hash of hashes or hash of arrays"
+                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
+      end
+
+      def nested_attributes
+        @klass.reflect_on_all_associations.select do |association|
+          @klass.instance_methods.include?("#{association.name}_attributes=".to_sym) && association.options[:polymorphic] != true
+        end
+      end
+
+      def ns(ns, provider, key)
+        { "xmlns:#{ns}" => Namespaces::PROVIDERS[provider][key] }
+      end
+
+    end
+  end
+end

data/lib/schematic/serializers/xsd.rb

@@ -7,133 +7,22 @@ module Schematic
         end
       end
 
+      def xsd_generator
+        @xsd_generator ||= Schematic::Generator::Xsd.new(self)
+      end
+
       def to_xsd(options = {})
         output = ""
         builder = Builder::XmlMarkup.new(:target => output, :indent => 2)
-        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
+        xsd_generator.options = options
+        xsd_generator.header(builder)
+        xsd_generator.schema(builder)
         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
-          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
-
-            generate_xsd_additional_methods(all, additional_methods)
-          end
-        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
-        end
-      end
-
-      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|
-                if values.is_a?(Array)
-                  complex_type.xs :sequence do |nested_sequence|
-                    values.each do |value|
-                      nested_sequence.xs :element, "name" => value.to_s.dasherize, "minOccurs" => "0", "maxOccurs" => "unbounded"
-                    end
-                  end
-                elsif values.is_a?(Hash)
-                  complex_type.xs :all do |nested_all|
-                    generate_xsd_additional_methods(nested_all, values)
-                  end
-                else
-                  raise "Additional methods must be a hash of hashes or hash of arrays"
-                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
+      def generate_xsd(builder, klass, options)
+        xsd_generator.options = options
+        xsd_generator.generate(builder, klass)
       end
 
       def xsd_methods
@@ -144,17 +33,6 @@ module Schematic
         []
       end
 
-      def xsd_nested_attributes
-        self.reflect_on_all_associations.select do |association|
-          self.instance_methods.include?("#{association.name}_attributes=".to_sym) && association.options[:polymorphic] != true
-        end
-      end
-
-      def xsd_columns
-        self.columns
-      end
-
-
     end
   end
 end