rgen-xsd 0.1.0

data/lib/rgen/xsd/metamodel_generator.rb

@@ -0,0 +1,110 @@
+$:.unshift(File.dirname(__FILE__)+"/../../")
+
+require "rgen/environment"
+require "rgen/util/name_helper"
+require 'mmgen/metamodel_generator'
+
+require "rgen/xsd/xsd_instantiator"
+require "rgen/xsd/metamodel_modification_helper"
+require 'optparse'
+ 
+include RGen::Util::NameHelper
+include RGen::XSD::MetamodelModificationHelper
+
+options = {}
+optparse = OptionParser.new do|opts|
+  opts.banner = "Usage: metamodel_generator.rb [options] <schema file>+"
+
+  opts.on( '--mm VERSION', 'XML schema version: 1.0 or 1.1' ) do |v|
+    options[:mm] = v
+  end
+
+  opts.on('-o FILE', "Output metamodel file") do |f|
+    options[:outfile] = f
+  end
+end
+optparse.parse!
+if !options[:mm]
+  puts "Schema version not specified" 
+  exit
+end
+if !options[:outfile]
+  puts "Output file not specified" 
+  exit
+end
+
+case options[:mm]
+when "1.0"
+  require "rgen/xsd/1.0/metamodel"
+when "1.1"
+  require "rgen/xsd/1.1/metamodel"
+else
+  puts "Unknown schema version: #{options[:mm]}"
+  exit
+end
+XMLSchemaMetamodel = MM::W3Org2001XMLSchema
+
+env = RGen::Environment.new
+mm = XMLSchemaMetamodel
+inst = RGen::XSD::XSDInstantiator.new(env, mm)
+
+ARGV.each do |fn|
+  inst.instantiate(fn)
+end
+
+problems = []
+inst.resolve(problems)
+
+if problems.size > 0
+  problems.each do |p|
+    puts p
+  end
+  puts "#{problems.size} problems, stop."
+  exit
+end
+
+require "rgen/xsd/xml_schema_metamodel_ext"
+require "rgen/xsd/xsd_to_ecore"
+
+sch = env.find(:class => XMLSchemaMetamodel::Element, :name => "schema").first
+
+env_ecore = RGen::Environment.new
+trans = RGen::XSD::XSDToEcoreTransformer.new(env, env_ecore)
+root = trans.transform
+
+class_complexType = env_ecore.find(:class => RGen::ECore::EClass, :name => "ComplexType").first
+class_simpleType = env_ecore.find(:class => RGen::ECore::EClass, :name => "SimpleType").first
+class_element = env_ecore.find(:class => RGen::ECore::EClass, :name => "Element").first
+class_group = env_ecore.find(:class => RGen::ECore::EClass, :name => "Group").first
+class_attribute = env_ecore.find(:class => RGen::ECore::EClass, :name => "Attribute").first
+class_attributeGroup = env_ecore.find(:class => RGen::ECore::EClass, :name => "AttributeGroup").first
+
+# insert Type class as supertype of ComplexType and SimpleType
+class_type = env_ecore.new(RGen::ECore::EClass, :name => "Type", :ePackage => class_complexType.ePackage,
+  :eSuperTypes => class_complexType.eSuperTypes)
+class_complexType.eSuperTypes = [class_type]
+class_simpleType.eSuperTypes = [class_type]
+
+# explicit references
+attribute_to_reference(env_ecore, "RestrictionType#base", class_type)
+attribute_to_reference(env_ecore, "RestrictionTYPE#base", class_type)
+attribute_to_reference(env_ecore, "ExtensionType#base", class_type)
+attribute_to_reference(env_ecore, "Element#ref", class_element)
+attribute_to_reference(env_ecore, "Element#type", class_type)
+attribute_to_reference(env_ecore, "Group#ref", class_group)
+attribute_to_reference(env_ecore, "AttributeGroup#ref", class_attributeGroup)
+attribute_to_reference(env_ecore, "Attribute#ref", class_attribute)
+attribute_to_reference(env_ecore, "Attribute#type", class_simpleType)
+attribute_to_reference(env_ecore, "Element#substitutionGroup", class_element)
+attribute_to_reference(env_ecore, "ListTYPE#itemType", class_simpleType)
+attribute_to_reference(env_ecore, "UnionTYPE#memberTypes", class_simpleType)
+
+# bidirectional references
+create_opposite(env_ecore, "Element#substitutionGroup", "substitutes", -1)
+create_opposite(env_ecore, "Element#complexType", "containingElement", 1)
+create_opposite(env_ecore, "Element#simpleType", "containingElement", 1)
+create_opposite(env_ecore, "Attribute#simpleType", "containingAttribute", 1)
+
+include MMGen::MetamodelGenerator
+generateMetamodel(root, options[:outfile])
+

data/lib/rgen/xsd/metamodel_modification_helper.rb

@@ -0,0 +1,41 @@
+module RGen
+
+module XSD
+
+module MetamodelModificationHelper
+
+def find_feature(env, desc)
+  env.find(:class => RGen::ECore::EStructuralFeature, :name => desc.split("#").last).
+    find{|f| f.eContainingClass.name == desc.split("#").first}
+end
+
+def attribute_to_reference(env, desc, target)
+  a = find_feature(env, desc)
+  r = env.new(RGen::ECore::EReference, Hash[
+    RGen::ECore::EStructuralFeature.ecore.eAllStructuralFeatures.collect do |f| 
+      next if f.derived
+      p = [f.name, a.getGeneric(f.name)]
+      if f.many
+        a.setGeneric(f.name, [])
+      else
+        a.setGeneric(f.name, nil)
+      end
+      p
+    end])
+  r.eType = target
+  r
+end
+
+def create_opposite(env, desc, name, upper_bound)
+  r = find_feature(env, desc)
+  r.eOpposite = 
+    env.new(RGen::ECore::EReference, :name => name, :eType => r.eContainingClass, 
+      :eContainingClass => r.eType, :upperBound => upper_bound, :eOpposite => r)
+end
+
+end
+
+end
+
+end
+

data/lib/rgen/xsd/particle.rb

@@ -0,0 +1,169 @@
+module RGen
+module XSD
+module Particle
+
+# helper structure representing a particle or particle tree
+# particles of kind :choice, :sequence or :all can have child particles
+Particle = Struct.new(:kind, :children, :minOccurs, :maxOccurs, :node)
+
+# builds a flat list of the element particles contained in +node+
+# to be used for ComplexType and complex content extensions 
+def element_particles(node)
+  trees = build_particles_trees(node)
+  if trees.size == 1
+    flatten_particle_tree(trees.first)
+  elsif trees.size > 1
+    puts "WARN: only one particle expected as a content model"
+    []
+  else
+    []
+  end
+end
+
+def add_substitution_particles(particles)
+  result = []
+  particles.each do |p|
+    result << p
+    if p.kind == :element
+      p.node.substitutes.each do |s|
+        result << Particle.new(:element, [], p.minOccurs, p.maxOccurs, s)
+      end
+    end
+  end
+  result
+end
+
+# flattens the particle tree with root +particle+ and calculates min/max occurrence
+# returns a list of particles of kind "element" and "any"
+# element names are unique throughout the list
+# the order is the order of first occurrence
+def flatten_particle_tree(particle)
+  if particle.kind == :element || particle.kind == :any
+    [particle]
+  else 
+    eocc = {}
+    elist = []
+    particle.children.each do |c|
+      flatten_particle_tree(c).each do |e|
+        if e.kind == :element
+          name = e.node.name
+        else
+          name = "#any#" 
+        end
+        if !eocc[name]
+          eocc[name] = [] 
+          elist << name
+        end
+        eocc[name] << e
+      end
+    end
+    is_unbounded = lambda do |particle, elements|
+      (particle.maxOccurs == "unbounded" && 
+        elements.any?{|e| e.maxOccurs == "unbounded" || e.maxOccurs.to_i > 0}) ||
+        (particle.maxOccurs.to_i > 0 &&
+        elements.any?{|e| e.maxOccurs == "unbounded"})
+    end
+    if particle.kind == :choice
+      elist.collect do |n|
+        if eocc[n].size < particle.children.size
+          # element is not in every choice
+          min = 0
+        else
+          min = eocc[n].collect{|e| e.minOccurs.to_i}.min * particle.minOccurs.to_i
+        end
+        if is_unbounded.call(particle, eocc[n])
+          max = "unbounded"
+        else
+          max = eocc[n].collect{|e| e.maxOccurs.to_i}.max * particle.maxOccurs.to_i
+        end
+        if n == "#any#"
+          Particle.new(:any, [], min, max, eocc[n].first.node)
+        else
+          Particle.new(:element, [], min, max, eocc[n].first.node)
+        end
+      end
+    else # sequence or all
+      elist.collect do |n|
+        min = eocc[n].inject(0){|m, e| m + e.minOccurs.to_i} * particle.minOccurs.to_i
+        if is_unbounded.call(particle, eocc[n])
+          max = "unbounded"
+        else
+          max = eocc[n].inject(0){|m, e| m + e.maxOccurs.to_i} * particle.maxOccurs.to_i
+        end
+        if n == "#any#"
+          Particle.new(:any, [], min, max, eocc[n].first.node)
+        else
+          Particle.new(:element, [], min, max, eocc[n].first.node)
+        end
+      end
+    end
+  end
+end
+
+# builds the particle trees for the particles contained in node
+def build_particles_trees(node)
+  trees = []
+  # ComplexType and extension type have only one choice, sequence, all, group
+  choices = node.choice
+  choices = [choices].compact unless choices.is_a?(Array)
+  choices.each do |c|
+    trees << Particle.new(:choice, build_particles_trees(c), c.minOccurs || "1", c.maxOccurs || "1", c)
+  end
+  sequences = node.sequence
+  sequences = [sequences].compact unless sequences.is_a?(Array)
+  sequences.each do |s|
+    trees << Particle.new(:sequence, build_particles_trees(s), s.minOccurs || "1", s.maxOccurs || "1", s)
+  end
+  alls = node.all
+  alls = [alls].compact unless alls.is_a?(Array)
+  alls.each do |a|
+    trees << Particle.new(:all, build_particles_trees(s), a.minOccurs || "1", a.maxOccurs || "1", a)
+  end
+  # Group definitions don't have group reference particles
+  if node.respond_to?(:group)
+    groups = node.group
+    groups = [groups].compact unless groups.is_a?(Array)
+    groups.each do |g|
+      if g.ref
+        # the referenced group is a Model Group Definition, i.e. a node wrapping a Model Group
+        # it must contain at most one of Choice, Sequence, All
+        # it must not contain another "group" tag because this would be a particle
+        group_childs = g.ref.all + g.ref.choice + g.ref.sequence
+        if group_childs.size == 1
+          gtc = build_particles_trees(g.ref).first
+          gtc.minOccurs = g.minOccurs || "1"
+          gtc.maxOccurs = g.maxOccurs || "1"
+          trees << gtc
+        elsif group_childs.size > 1
+          puts "WARN: ignoring model group definition containing more than one model group"
+        else
+          # empty, ignore
+        end
+      else
+        puts "WARN: ignoring non-toplevel group without a ref"
+      end
+    end
+  end
+  # ComplexType and complex content extension don't have element particles
+  if node.respond_to?(:element)
+    node.element.each do |e|
+      if e.ref
+        trees << Particle.new(:element, [], e.minOccurs || "1", e.maxOccurs || "1", e.ref)
+      else
+        trees << Particle.new(:element, [], e.minOccurs || "1", e.maxOccurs || "1", e)
+      end
+    end
+  end
+  # ComplexType and complex content extension don't have 'any' particles
+  if node.respond_to?(:any)
+    node.any.each do |a|
+      trees << Particle.new(:any, [], a.minOccurs || "1", a.maxOccurs || "1", a)
+    end
+  end
+  trees
+end
+
+end
+end
+end
+

data/lib/rgen/xsd/simple_type.rb

@@ -0,0 +1,87 @@
+module RGen
+module XSD
+module SimpleType
+
+SimpleType = Struct.new(:type, :isList, :minOccurs, :maxOccurs)
+
+def build_type_desc(type)
+  builtin = builtin_type(type)
+  if builtin
+    builtin 
+  elsif type.respond_to?(:list) && type.list 
+    if type.list.itemType || type.list.simpleType
+      td = build_type_desc(type.list.itemType || type.list.simpleType)
+      td.isList = true
+      td.minOccurs = 0
+      td.maxOccurs = -1
+      td
+    else
+      puts "WARN: list type without an item type"
+      SimpleType.new(:string, false, 0, 1)
+    end
+  elsif type.respond_to?(:union) && type.union
+    # TODO
+    # (type.union.memberTypes + type.union.simpleType).each do |t|
+    #   build_type_desc(t)
+    # end
+    # TODO: make this a string instead? otherwise there is a problem serializing with RText (could also be fixed in RText: o.to_s)
+    SimpleType.new(:object, false, 0, 1)
+  elsif type.respond_to?(:restriction) && type.restriction
+    if type.restriction.base
+      td = build_type_desc(type.restriction.base)
+      if td.type == :string && type.restriction.enumeration.size > 0
+        SimpleType.new(
+          type.restriction.enumeration.collect { |e| e.value },
+          false, 0, 1)
+      elsif td.isList
+        # assumption: restrictions are properly nested
+        # note: this doesn't work correctly in case of lists of lists
+        td.minOccurs = type.restriction.minLength.first.value.to_i if type.restriction.minLength.first
+        td.maxOccurs = type.restriction.maxLength.first.value.to_i if type.restriction.maxLength.first
+        td
+      else
+        # unhandled restriction, pass the original
+        td
+      end
+    else
+      puts "WARN: restriction type without a base type"
+      SimpleType.new(:string, false, 0, 1)
+    end  
+  else
+    puts "WARN: unknown node type: #{type.class}"
+    SimpleType.new(:string, false, 0, 1)
+  end
+end
+
+def builtin_type(type)
+  if type.nil?
+    # assumen anySimpleType
+    return SimpleType.new(:string, false, 0, 1)
+  end
+  case type.name
+  when "anyType"
+    SimpleType.new(:object, false, 0, 1)
+  when "anySimpleType", "string", "normalizedString", "token", "language", "Name", "NCName", 
+       "ID", "IDREF", "ENTITY", "NMTOKEN", "base64Binary", "hexBinary", "anyURI", "QName", 
+       "NOTATION", "duration", "dateTime", "time", "date", "gYearMonth", "gYear", "gMonthDay", 
+       "gDay", "gMonth" 
+    SimpleType.new(:string, false, 0, 1)
+  when "IDREFS", "ENTITIES", "NMTOKENS"
+    SimpleType.new(:string, true, 0, -1) 
+  when "float", "double"
+    SimpleType.new(:float, false, 0, 1)
+  when "decimal", "integer", "nonPositiveInteger", "negativeInteger", "long", "int", "short",
+       "byte", "nonNegativeInteger", "unsignedLong", "unsignedInt", "unsignedShort", 
+       "unsignedByte", "positiveInteger"
+    SimpleType.new(:int, false, 0, 1)
+  when "boolean"
+    SimpleType.new(:boolean, false, 0, 1)
+  else
+    nil
+  end
+end
+
+end
+end
+end
+

data/lib/rgen/xsd/xml/readme.txt

@@ -0,0 +1,6 @@
+This folder contains the following schema parts as published by the W3C
+
+* xml.xsd (http://www.w3.org/2007/08/xml.xsd)
+
+Copyright � 2007 World Wide Web Consortium, (Massachusetts Institute of Technology, European Research Consortium for Informatics and Mathematics, Keio University). All Rights Reserved. http://www.w3.org/Consortium/Legal/2002/copyright-documents-20021231
+

data/lib/rgen/xsd/xml/xml.xsd

@@ -0,0 +1,145 @@
+<?xml version='1.0'?>
+<xs:schema targetNamespace="http://www.w3.org/XML/1998/namespace" xmlns:xs="http://www.w3.org/2001/XMLSchema" xml:lang="en">
+
+ <xs:annotation>
+  <xs:documentation>
+   See http://www.w3.org/XML/1998/namespace.html and
+   http://www.w3.org/TR/REC-xml for information about this namespace.
+
+    This schema document describes the XML namespace, in a form
+    suitable for import by other schema documents.  
+
+    Note that local names in this namespace are intended to be defined
+    only by the World Wide Web Consortium or its subgroups.  The
+    following names are currently defined in this namespace and should
+    not be used with conflicting semantics by any Working Group,
+    specification, or document instance:
+
+    base (as an attribute name): denotes an attribute whose value
+         provides a URI to be used as the base for interpreting any
+         relative URIs in the scope of the element on which it
+         appears; its value is inherited.  This name is reserved
+         by virtue of its definition in the XML Base specification.
+
+    id   (as an attribute name): denotes an attribute whose value
+         should be interpreted as if declared to be of type ID.
+         This name is reserved by virtue of its definition in the
+         xml:id specification.
+
+    lang (as an attribute name): denotes an attribute whose value
+         is a language code for the natural language of the content of
+         any element; its value is inherited.  This name is reserved
+         by virtue of its definition in the XML specification.
+  
+    space (as an attribute name): denotes an attribute whose
+         value is a keyword indicating what whitespace processing
+         discipline is intended for the content of the element; its
+         value is inherited.  This name is reserved by virtue of its
+         definition in the XML specification.
+
+    Father (in any context at all): denotes Jon Bosak, the chair of 
+         the original XML Working Group.  This name is reserved by 
+         the following decision of the W3C XML Plenary and 
+         XML Coordination groups:
+
+             In appreciation for his vision, leadership and dedication
+             the W3C XML Plenary on this 10th day of February, 2000
+             reserves for Jon Bosak in perpetuity the XML name
+             xml:Father
+  </xs:documentation>
+ </xs:annotation>
+
+ <xs:annotation>
+  <xs:documentation>This schema defines attributes and an attribute group
+        suitable for use by
+        schemas wishing to allow xml:base, xml:lang, xml:space or xml:id
+        attributes on elements they define.
+
+        To enable this, such a schema must import this schema
+        for the XML namespace, e.g. as follows:
+        &lt;schema . . .>
+         . . .
+         &lt;import namespace="http://www.w3.org/XML/1998/namespace"
+                    schemaLocation="http://www.w3.org/2001/xml.xsd"/>
+
+        Subsequently, qualified reference to any of the attributes
+        or the group defined below will have the desired effect, e.g.
+
+        &lt;type . . .>
+         . . .
+         &lt;attributeGroup ref="xml:specialAttrs"/>
+ 
+         will define a type which will schema-validate an instance
+         element with any of those attributes</xs:documentation>
+ </xs:annotation>
+
+ <xs:annotation>
+  <xs:documentation>In keeping with the XML Schema WG's standard versioning
+   policy, this schema document will persist at
+   http://www.w3.org/2007/08/xml.xsd.
+   At the date of issue it can also be found at
+   http://www.w3.org/2001/xml.xsd.
+   The schema document at that URI may however change in the future,
+   in order to remain compatible with the latest version of XML Schema
+   itself, or with the XML namespace itself.  In other words, if the XML
+   Schema or XML namespaces change, the version of this document at
+   http://www.w3.org/2001/xml.xsd will change
+   accordingly; the version at
+   http://www.w3.org/2007/08/xml.xsd will not change.
+  </xs:documentation>
+ </xs:annotation>
+
+ <xs:attribute name="lang">
+  <xs:annotation>
+   <xs:documentation>Attempting to install the relevant ISO 2- and 3-letter
+         codes as the enumerated possible values is probably never
+         going to be a realistic possibility.  See
+         RFC 3066 at http://www.ietf.org/rfc/rfc3066.txt and the IANA registry
+         at http://www.iana.org/assignments/lang-tag-apps.htm for
+         further information.
+
+         The union allows for the 'un-declaration' of xml:lang with
+         the empty string.</xs:documentation>
+  </xs:annotation>
+  <xs:simpleType>
+   <xs:union memberTypes="xs:language">
+    <xs:simpleType>    
+     <xs:restriction base="xs:string">
+      <xs:enumeration value=""/>
+     </xs:restriction>
+    </xs:simpleType>
+   </xs:union>
+  </xs:simpleType>
+ </xs:attribute>
+
+ <xs:attribute name="space">
+  <xs:simpleType>
+   <xs:restriction base="xs:NCName">
+    <xs:enumeration value="default"/>
+    <xs:enumeration value="preserve"/>
+   </xs:restriction>
+  </xs:simpleType>
+ </xs:attribute>
+
+ <xs:attribute name="base" type="xs:anyURI">
+  <xs:annotation>
+   <xs:documentation>See http://www.w3.org/TR/xmlbase/ for
+                     information about this attribute.</xs:documentation>
+  </xs:annotation>
+ </xs:attribute>
+ 
+ <xs:attribute name="id" type="xs:ID">
+  <xs:annotation>
+   <xs:documentation>See http://www.w3.org/TR/xml-id/ for
+                     information about this attribute.</xs:documentation>
+  </xs:annotation>
+ </xs:attribute>
+
+ <xs:attributeGroup name="specialAttrs">
+  <xs:attribute ref="xml:base"/>
+  <xs:attribute ref="xml:lang"/>
+  <xs:attribute ref="xml:space"/>
+  <xs:attribute ref="xml:id"/>
+ </xs:attributeGroup>
+
+</xs:schema>

data/lib/rgen/xsd/xml_schema_metamodel_ext.rb

@@ -0,0 +1,54 @@
+module XMLSchemaMetamodel
+
+module Element::ClassModule
+  def effectiveElement
+    ref || self
+  end
+  def effectiveType
+    e = effectiveElement
+    if e.getType && e.complexType
+      puts "WARN: element has both, a type reference and a contained type"
+    end
+    e.getType || e.complexType || e.simpleType
+  end
+end
+
+module Attribute::ClassModule
+  def effectiveAttribute
+    ref || self
+  end
+  def effectiveType
+    e = effectiveAttribute
+    if e.getType && e.simpleType
+      puts "WARN: attribute has both, a type reference and a contained type"
+    end
+    e.getType || e.simpleType
+  end
+end
+
+module ComplexType::ClassModule
+  def allAttributes
+    attribute + attributeGroup.allAttributes +
+      (complexContent.andand.extension.andand.allAttributes || []) +
+      (simpleContent.andand.extension.andand.allAttributes || [])
+  end
+end
+
+module ExtensionType::ClassModule
+  def allAttributes
+    attribute + attributeGroup.allAttributes
+  end
+end
+
+module AttributeGroup::ClassModule
+  def effectiveAttributeGroup
+    ref || self
+  end
+  def allAttributes
+    effectiveAttributeGroup.attribute
+  end
+end
+
+end
+
+