schematic 0.6.2 → 0.7.0

data/lib/schematic/generator/sandbox.rb

@@ -1,3 +1,6 @@
+require 'builder'
+require 'schematic/generator/xsd'
+
 module Schematic
   module Generator
     class Sandbox
@@ -20,7 +23,7 @@ module Schematic
       end
 
       def to_xsd(options = {})
-        output = ""
+        output = ''
         builder = Builder::XmlMarkup.new(:target => output, :indent => 2)
         xsd_generator.options = options
         xsd_generator.header(builder)

data/lib/schematic/generator/types.rb

@@ -2,24 +2,25 @@ 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" },
-      }
+        :integer  => { :complex_type => 'Integer',  :xsd_type => 'xs:integer' }.freeze,
+        :float    => { :complex_type => 'Float',    :xsd_type => 'xs:float' }.freeze,
+        :string   => { :complex_type => 'String',   :xsd_type => 'xs:string' }.freeze,
+        :text     => { :complex_type => 'Text',     :xsd_type => 'xs:string' }.freeze,
+        :datetime => { :complex_type => 'DateTime', :xsd_type => 'xs:dateTime' }.freeze,
+        :date     => { :complex_type => 'Date',     :xsd_type => 'xs:date' }.freeze,
+        :boolean  => { :complex_type => 'Boolean',  :xsd_type => 'xs:boolean' }.freeze,
+        :uuid     => { :complex_type => 'String',   :xsd_type => 'xs:string' }.freeze,
+      }.freeze
 
       def self.xsd(builder)
-        Types::COMPLEX.each do |key, value|
+        Types::COMPLEX.values.uniq.each do |value|
           complex_type_name = value[:complex_type]
           xsd_type = value[:xsd_type]
-          builder.xs :complexType, "name" => complex_type_name do |complex_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"
-                extension.xs :attribute, "name" => "nil", "type" => "xs:boolean", "use" => "optional"
+              simple_content.xs :extension, 'base' => xsd_type do |extension|
+                extension.xs :attribute, 'name' => 'type', 'type' => 'xs:string', 'use' => 'optional'
+                extension.xs :attribute, 'name' => 'nil', 'type' => 'xs:boolean', 'use' => 'optional'
               end
             end
           end

data/lib/schematic/generator/uniqueness.rb

@@ -1,18 +1,20 @@
+require 'active_record/validations/uniqueness'
+require 'schematic/generator/column_validator'
+
 module Schematic
   module Generator
     class Uniqueness < ColumnValidator
-
       def generate(builder)
         for_validator ActiveRecord::Validations::UniquenessValidator do |validator|
           unique_name = validator.attributes.first.to_s.dasherize
           additional_fields = (Array.wrap(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
+          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
+              unique.xs :field, 'xpath' => additional_field
             end
           end
         end
@@ -20,6 +22,3 @@ module Schematic
     end
   end
 end
-
-
-

data/lib/schematic/generator/xsd.rb

@@ -1,3 +1,9 @@
+require 'schematic/generator/column'
+require 'schematic/generator/names'
+require 'schematic/generator/namespaces'
+require 'schematic/generator/types'
+require 'schematic/generator/uniqueness'
+
 module Schematic
   module Generator
     class Xsd
@@ -21,7 +27,7 @@ module Schematic
       end
 
       def schema(builder)
-        builder.xs :schema, ns("xs", :w3, :schema) do |schema|
+        builder.xs :schema, ns('xs', :w3, :schema) do |schema|
           Types.xsd(schema)
           element_for_klass(schema)
           generate(schema, @klass)
@@ -29,7 +35,7 @@ module Schematic
       end
 
       def element_for_klass(builder)
-        builder.xs :element, "name" => @names.element_collection, "type" => @names.collection_type do |element|
+        builder.xs :element, 'name' => @names.element_collection, 'type' => @names.collection_type do |element|
           generate_uniqueness_constraints(element)
         end
       end
@@ -65,16 +71,16 @@ module Schematic
       end
 
       def generate_complex_type_for_collection(builder)
-        builder.xs :complexType, "name" => @names.collection_type do |complex_type|
+        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"
+            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"
+          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|
+        builder.xs :complexType, 'name' => @names.type do |complex_type|
           additional_methods = @klass.schematic_sandbox.added_elements.merge(@options[:methods] || {})
           ignored_methods = @klass.schematic_sandbox.ignored_elements.dup
           exclude = @exclude
@@ -98,22 +104,22 @@ module Schematic
               case nested_attribute.macro
               when :has_many
                 all.xs :element,
-                  "name" => nested_attribute_name(nested_attribute.name),
-                  "type" => nested_attribute.klass.schematic_sandbox.xsd_generator.names.collection_type,
-                  "minOccurs" => "0",
-                  "maxOccurs" => "1"
+                  'name' => nested_attribute_name(nested_attribute.name),
+                  'type' => nested_attribute.klass.schematic_sandbox.xsd_generator.names.collection_type,
+                  'minOccurs' => '0',
+                  'maxOccurs' => '1'
               when :has_one
                 all.xs :element,
-                  "name" => nested_attribute_name(nested_attribute.name, {:pluralized => false}),
-                  "type" => nested_attribute.klass.schematic_sandbox.xsd_generator.names.type,
-                  "minOccurs" => "0",
-                  "maxOccurs" => "1"
+                  'name' => nested_attribute_name(nested_attribute.name, {:pluralized => false}),
+                  'type' => nested_attribute.klass.schematic_sandbox.xsd_generator.names.type,
+                  'minOccurs' => '0',
+                  'maxOccurs' => '1'
               when :belongs_to
                 all.xs :element,
-                  "name" => nested_attribute_name(nested_attribute.name, {:pluralized => false}),
-                  "type" => nested_attribute.klass.schematic_sandbox.xsd_generator.names.type,
-                  "minOccurs" => "0",
-                  "maxOccurs" => "1"
+                  'name' => nested_attribute_name(nested_attribute.name, {:pluralized => false}),
+                  'type' => nested_attribute.klass.schematic_sandbox.xsd_generator.names.type,
+                  'minOccurs' => '0',
+                  'maxOccurs' => '1'
               end
             end
 
@@ -140,10 +146,10 @@ module Schematic
         enumeration_method = "xsd_#{value}_enumeration_restrictions".to_sym
         builder.xs :complexType do |complex_type|
           complex_type.xs :simpleContent do |simple_content|
-            simple_content.xs :restriction, "base" => "String" do |restriction|
+            simple_content.xs :restriction, 'base' => 'String' do |restriction|
               if @klass.respond_to? enumeration_method
                 @klass.send(enumeration_method).each do |enumeration|
-                  restriction.xs :enumeration, "value" => enumeration
+                  restriction.xs :enumeration, 'value' => enumeration
                 end
               end
             end
@@ -155,18 +161,18 @@ module Schematic
         additional_methods.each do |method_name, values|
           method_xsd_name = method_name.to_s.dasherize
           if values.is_a?(Array) || values.is_a?(Hash)
-            builder.xs :element, "name" => method_xsd_name, "minOccurs" => "0", "maxOccurs" => "1" do |element|
+            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|
                     if values.present?
                       values.each do |value|
-                        nested_sequence.xs :element, "name" => value.to_s.dasherize, "minOccurs" => "0", "maxOccurs" => "unbounded" do |sequence_element|
+                        nested_sequence.xs :element, 'name' => value.to_s.dasherize, 'minOccurs' => '0', 'maxOccurs' => 'unbounded' do |sequence_element|
                           generate_inclusion_value_restrictions(sequence_element, value)
                         end
                       end
                     else
-                      nested_sequence.xs :any, "processContents" => "skip", "minOccurs" => "0", "maxOccurs" => "unbounded"
+                      nested_sequence.xs :any, 'processContents' => 'skip', 'minOccurs' => '0', 'maxOccurs' => 'unbounded'
                     end
                   end
                 elsif values.is_a?(Hash)
@@ -174,9 +180,9 @@ module Schematic
                     generate_additional_methods(nested_all, values)
                   end
                 else
-                  raise "Additional methods must be a hash of hashes or hash of arrays"
+                  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"
+                complex_type.xs :attribute, 'name' => 'type', 'type' => 'xs:string', 'fixed' => 'array', 'use' => 'optional'
               end
             end
           else
@@ -203,7 +209,7 @@ module Schematic
       def nested_attribute_name(name, options={})
         pluralized = options.delete(:pluralized)
         pluralized = true if pluralized.nil?
-        name = name.to_s.gsub("_", "-")
+        name = name.to_s.gsub('_', '-')
         name = name.pluralize if pluralized
         "#{name}-attributes"
       end

data/lib/schematic/serializers/xsd.rb

@@ -1,11 +1,12 @@
+require 'schematic/generator/sandbox'
+require 'schematic/exceptions'
+
 module Schematic
   module Serializers
     module Xsd
-      class << self
-        def extended(klass)
-          raise ClassMissingXmlSerializer unless klass.ancestors.include?(ActiveModel::Serializers::Xml)
-          raise ClassMissingAttributes unless klass.instance_methods.include?(:attributes)
-        end
+      def self.extended(klass)
+        raise ClassMissingXmlSerializer unless klass.ancestors.include?(ActiveModel::Serializers::Xml)
+        raise ClassMissingAttributes unless klass.instance_methods.include?(:attributes)
       end
 
       def schematic(&block)
@@ -19,7 +20,6 @@ module Schematic
       def to_xsd(options = {})
         schematic_sandbox.to_xsd(options)
       end
-
     end
   end
 end

data/lib/schematic/version.rb

@@ -1,3 +1,3 @@
 module Schematic
-  VERSION = "0.6.2"
+  VERSION = '0.7.0'.freeze
 end

data/schematic.gemspec

@@ -1,29 +1,28 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "schematic/version"
+# encoding: utf-8
+$:.push File.expand_path('../lib', __FILE__)
+require 'schematic/version'
 
-Gem::Specification.new do |s|
-  s.name        = "schematic"
-  s.version     = Schematic::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Case Commons, LLC"]
-  s.email       = ["casecommons-dev@googlegroups.com"]
-  s.homepage    = "https://github.com/Casecommons/schematic"
-  s.summary     = %q{Automatic XSD generation from ActiveRecord models}
-  s.description = %q{Automatic XSD generation from ActiveRecord models}
+Gem::Specification.new do |spec|
+  spec.name        = 'schematic'
+  spec.version     = Schematic::VERSION
+  spec.authors     = ['Case Commons, LLC']
+  spec.email       = ['casecommons-dev@googlegroups.com', 'andrew@johnandrewmarshall.com']
+  spec.homepage    = 'https://github.com/Casecommons/schematic'
+  spec.summary     = %q{Automatic XSD generation from ActiveRecord models}
+  spec.description = spec.summary
+  spec.license     = 'MIT'
 
-  s.rubyforge_project = "schematic"
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
 
-  s.add_dependency('activerecord', '>= 3.0.0')
-  s.add_dependency('builder')
-  s.add_development_dependency('rspec-rails', '= 2.7')
-  s.add_development_dependency('with_model', '>= 0.2.4')
-  s.add_development_dependency('nokogiri')
-  s.add_development_dependency('sqlite3')
-  s.add_development_dependency('autotest')
+  spec.add_dependency 'activerecord', '~> 4.0'
+  spec.add_dependency 'builder'
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  spec.add_development_dependency 'nokogiri'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 2.14'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'with_model', '~> 1.0'
 end

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

@@ -1,12 +1,12 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe Schematic::Generator::Restrictions::Enumeration do
+describe "Schematic::Generator::Restrictions::Custom" do
   describe ".to_xsd" do
     context "with a model with custom validations" do
       before do
         class CrazyTownValidator < ActiveModel::EachValidator
           def validate_each(record, attribute, value)
-            record.errors.add(attribute, "must be crazy") unless value.match /.*crazy.*|\w/
+            record.errors.add(attribute, 'must be crazy') unless value.match /.*crazy.*|\w/
           end
 
           def xsd_pattern_restrictions
@@ -18,30 +18,31 @@ describe Schematic::Generator::Restrictions::Enumeration do
       subject { sanitize_xml(CustomModel.to_xsd) }
       with_model :custom_model do
         table :id => false do |t|
-          t.string "title"
+          t.string 'title'
         end
 
         model do
+          self.primary_key = :title
           validates :title, :crazy_town => true
         end
       end
 
       it "should validate against it's own XSD" do
-        invalid_instance = CustomModel.new(:title => "happy today")
+        invalid_instance = CustomModel.new(:title => 'happy today')
         xml = [invalid_instance].to_xml
-        lambda {
+        expect {
           validate_xml_against_xsd(xml, subject)
-        }.should raise_error
-        invalid_instance = CustomModel.new(:title => "happytoday")
+        }.to raise_error
+        invalid_instance = CustomModel.new(:title => 'happytoday')
         xml = [invalid_instance].to_xml
-        lambda {
+        expect {
           validate_xml_against_xsd(xml, subject)
-        }.should raise_error
-        valid_instance = CustomModel.new(:title => "iamcrazytoday")
+        }.to raise_error
+        valid_instance = CustomModel.new(:title => 'iamcrazytoday')
         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
@@ -60,12 +61,8 @@ describe Schematic::Generator::Restrictions::Enumeration do
           XML
         end
 
-        subject.should == xsd
+        expect(subject).to eq(xsd)
       end
     end
   end
 end
-
-
-
-

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

@@ -1,32 +1,32 @@
-require "spec_helper"
-require "support/extensions/active_model/validations/inclusion"
+require 'spec_helper'
 
-describe Schematic::Generator::Restrictions::Enumeration do
+describe "Schematic::Generator::Restrictions::Enumeration" do
   describe ".to_xsd" do
     context "with a model with inclusion validations" do
       subject { sanitize_xml(EnumerationModel.to_xsd) }
       with_model :enumeration_model do
         table :id => false do |t|
-          t.string "title"
-          t.string "should_be_skipped"
-          t.string "should_also_be_skipped"
-          t.string "and_also_be_skipped"
-          t.boolean "active"
-          t.string "options"
-          t.string "more_options"
-          t.integer "force_enumeration"
-          t.integer "skip_enumeration"
-          t.integer "skip_inclusion_set_lambda"
+          t.string 'title'
+          t.string 'should_be_skipped'
+          t.string 'should_also_be_skipped'
+          t.string 'and_also_be_skipped'
+          t.boolean 'active'
+          t.string 'options'
+          t.string 'more_options'
+          t.integer 'force_enumeration'
+          t.integer 'skip_enumeration'
+          t.integer 'skip_inclusion_set_lambda'
         end
 
         model do
-          validates :title, :inclusion => { :in => ["a", "b", "c"] }
-          validates :should_be_skipped, :inclusion => ["a", "b", "c"], :if => lambda { false }
-          validates :should_also_be_skipped, :inclusion => ["a", "b", "c"], :unless => lambda { false }
-          validates :and_also_be_skipped, :inclusion => ["a", "b", "c"], :if => lambda { true}, :unless => lambda { false }
+          self.primary_key = :title
+          validates :title, :inclusion => { :in => ['a', 'b', 'c'] }
+          validates :should_be_skipped, :inclusion => ['a', 'b', 'c'], :if => lambda { false }
+          validates :should_also_be_skipped, :inclusion => ['a', 'b', 'c'], :unless => lambda { false }
+          validates :and_also_be_skipped, :inclusion => ['a', 'b', 'c'], :if => lambda { true}, :unless => lambda { false }
           validates :active, :inclusion => { :in => [true, false] }
-          validates :options, :inclusion => { :in => lambda { |f| ["some valid attribute"] } }
-          validates :more_options, :inclusion => { :in => lambda { |f| f.title == "something" ? ["test"] : ["something else"] } }
+          validates :options, :inclusion => { :in => lambda { |f| ['some valid attribute'] } }
+          validates :more_options, :inclusion => { :in => lambda { |f| f.title == 'something' ? ['test'] : ['something else'] } }
           validates :force_enumeration, :inclusion => { :in => [1, 2], :xsd => { :include => true} }, :if => lambda { false }
           validates :skip_enumeration, :inclusion => { :in => [1, 2], :xsd => { :include => false} }, :if => lambda { true }
           validates :skip_inclusion_set_lambda, :inclusion => { :in => lambda { |x| [1, 2] } }, :if => :some_method
@@ -38,25 +38,25 @@ describe Schematic::Generator::Restrictions::Enumeration do
       end
 
       it "should validate against it's own XSD" do
-        invalid_instance = EnumerationModel.new(:title => "d")
+        invalid_instance = EnumerationModel.new(:title => 'd')
         xml = [invalid_instance].to_xml
-        lambda {
+        expect {
           validate_xml_against_xsd(xml, subject)
-        }.should raise_error
-        valid_instance = EnumerationModel.new(:title => "a",
-                                              :should_be_skipped => "a",
-                                              :should_also_be_skipped => "a",
-                                              :and_also_be_skipped => "a",
+        }.to raise_error
+        valid_instance = EnumerationModel.new(:title => 'a',
+                                              :should_be_skipped => 'a',
+                                              :should_also_be_skipped => 'a',
+                                              :and_also_be_skipped => 'a',
                                               :active => true,
-                                              :options => "some valid attribute",
-                                              :more_options => "something else",
+                                              :options => 'some valid attribute',
+                                              :more_options => 'something else',
                                               :force_enumeration => 2,
                                               :skip_enumeration => 2,
                                               :skip_inclusion_set_lambda => 2)
         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
@@ -151,7 +151,7 @@ describe Schematic::Generator::Restrictions::Enumeration do
           XML
         end
 
-        subject.should == xsd
+        expect(subject).to eq(xsd)
       end
     end
   end