spectifly 0.0.1

data/lib/spectifly/xsd/builder.rb

@@ -0,0 +1,43 @@
+require 'builder'
+require_relative 'field'
+require_relative 'association'
+require_relative 'types'
+
+module Spectifly
+  module Xsd
+    class Builder < Spectifly::Base::Builder
+      def root_type
+        Spectifly::Support.lower_camelize("#{root}Type")
+      end
+
+      def build_type(xml = nil)
+        xml ||= ::Builder::XmlMarkup.new(:indent => 2)
+        xml.xs 'complexType'.to_sym, :name => root_type do
+          xml.xs :sequence do
+            fields.each do |field|
+              field.to_xsd(xml)
+            end
+            associations.each do |association|
+              association.to_xsd(xml)
+            end
+          end
+        end
+      end
+
+      def build(xml = nil)
+        xml ||= ::Builder::XmlMarkup.new(:indent => 2)
+        xml.instruct! :xml, :version => '1.0', :encoding => 'UTF-8'
+        xml.xs :schema, 'xmlns:xs' => "http://www.w3.org/2001/XMLSchema", 'elementFormDefault' => "qualified" do
+          custom_types.each do |cust|
+            xml.xs :include, 'schemaLocation' => "#{cust}.xsd"
+          end
+          unless utilized_extended_types.empty?
+            xml.xs :include, 'schemaLocation' => "extended.xsd"
+          end
+          xml.xs :element, :name => Spectifly::Support.camelize(root), :type => root_type
+          build_type(xml)
+        end
+      end
+    end
+  end
+end

data/lib/spectifly/xsd/field.rb

@@ -0,0 +1,92 @@
+require_relative 'types'
+
+module Spectifly
+  module Xsd
+    class Field < Spectifly::Base::Field
+      def extract_restrictions
+        super
+        @restrictions.delete('unique')
+        @restrictions
+      end
+
+      def name
+        Spectifly::Support.camelize(@field_name).gsub(/\W/, '')
+      end
+
+      def name_as_type
+        Spectifly::Support.lower_camelize("#{name}Type")
+      end
+
+      def display_type
+        prefix = if @validations.include?('Must be positive')
+          'positive_'
+        elsif @validations.include?('Must be non-negative')
+          'non_negative_'
+        end
+        prefixed_type = "#{prefix}#{type}"
+        camel_type = Spectifly::Support.lower_camelize(prefixed_type)
+        if Spectifly::Xsd::Types::Native.include?(prefixed_type)
+          "xs:#{camel_type}"
+        else
+          "#{camel_type}Type"
+        end
+      end
+
+      def to_xsd(builder = nil)
+        builder ||= ::Builder::XmlMarkup.new(:indent => 2)
+        attributes['type'] = display_type if restrictions.empty?
+        attributes['minOccurs'] = '0' unless required?
+        attributes['maxOccurs'] = 'unbounded' if multiple?
+        block = embedded_block
+        builder.xs :element, { :name => name }.merge(attributes), &block
+      end
+
+      def regex
+        return nil unless restrictions['regex']
+        regex = restrictions['regex'].source
+        if regex =~ /^(\^)?([^\$]*)(\$)?$/
+          prefix = '[\s\S]*' unless $1
+          suffix = '[\s\S]*' unless $3
+          regex = "#{prefix}#{$2}#{suffix}"
+        end
+        regex
+      end
+
+      def type_block(use_name = false)
+        type_attributes = { :name => name_as_type } if use_name
+        Proc.new { |el|
+          el.xs :simpleType, type_attributes do |st|
+            st.xs :restriction, :base => display_type, &restrictions_block
+          end
+        }
+      end
+
+      def restrictions_block
+        if !restrictions.empty?
+          Proc.new { |el|
+            el.xs :minInclusive, :value => restrictions['minimum_value'] if restrictions['minimum_value']
+            el.xs :maxInclusive, :value => restrictions['maximum_value'] if restrictions['maximum_value']
+            el.xs :pattern, :value => regex if regex
+            (restrictions['valid_values'] || []).each do |vv|
+              el.xs :enumeration, :value => vv
+            end
+          }
+        end
+      end
+
+      def embedded_block
+        if description || example || !restrictions.empty?
+          Proc.new { |el|
+            if description || example
+              el.xs :annotation do |ann|
+                ann.xs :documentation, description if description
+                ann.xs :documentation, "Example: #{example}" if example
+              end
+            end
+            type_block.call(el) unless restrictions.empty?
+          }
+        end
+      end
+    end
+  end
+end

data/lib/spectifly/xsd/types.rb

@@ -0,0 +1,32 @@
+module Spectifly
+  module Xsd
+    class Types
+      Native = [
+        'boolean',
+        'string',
+        'date',
+        'date_time',
+        'integer',
+        'non_negative_integer',
+        'positive_integer',
+        'decimal',
+        'base64_binary'
+      ]
+
+      Extended = Spectifly::Base::Types::Extended
+
+      class << self
+        def build_extended(xml = nil)
+          xml ||= ::Builder::XmlMarkup.new(:indent => 2)
+          xml.instruct! :xml, :version => '1.0', :encoding => 'UTF-8'
+          xml.xs :schema, 'xmlns:xs' => "http://www.w3.org/2001/XMLSchema", 'elementFormDefault' => "qualified" do
+            Extended.each_pair do |name, attributes|
+              field = Spectifly::Xsd::Field.new(name.dup, attributes.dup)
+              field.type_block(true).call(xml)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tasks/spectifly.rake

@@ -0,0 +1,6 @@
+namespace :spectifly do
+  desc 'Do whatever'
+  Spectifly::Task.new('whatever') do |sfly|
+    sfly.config_path = File.join(Rake.original_dir, 'config', 'spectifly.yml')
+  end
+end

data/spec/expectations/extended.xsd

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
+  <xs:simpleType name="percentType">
+    <xs:restriction base="xs:decimal"/>
+  </xs:simpleType>
+  <xs:simpleType name="currencyType">
+    <xs:restriction base="xs:decimal"/>
+  </xs:simpleType>
+  <xs:simpleType name="yearType">
+    <xs:restriction base="xs:integer"/>
+  </xs:simpleType>
+  <xs:simpleType name="phoneType">
+    <xs:restriction base="xs:string"/>
+  </xs:simpleType>
+</xs:schema>

data/spec/expectations/group.json

@@ -0,0 +1,37 @@
+{
+  "group": {
+    "has_many": {
+      "peeps": {
+        "type": "individual",
+        "required": false,
+        "description": "Who is in the group"
+      }
+    },
+    "has_one": {
+      "master": {
+        "type": "individual",
+        "required": true,
+        "description": "Who is the master of the group"
+      }
+    },
+    "group_id": {
+      "type": "string",
+      "multiple": false,
+      "required": false,
+      "description": "Identifier used to register group for scams",
+      "restrictions": {
+        "unique": true,
+        "regex": "^[0-9]{2}(-?[0-9]{5})$"
+      }
+    },
+    "name": {
+      "type": "string",
+      "multiple": false,
+      "required": true,
+      "description": "The name of this group",
+      "restrictions": {
+        "regex": "group"
+      }
+    }
+  }
+}

data/spec/expectations/group.xsd

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
+  <xs:include schemaLocation="individual.xsd"/>
+  <xs:element name="Group" type="groupType"/>
+  <xs:complexType name="groupType">
+    <xs:sequence>
+      <xs:element name="GroupID" minOccurs="0">
+        <xs:annotation>
+          <xs:documentation>Identifier used to register group for scams</xs:documentation>
+        </xs:annotation>
+        <xs:simpleType>
+          <xs:restriction base="xs:string">
+            <xs:pattern value="[0-9]{2}(-?[0-9]{5})"/>
+          </xs:restriction>
+        </xs:simpleType>
+      </xs:element>
+      <xs:element name="Name">
+        <xs:annotation>
+          <xs:documentation>The name of this group</xs:documentation>
+        </xs:annotation>
+        <xs:simpleType>
+          <xs:restriction base="xs:string">
+            <xs:pattern value="[\s\S]*group[\s\S]*"/>
+          </xs:restriction>
+        </xs:simpleType>
+      </xs:element>
+      <xs:element name="Peeps" type="individualType" minOccurs="0" maxOccurs="unbounded">
+        <xs:annotation>
+          <xs:documentation>Who is in the group</xs:documentation>
+        </xs:annotation>
+      </xs:element>
+      <xs:element name="Master" type="individualType">
+        <xs:annotation>
+          <xs:documentation>Who is the master of the group</xs:documentation>
+        </xs:annotation>
+      </xs:element>
+    </xs:sequence>
+  </xs:complexType>
+</xs:schema>

data/spec/expectations/individual.json

@@ -0,0 +1,57 @@
+{
+  "individual": {
+    "belongs_to": {
+      "party": {
+        "type": "group",
+        "required": true,
+        "description": "Which funtime party this individual happy with is"
+      }
+    },
+    "name": {
+      "type": "string",
+      "multiple": false,
+      "required": true,
+      "description": "The individual's name",
+      "example": "Randy McTougherson",
+      "restrictions": {
+        "unique": true
+      }
+    },
+    "age": {
+      "type": "integer",
+      "multiple": false,
+      "required": false,
+      "validations": [
+        "Must be non-negative"
+      ]
+    },
+    "happiness": {
+      "type": "percent",
+      "multiple": false,
+      "required": false,
+      "restrictions": {
+        "minimum_value": 0,
+        "maximum_value": 100
+      }
+    },
+    "positions": {
+      "type": "string",
+      "multiple": true,
+      "required": false,
+      "description": "Which positions individual occupies in a group",
+      "restrictions": {
+        "valid_values": [
+          "Lotus",
+          "Pole",
+          "Third"
+        ]
+      }
+    },
+    "pickled": {
+      "type": "boolean",
+      "multiple": false,
+      "required": true,
+      "description": "Whether or not this individual is pickled"
+    }
+  }
+}

data/spec/expectations/individual.xsd

@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
+  <xs:include schemaLocation="group.xsd"/>
+  <xs:include schemaLocation="extended.xsd"/>
+  <xs:element name="Individual" type="individualType"/>
+  <xs:complexType name="individualType">
+    <xs:sequence>
+      <xs:element name="Name" type="xs:string">
+        <xs:annotation>
+          <xs:documentation>The individual's name</xs:documentation>
+          <xs:documentation>Example: Randy McTougherson</xs:documentation>
+        </xs:annotation>
+      </xs:element>
+      <xs:element name="Age" type="xs:nonNegativeInteger" minOccurs="0"/>
+      <xs:element name="Happiness" minOccurs="0">
+        <xs:simpleType>
+          <xs:restriction base="percentType">
+            <xs:minInclusive value="0"/>
+            <xs:maxInclusive value="100"/>
+          </xs:restriction>
+        </xs:simpleType>
+      </xs:element>
+      <xs:element name="Positions" minOccurs="0" maxOccurs="unbounded">
+        <xs:annotation>
+          <xs:documentation>Which positions individual occupies in a group</xs:documentation>
+        </xs:annotation>
+        <xs:simpleType>
+          <xs:restriction base="xs:string">
+            <xs:enumeration value="Lotus"/>
+            <xs:enumeration value="Pole"/>
+            <xs:enumeration value="Third"/>
+          </xs:restriction>
+        </xs:simpleType>
+      </xs:element>
+      <xs:element name="Pickled" type="xs:boolean">
+        <xs:annotation>
+          <xs:documentation>Whether or not this individual is pickled</xs:documentation>
+        </xs:annotation>
+      </xs:element>
+      <xs:element name="Party" type="groupType" minOccurs="0">
+        <xs:annotation>
+          <xs:documentation>Which funtime party this individual happy with is</xs:documentation>
+        </xs:annotation>
+      </xs:element>
+    </xs:sequence>
+  </xs:complexType>
+</xs:schema>

data/spec/expectations/presented/masterless_group.json

@@ -0,0 +1,30 @@
+{
+  "group": {
+    "has_many": {
+      "peeps": {
+        "type": "individual",
+        "required": false,
+        "description": "Who is in the group"
+      }
+    },
+    "group_id": {
+      "type": "string",
+      "multiple": false,
+      "required": false,
+      "description": "Identifier used to register group for scams",
+      "restrictions": {
+        "unique": true,
+        "regex": "^[0-9]{2}(-?[0-9]{5})$"
+      }
+    },
+    "name": {
+      "type": "string",
+      "multiple": false,
+      "required": true,
+      "description": "The name of this group",
+      "restrictions": {
+        "regex": "group"
+      }
+    }
+  }
+}

data/spec/expectations/presented/masterless_group.xsd

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
+  <xs:include schemaLocation="individual.xsd"/>
+  <xs:element name="Group" type="groupType"/>
+  <xs:complexType name="groupType">
+    <xs:sequence>
+      <xs:element name="GroupID" minOccurs="0">
+        <xs:annotation>
+          <xs:documentation>Identifier used to register group for scams</xs:documentation>
+        </xs:annotation>
+        <xs:simpleType>
+          <xs:restriction base="xs:string">
+            <xs:pattern value="[0-9]{2}(-?[0-9]{5})"/>
+          </xs:restriction>
+        </xs:simpleType>
+      </xs:element>
+      <xs:element name="Name">
+        <xs:annotation>
+          <xs:documentation>The name of this group</xs:documentation>
+        </xs:annotation>
+        <xs:simpleType>
+          <xs:restriction base="xs:string">
+            <xs:pattern value="[\s\S]*group[\s\S]*"/>
+          </xs:restriction>
+        </xs:simpleType>
+      </xs:element>
+      <xs:element name="Peeps" type="individualType" minOccurs="0" maxOccurs="unbounded">
+        <xs:annotation>
+          <xs:documentation>Who is in the group</xs:documentation>
+        </xs:annotation>
+      </xs:element>
+    </xs:sequence>
+  </xs:complexType>
+</xs:schema>