schematic 0.3.8 → 0.4.0

data/README.rdoc

@@ -31,21 +31,22 @@ the XSD you can set: { :xsd => { :include => true } } in the options e.g.
     validates :category, :inclusion => { :in => ["foo", "bar"], :xsd => { :include => true } }, :if => lambda { ... }
   end
 
-You can include additional elements by defining a ".xsd_methods" on your class:
+You can include or exclude additional elements:
 
   class Post < ActiveRecord::Base
-    def self.xsd_methods
-      {:title => nil, :author => [:name, :email, :url]}
+    schematic do
+      element :title
+      element :author => [:name, :email, :url]
+      element :blog => { :post => { :category => nil } }
+      ignore :comments
     end
   end
 
-You can exclude elements by defining a ".xsd_ignore_methods" on your class:
+If you want to programatically include or exclude elements use:
 
-  class Post < ActiveRecord::Base
-    def self.xsd_ignore_methods
-      [:created_at, :updated_at]
-    end
-  end
+  Post#schematic_sandbox.added_elements and Post#schematic_sandbox.ignored_elements
+
+The former is a Hash and the latter is an Array.
 
 You can define your own custom restrictions by inheriting from the Restrictions Base class:
 

data/lib/schematic.rb

@@ -5,6 +5,7 @@ module Schematic
     end
   end
   module Generator
+    autoload :Sandbox, 'schematic/generator/sandbox'
     autoload :Xsd, 'schematic/generator/xsd'
     autoload :Names, 'schematic/generator/names'
     autoload :Namespaces, 'schematic/generator/namespaces'

data/lib/schematic/generator/sandbox.rb

@@ -0,0 +1,48 @@
+module Schematic
+  module Generator
+    class Sandbox
+      attr_accessor :ignored_elements, :added_elements
+
+      def initialize(klass)
+        @klass = klass
+        @ignored_elements ||= []
+        @added_elements ||= {}
+      end
+
+      def run(&block)
+        instance_eval &block
+      end
+
+      def xsd_generator
+        @xsd_generator ||= Schematic::Generator::Xsd.new(@klass)
+      end
+
+      def to_xsd(options = {})
+        output = ""
+        builder = Builder::XmlMarkup.new(:target => output, :indent => 2)
+        xsd_generator.options = options
+        xsd_generator.header(builder)
+        xsd_generator.schema(builder)
+        output
+      end
+
+      def generate_xsd(builder, klass, options)
+        xsd_generator.options = options
+        xsd_generator.generate(builder, klass)
+      end
+
+      def ignore(*fields)
+        fields.each { |field| ignored_elements << field }
+      end
+
+      def element(*args)
+        name = args.shift
+        if name.is_a? Hash
+          added_elements[name.keys.first] = name.values.first
+        else
+          added_elements[name] = nil
+        end
+      end
+    end
+  end
+end

data/lib/schematic/generator/xsd.rb

@@ -39,7 +39,7 @@ module Schematic
           next if nested_attribute.klass == klass
           next if nested_attribute.klass == klass.superclass
           next if @options && @options[:generated_types] && @options[:generated_types].include?(nested_attribute.klass)
-          nested_attribute.klass.generate_xsd(builder, klass, @options)
+          nested_attribute.klass.schematic_sandbox.generate_xsd(builder, klass, @options)
           @options[:generated_types] << nested_attribute.klass
         end
 
@@ -58,15 +58,15 @@ module Schematic
 
       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] || [])
+          additional_methods = @klass.schematic_sandbox.added_elements.merge(@options[:methods] || {})
+          ignored_methods = @klass.schematic_sandbox.ignored_elements | (@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(nested_attribute.name),
-                "type" => nested_attribute.klass.xsd_generator.names.collection_type,
+                "type" => nested_attribute.klass.schematic_sandbox.xsd_generator.names.collection_type,
                 "minOccurs" => "0",
                 "maxOccurs" => "1"
             end
@@ -134,7 +134,7 @@ module Schematic
           else
             column_klass = Struct.new(:name, :type)
             column = column_klass.new(method_name.to_s, :string)
-            Column.new(@klass, column, {}, @klass.xsd_ignore_methods).generate(builder)
+            Column.new(@klass, column, {}, @klass.schematic_sandbox.ignored_elements).generate(builder)
           end
         end
       end

data/lib/schematic/serializers/xsd.rb

@@ -7,30 +7,16 @@ module Schematic
         end
       end
 
-      def xsd_generator
-        @xsd_generator ||= Schematic::Generator::Xsd.new(self)
+      def schematic(&block)
+        schematic_sandbox.run(&block)
       end
 
-      def to_xsd(options = {})
-        output = ""
-        builder = Builder::XmlMarkup.new(:target => output, :indent => 2)
-        xsd_generator.options = options
-        xsd_generator.header(builder)
-        xsd_generator.schema(builder)
-        output
-      end
-
-      def generate_xsd(builder, klass, options)
-        xsd_generator.options = options
-        xsd_generator.generate(builder, klass)
+      def schematic_sandbox
+        @schematic_sandbox ||= Schematic::Generator::Sandbox.new(self)
       end
 
-      def xsd_methods
-        {}
-      end
-
-      def xsd_ignore_methods
-        []
+      def to_xsd(options = {})
+        schematic_sandbox.to_xsd(options)
       end
 
     end

data/lib/schematic/version.rb

@@ -1,3 +1,3 @@
 module Schematic
-  VERSION = "0.3.8"
+  VERSION = "0.4.0"
 end

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

@@ -15,6 +15,7 @@ describe Schematic::Generator::Restrictions::Enumeration do
           t.string "options"
           t.integer "force_enumeration"
           t.integer "skip_enumeration"
+          t.integer "skip_inclusion_set_lambda"
         end
 
         model do
@@ -26,6 +27,11 @@ describe Schematic::Generator::Restrictions::Enumeration do
           validates :options, :inclusion => { :in => lambda { |f| ["some valid attribute"] } }
           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
+
+          def some_method
+            true
+          end
         end
       end
 
@@ -42,7 +48,8 @@ describe Schematic::Generator::Restrictions::Enumeration do
                                               :active => true,
                                               :options => "some valid attribute",
                                               :force_enumeration => 2,
-                                              :skip_enumeration => 2)
+                                              :skip_enumeration => 2,
+                                              :skip_inclusion_set_lambda => 2)
         xml = [valid_instance].to_xml
         lambda {
           validate_xml_against_xsd(xml, subject)
@@ -121,6 +128,14 @@ describe Schematic::Generator::Restrictions::Enumeration do
                   </xs:simpleContent>
                 </xs:complexType>
               </xs:element>
+              <xs:element name="skip-inclusion-set-lambda" minOccurs="0" maxOccurs="1">
+                <xs:complexType>
+                  <xs:simpleContent>
+                    <xs:restriction base="Integer">
+                    </xs:restriction>
+                  </xs:simpleContent>
+                </xs:complexType>
+              </xs:element>
           XML
         end
 

data/spec/schematic/generator/sandbox_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe Schematic::Generator::Sandbox do
+  subject { Schematic::Generator::Sandbox.new(klass) }
+  let(:klass) { Object }
+
+  describe "ignoring elements" do
+    it "should add the method to the ignored list" do
+      subject.run do
+        ignore :foo
+      end
+      subject.ignored_elements.should 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)
+    end
+  end
+
+  describe "adding elements" do
+    context "given a single element" do
+      it "should add the method to the element list" do
+        subject.run do
+          element :foo
+        end
+        subject.added_elements.keys.should include(:foo)
+      end
+    end
+
+    context "nesting elements" do
+      it "should add the method to the element list" do
+        subject.run do
+          element :foo => { :bar => nil }
+        end
+        subject.added_elements[:foo].should == { :bar => nil }
+      end
+    end
+
+    context "sequence of subelements" do
+      it "should add the method to the element list" do
+        subject.run do
+          element :foo => [:bar]
+        end
+        subject.added_elements[:foo].should == [:bar]
+      end
+    end
+  end
+end
+

data/spec/schematic/serializers/xsd_xsd_ignore_methods_spec.rb

@@ -1,15 +1,15 @@
 require "spec_helper"
 
 describe Schematic::Serializers::Xsd do
-  describe ".xsd_ignore_methods" do
+  describe "schematic#ignore keyword" do
     with_model :some_model do
       table :id => false do |t|
         t.string :title
       end
 
       model do
-        def self.xsd_ignore_methods
-          [:title]
+        schematic do
+          ignore :title
         end
       end
     end

data/spec/schematic/serializers/xsd_xsd_methods_spec.rb

@@ -1,14 +1,14 @@
 require "spec_helper"
 
 describe Schematic::Serializers::Xsd do
-  describe ".xsd_methods" do
+  describe "Adding additional methods" do
     context "given a method" do
       with_model :some_model do
         table {}
 
         model do
-          def self.xsd_methods
-            {:foo_bar => nil}
+          schematic do
+            element :foo_bar
           end
         end
       end
@@ -58,8 +58,8 @@ describe Schematic::Serializers::Xsd do
             super({:methods => [:foo_bar]}.merge(options))
           end
 
-          def self.xsd_methods
-            {:foo_bar => nil}
+          schematic do
+            element :foo_bar
           end
         end
       end
@@ -121,8 +121,8 @@ describe Schematic::Serializers::Xsd do
             ["a", "b", "c"]
           end
 
-          def self.xsd_methods
-            {:bar => nil}
+          schematic do
+            element :bar
           end
 
           def to_xml(options = {})
@@ -191,8 +191,8 @@ describe Schematic::Serializers::Xsd do
             ["1", "2", "3"]
           end
 
-          def self.xsd_methods
-            {:foo => [:foo]}
+          schematic do
+            element :foo => [:foo]
           end
 
           def to_xml(options = {})
@@ -255,8 +255,9 @@ describe Schematic::Serializers::Xsd do
         table {}
 
         model do
-          def self.xsd_methods
-            { :foo => { :bar => {:baz => nil } } }
+          schematic do
+            element :foo => { :bar => { :baz => nil } }
+            element :quz
           end
         end
       end
@@ -293,6 +294,14 @@ describe Schematic::Serializers::Xsd do
             </xs:all>
             <xs:attribute name="type" type="xs:string" fixed="array" use="optional"/>
           </xs:complexType>
+        </xs:element>
+        <xs:element name="quz" minOccurs="0" maxOccurs="1">
+          <xs:complexType>
+            <xs:simpleContent>
+              <xs:restriction base="String">
+              </xs:restriction>
+            </xs:simpleContent>
+          </xs:complexType>
         </xs:element>
           XML
         end

data/spec/schematic_serializers_xsd_spec.rb

@@ -34,10 +34,10 @@ describe Schematic::Serializers::Xsd do
             validates :some_date, :presence => true, :allow_blank => true
             validates :some_datetime, :presence => true, :allow_blank => false
             attr_accessor :additional_method_array
-            class << self
-              def xsd_methods
-                {:foo => { :bar => { :baz => nil }, :quz => [:qaz] }, :method_is_also_columns => [:method_is_also_column], :additional_method_array => [] }
-              end
+            schematic do
+              element :foo => { :bar => { :baz => nil }, :quz => [:qaz] }
+              element :method_is_also_columns => [:method_is_also_column]
+              element :additional_method_array => []
             end
 
             def to_xml(options)

data/spec/spec_helper.rb

@@ -40,6 +40,7 @@ def sanitize_xml(xml)
 end
 
 def generate_xsd_for_model(model, header_element = nil)
+  xsd_generator = model.schematic_sandbox.xsd_generator
   output = <<-XML
 <?xml version="1.0" encoding="UTF-8"?>
 <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
@@ -92,16 +93,16 @@ def generate_xsd_for_model(model, header_element = nil)
   </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="#{xsd_generator.names.element_collection}" type="#{xsd_generator.names.collection_type}">
   #{header_element}
   </xs:element>
-  <xs:complexType name="#{model.xsd_generator.names.collection_type}">
+  <xs:complexType name="#{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"/>
+      <xs:element name="#{xsd_generator.names.element}" type="#{xsd_generator.names.type}" minOccurs="0" maxOccurs="unbounded"/>
     </xs:sequence>
     <xs:attribute name="type" type="xs:string" fixed="array"/>
   </xs:complexType>
-  <xs:complexType name="#{model.xsd_generator.names.type}">
+  <xs:complexType name="#{xsd_generator.names.type}">
     <xs:all>
   #{yield}
     </xs:all>

metadata

@@ -2,7 +2,7 @@
 name: schematic
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.8
+  version: 0.4.0
 platform: ruby
 authors: 
 - Case Commons, LLC
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-01 00:00:00 Z
+date: 2011-08-03 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -118,6 +118,7 @@ files:
 - lib/schematic/generator/restrictions/length.rb
 - lib/schematic/generator/restrictions/numericality.rb
 - lib/schematic/generator/restrictions/pattern.rb
+- lib/schematic/generator/sandbox.rb
 - lib/schematic/generator/types.rb
 - lib/schematic/generator/uniqueness.rb
 - lib/schematic/generator/xsd.rb
@@ -130,6 +131,7 @@ files:
 - spec/schematic/generator/restrictions/mixin_spec.rb
 - spec/schematic/generator/restrictions/numericality_spec.rb
 - spec/schematic/generator/restrictions/pattern_spec.rb
+- spec/schematic/generator/sandbox_spec.rb
 - spec/schematic/generator/uniqueness_spec.rb
 - spec/schematic/serializers/xsd_extend_spec.rb
 - spec/schematic/serializers/xsd_validation_presence_spec.rb
@@ -154,7 +156,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3119055094098631503
+      hash: -3764245537010144539
       segments: 
       - 0
       version: "0"
@@ -163,7 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3119055094098631503
+      hash: -3764245537010144539
       segments: 
       - 0
       version: "0"
@@ -181,6 +183,7 @@ test_files:
 - spec/schematic/generator/restrictions/mixin_spec.rb
 - spec/schematic/generator/restrictions/numericality_spec.rb
 - spec/schematic/generator/restrictions/pattern_spec.rb
+- spec/schematic/generator/sandbox_spec.rb
 - spec/schematic/generator/uniqueness_spec.rb
 - spec/schematic/serializers/xsd_extend_spec.rb
 - spec/schematic/serializers/xsd_validation_presence_spec.rb