puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/rgen/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Martin Thiede
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/rgen/PUPPET_README.md

@@ -0,0 +1,6 @@
+RGen - Ruby Modelling and Generator Framework
+=============================================
+
+RGen version 0.7.0
+
+Copied from https://github.com/mthiede/rgen/tree/3e3c42a470269982ef52972bed82d65f78de496c

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/rgen/README.rdoc

@@ -0,0 +1,78 @@
+= RGen - Ruby Modelling and Generator Framework
+
+RGen is a framework for Model Driven Software Development (MDSD)in Ruby.
+This means that it helps you build Metamodels, instantiate Models, modify
+and transform Models and finally generate arbitrary textual content from it.
+
+RGen features include:
+* Supporting Ruby 1.8.6, 1.8.7 and 1.9.x
+* Metamodel definition language (internal Ruby DSL)
+* ECore Meta-metamodel with an ECore instance available for every Metamodel
+* Generator creating the Ruby metamodel definition from an ECore instance
+* Transformer creating Ruby metamodel classes/modules from an ECore instance
+* Instantiation of Metamodels, i.e. creation of Models (e.g. from XML)
+* Model builder, internal Ruby DSL
+* Model fragmentation over several several files and per-fragment caching
+* Model Transformation language (internal Ruby DSL)
+* Powerful template based generator language (internal Ruby DSL inside of ERB)
+* UML 1.3 metamodel and XMI 1.1 instantiator included
+* ECore XML support (XMI 2.0)
+* UML-to-ECore and ECore-to-UML transformation (UML class models)
+* Enterprise Architect support (UML1.3/XMI1.1) 
+
+
+== Download
+
+Get the latest release from Github: https://github.com/mthiede/rgen
+
+
+== Installation
+
+Install RGen as a Ruby gem:
+
+  gem install rgen
+
+
+== Running the Tests 
+
+Change to the 'test' folder and run the test suite:
+
+  cd test
+  ruby rgen_test.rb
+
+
+== Documentation
+
+RDoc documentation is available at Github: http://mthiede.github.com/rgen/
+
+Find the main documentation parts for:
+* RGen::MetamodelBuilder
+* RGen::Transformer
+* RGen::TemplateLanguage
+* RGen::Fragment::FragmentedModel
+
+
+== Examples
+
+There are several examples of using RGen within the framework itself.
+
+Metamodel Definition:
+  lib/rgen/ecore/ecore.rb
+  lib/metamodels/uml13_metamodel.rb
+
+Instantiation:
+  lib/rgen/instantiator/xmi11_instantiator.rb
+  lib/rgen/instantiator/ecore_xml_instantiator.rb
+  
+Transformations:
+  lib/rgen/ecore/ruby_to_ecore.rb
+  lib/transformers/uml13_to_ecore.rb
+  
+Generators:
+  lib/mmgen/metamodel_generator.rb
+
+  
+== License
+
+RGen is released under the MIT license.
+

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/rgen/Rakefile

@@ -0,0 +1,41 @@
+require 'rubygems/package_task'
+require 'rdoc/task'
+
+RGenGemSpec = Gem::Specification.new do |s|
+  s.name = %q{rgen}
+  s.version = "0.7.0"
+  s.date = Time.now.strftime("%Y-%m-%d")
+  s.summary = %q{Ruby Modelling and Generator Framework}
+  s.email = %q{martin dot thiede at gmx de}
+  s.homepage = %q{http://ruby-gen.org}
+  s.rubyforge_project = %q{rgen}
+  s.description = %q{RGen is a framework for Model Driven Software Development (MDSD) in Ruby. This means that it helps you build Metamodels, instantiate Models, modify and transform Models and finally generate arbitrary textual content from it.}
+  s.authors = ["Martin Thiede"]
+  gemfiles = Rake::FileList.new
+  gemfiles.include("{lib,test}/**/*")
+  gemfiles.include("README.rdoc", "CHANGELOG", "MIT-LICENSE", "Rakefile") 
+  gemfiles.exclude(/\b\.bak\b/)
+  s.files = gemfiles
+  s.rdoc_options = ["--main", "README.rdoc", "-x", "test", "-x", "metamodels", "-x", "ea_support/uml13*"]
+  s.extra_rdoc_files = ["README.rdoc", "CHANGELOG", "MIT-LICENSE"]
+end
+
+RDoc::Task.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "CHANGELOG", "MIT-LICENSE", "lib/**/*.rb")
+  rd.rdoc_files.exclude("lib/metamodels/*")
+  rd.rdoc_files.exclude("lib/ea_support/uml13*")
+  rd.rdoc_dir = "doc"
+end
+
+RGenPackageTask = Gem::PackageTask.new(RGenGemSpec) do |p|
+  p.need_zip = false
+end	
+
+task :prepare_package_rdoc => :rdoc do
+  RGenPackageTask.package_files.include("doc/**/*")
+end
+
+task :release => [:prepare_package_rdoc, :package]
+
+task :clobber => [:clobber_rdoc, :clobber_package]

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/rgen/TODO

@@ -0,0 +1,41 @@
+=Known Bugs
+* <% expand ... :indent => 0 %> seems to change behaviour of active template not only expanded subtemplate
+* Ecore build in types (EString, ...) do not work in ECore instantiator, define your own EDatatype instead
+* ECore datatypes in RGen::ECore should use Java like instanceClassNames
+* overloading of transformation rules not working correctly
+* with \r\n in templates, empty lines appear in output
+* <%nl%> after <%nows%> creates no indentation (<%nl%> in another template in same file)
+
+=Major issues 
+* XML instantiator documentation
+* revise builder datatypes, especially enum implementation using Enum objects as types, 
+  also revise ecore metamodel at this point
+* revise documentation of BuilderExtensions
+* further cleanup EA UML import/export
+  - The differences between EA UML and uml13_metamodel.rb seem to be violations by EA, ArgoUML follows the standard much more closely
+  - Enums should be instances of Enumeration class with EnumerationLiterals (UML Standard), 
+    for EA convert to Classes with stereotype "enumeration" and attributes as literals 
+    (this is what EA 7 creates when clicking on the "New Enumeration" button, EA will reference these classes as type)
+    This is whats missing for Pragma MM generators.
+  - Support primitive types as instances of DataType (which basically have a name) instead of tagged values
+    (this should also be working with EA 7, the tagged values are just add on)
+  - Support more UML metamodel features in the transformers
+* Model Serializer:
+  - make "name" attribute configurable
+  - convert chars in string into something Ruby compatible (e.g newline to \n)
+
+=Minor Issues
+* allow definition of templates from within regular code
+* indexed find in environment
+* XMI Instantiator fixmap: add element names to make feature names unique
+* no error for expand '..', :forach => (foreach misspelled)
+* With JRuby (1.3.1) exceptions raised in templates have a short or no backtrace
+
+
+* extended constraint checks (feature bounds)
+* class filter in RText language
+* root classes for RText language
+* command/class aliases in RText language
+* language variants (different root classes depending on file type)
+* reference name in reference_qualifier
+

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/rgen/anounce.txt

@@ -0,0 +1,61 @@
+=RGen - Ruby Modelling and Generator Framework
+
+RGen is a framework to support the "Model Driven Software Development (MDSD)" approach. Some people may want to call just about the same thing "Domain Specific Languages".
+
+The essence is to have a Metamodel which imposes a structure as well as certain other constraints on the Models to be instantiated from it. The Metamodel can be part of the software which is being developed.
+From a formal language point of view, the metamodel could be regarded as a grammer with the model being a sentence of the grammer.
+
+One possible application of MDSD are large domain specific software systems like banking systems. In this case one would define a metamodel which reflects the application domain (e.g. accounts, customers, their relations, ...).
+The metamodel can then serve as a common means of communication between users from the application domain (e.g. the customer) and software developers, as well as between software developers working on different subsystems. In addition, the metamodel can be used to generate recurring parts of the software instead of writing it by hand
+(e.g. database interfaces, application server glue code, etc). In a particular project a lot more usescases will typically show up.
+
+A very good framework implementing the MDSD approach is the open source Java framework OpenArchitectureWare (http://www.openarchitectureware.org/). Actually OpenArchitectureWare inspired the development of RGen.
+
+RGen implements many features also provided by OpenArchitectureWare:
+* Programmatic (textual) definition of Metamodels
+* Instantiation of models from various sources (XML, UML Models, ...)
+* Support of Model Transformations
+* Powerful template language (based on ERB) to generate arbitrary textual content
+
+In contrast to the mentioned Java framework, RGen is a more lightweight approach.
+It can be used to write powerful generator or transformation scripts quickly.
+However I believe RGen can also be useful in large software development projects.
+
+
+Here are some example usecases of RGen:
+
+Example 1: Generating C Code from a XML description
+* Directly instantiate the XML file using RGen's XMLInstantiator
+  An implicit Metamodel (Ruby classes) will be created automatically
+  The model is now available as Ruby objects in memory
+* Use the template language to navigate the instantiated model and       generate C code
+
+Example 2: UML Defined Application specific Metamodel
+* Specify your metamodel as a UML Class Diagram
+* If the tool you use is Enterprise Architect, the UML Class Diagram can directly be instantiated using RGen's XMIClassInstantiator
+* If not, support for your tool should be added. The existing XMI instantiator is basically a transformation from an XMI model to an UML Class model. For a tool producing different XMI output the transformation has to be adapted.
+* Use the included MetamodelGenerator to generate Ruby classes from the UML model. These classes act as your application specific metamodel. Of course the generated classes can be extended by hand written code, either by subclassing or by just adding methods using Ruby's open classes. The generated code itself should not be touched.
+* Extend RGen with an own instantiator which reads your specific file format and instantiates your application specific metamodel
+* Then go on doing transformations on your model(s) or generate output.
+
+
+RGen could also be useful in combination with Rails.
+One application to Rails could be to generate not only the model, view and controller classes, but also the database schemas and code reflecting associations between Rails model elements (i.e. the has_many, belongs_to, .. code in the ActiveRecord subclasses)
+The base model for such a generation could be a description of the model elements and its associations as an UML class model.
+Another application could be to base new Rails generators (like the Login generator, etc) on RGen.
+
+
+=Major Performance Improvement
+
+RGen 0.4.1 features major performance improvements.
+All applications using the template language will be faster now.
+Applications using the AbstractXMLInstantiator can benefit if explicit garbage collection is enabled.
+(see documentation of AbstractXMLInstantiator)
+Another improvement makes the "ecore" class method of classes and modules much faster.
+Last but not least the loading of metamodels takes about half the time as before.
+
+For large models the metamodel generator is about 20 times faster.
+Reading a 50 000 lines ecore file now takes 9 seconds on a Centrino Duo 2GHz (85s with RGen 0.4.0)
+Generating the RGen metamodel code for the ecore model takes 5 seconds (200s with RGen 0.4.0)
+Requiring this RGen metamodel takes about 3 seconds (about 6s with RGen 0.4.0).
+

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/rgen/design_rationale.txt

@@ -0,0 +1,71 @@
+=ElementSet vs. Array
+
+Subject:
+Use a special array-like class "ElementSet" with the following properties:
+* can call methods of elements by . notation
+* can use all set and enumerable methods of Array
+* enforce constraints regarding type of elements
+* auto register/unregister with counterpart of an association
+
+Dependencies:
+* Without the constraint and register/unregister functionality of the ElementSet,
+  the API of model elements built by MetamodelBuilder has to be different:
+  instead of "e.myelements << newel" would be "e.addMyelements(newel)"
+  However this can also be an advantage (see Metamodel Many Assoc API)
+
+A1. ElementSet:
++ nice notation for calling methods of elements (.)
++ nice notation for adding/removing elements from a model element
+  (e.myelements << newel; e.myelements.delete newel)
+- complicated to realize
+  if ElementSet inherits from Array:
+  	constraints/registration can not be garanteed for all add/remove operations
+  	input and output of Array methods must be wrapped into ElementSet objects
+  if ElementSet delegates to an Array:
+    all (relevant) methods have to be delegated (methods from including
+    Enumerable do not automatically return ElementSet objects)
+- dot notation for calling methods of elements my lead to errors which are difficult
+  to find
+
+A2. Array:
++ a separate operator like >> makes calling methods of elements more explicit
++ very easy to implement
++ easy to understand by users (no "magic" going on)
+
+Decision: (2006-06-08)
+A2. Array
+Simplicity of implementation and ease of use are more important than a nice notation
+
+
+
+= Metamodel Many Assoc API
+
+Subject:
+How to implement the API to deal with to-many associations of model elements.
+One option is an array like object which is held by the model element for each to-many
+association and which is given to the user for modification (external array).
+The other option is an internal array which is only accessed via add and remove
+methods
+
+Dependencies:
+If an external array is used, this array must check the association's constraints
+and register/unregister with the other side of the association.
+(see ElementSet vs. Array)
+
+A1.External Array
++ nice API (e.myassocs << newel; e. myassocs.delete newel)
++ this is a Rails like API
+- a reference to the array might be stored somewhere else in the program and
+  accidentially be modified, this would modify the model element it belongs to
+  as well as register/unregister with other model elements leading to errors
+  which are hard to find
+- an external array is complicated to implement (see ElementSet vs. Array)
+
+A2.Internal Array
++ easy to understand for non Ruby/Rails aware users
++ simple implementation
+
+Decision: (2006-06-09)
+A2. Internal Array
+Simplicity of implementation and ease of use are more important than a nice notation
+ 

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/rgen/lib/ea_support/ea_support.rb

@@ -0,0 +1,54 @@
+require 'ea_support/uml13_ea_metamodel'
+require 'ea_support/uml13_ea_metamodel_ext'
+require 'ea_support/uml13_to_uml13_ea'
+require 'ea_support/uml13_ea_to_uml13'
+require 'ea_support/id_store'
+require 'rgen/serializer/xmi11_serializer'
+require 'rgen/instantiator/xmi11_instantiator'
+require 'rgen/environment'
+
+module EASupport
+  
+  FIXMAP = {
+    :tags => {
+      "EAStub" => proc { |tag, attr| 
+        UML13EA::Class.new(:name => attr["name"]) if attr["UMLType"] == "Class"
+      }
+    }
+  }
+  
+  INFO = XMI11Instantiator::INFO
+  WARN = XMI11Instantiator::WARN
+  ERROR = XMI11Instantiator::ERROR
+  
+  def self.instantiateUML13FromXMI11(envUML, fileName, options={})
+    envUMLEA = RGen::Environment.new
+    xmiInst = XMI11Instantiator.new(envUMLEA, FIXMAP, options[:loglevel] || ERROR)
+    xmiInst.add_metamodel("omg.org/UML1.3", UML13EA)
+    File.open(fileName) do |f|
+      xmiInst.instantiate(f.read)
+    end
+    trans = UML13EAToUML13.new(envUMLEA, envUML)
+    trans.transform
+    trans.cleanModel if options[:clean_model]
+  end
+
+  def self.serializeUML13ToXMI11(envUML, fileName, options={})
+    envUMLEA = RGen::Environment.new
+    
+    UML13EA.idStore = options[:keep_ids] ? 
+      IdStore.new(File.dirname(fileName)+"/"+File.basename(fileName)+".ids") : IdStore.new
+    
+    UML13ToUML13EA.new(envUML, envUMLEA).transform
+    
+    File.open(fileName, "w") do |f|
+      xmiSer = RGen::Serializer::XMI11Serializer.new(f)
+      xmiSer.setNamespace("UML","omg.org/UML1.3")
+      xmiSer.serialize(envUMLEA.find(:class => UML13EA::Model).first, 
+        {:documentation => {:exporter => "Enterprise Architect", :exporterVersion => "2.5"}})
+    end
+    
+    UML13EA.idStore.store
+  end
+  
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/rgen/lib/ea_support/id_store.rb

@@ -0,0 +1,32 @@
+require 'yaml'
+
+class IdStore
+  def initialize(fileName=nil)
+    if fileName
+      raise "Base directory does not exist: #{File.dirname(fileName)}" \
+        unless File.exist?(File.dirname(fileName))
+      @idsFileName = fileName
+    end
+    @idHash = nil
+  end
+  
+  def idHash
+    load unless @idHash
+    @idHash
+  end
+  
+  def load
+    if @idsFileName && File.exist?(@idsFileName)
+      @idHash = YAML.load_file(@idsFileName) || {}
+    else
+      @idHash = {}
+    end
+  end
+  
+  def store
+    return unless @idsFileName
+    File.open(@idsFileName,"w") do |f|
+      YAML.dump(@idHash, f)
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/vendor/rgen/lib/ea_support/uml13_ea_metamodel.rb

@@ -0,0 +1,562 @@
+require 'rgen/metamodel_builder'
+
+module UML13EA
+   extend RGen::MetamodelBuilder::ModuleExtension
+   include RGen::MetamodelBuilder::DataTypes
+
+   OperationDirectionKind = Enum.new(:name => 'OperationDirectionKind', :literals =>[ ])
+   MessageDirectionKind = Enum.new(:name => 'MessageDirectionKind', :literals =>[ ])
+   ChangeableKind = Enum.new(:name => 'ChangeableKind', :literals =>[ :changeable, :none, :addOnly ])
+   PseudostateKind = Enum.new(:name => 'PseudostateKind', :literals =>[ :initial, :deepHistory, :shallowHistory, :join, :fork, :branch, :junction, :final ])
+   ParameterDirectionKind = Enum.new(:name => 'ParameterDirectionKind', :literals =>[ :in, :inout, :out, :return ])
+   ScopeKind = Enum.new(:name => 'ScopeKind', :literals =>[ :instance, :classifier ])
+   OrderingKind = Enum.new(:name => 'OrderingKind', :literals =>[ :unordered, :ordered, :sorted ])
+   CallConcurrencyKind = Enum.new(:name => 'CallConcurrencyKind', :literals =>[ :sequential, :guarded, :concurrent ])
+   AggregationKind = Enum.new(:name => 'AggregationKind', :literals =>[ :none, :aggregate, :composite, :shared ])
+   VisibilityKind = Enum.new(:name => 'VisibilityKind', :literals =>[ :public, :protected, :private ])
+end
+
+class UML13EA::Expression < RGen::MetamodelBuilder::MMBase
+   has_attr 'language', String 
+   has_attr 'body', String 
+end
+
+class UML13EA::ActionExpression < UML13EA::Expression
+end
+
+class UML13EA::Element < RGen::MetamodelBuilder::MMBase
+end
+
+class UML13EA::ModelElement < UML13EA::Element
+   has_attr 'name', String 
+   has_attr 'visibility', UML13EA::VisibilityKind, :defaultValueLiteral => "public" 
+   has_attr 'isSpecification', Boolean 
+end
+
+class UML13EA::Namespace < UML13EA::ModelElement
+end
+
+class UML13EA::GeneralizableElement < UML13EA::ModelElement
+   has_attr 'isRoot', Boolean 
+   has_attr 'isLeaf', Boolean 
+   has_attr 'isAbstract', Boolean 
+end
+
+class UML13EA::Classifier < RGen::MetamodelBuilder::MMMultiple(UML13EA::GeneralizableElement, UML13EA::Namespace)
+end
+
+class UML13EA::ClassifierRole < UML13EA::Classifier
+end
+
+class UML13EA::PresentationElement < UML13EA::Element
+end
+
+class UML13EA::DiagramElement < UML13EA::PresentationElement
+   has_attr 'geometry', String 
+   has_attr 'style', String 
+end
+
+class UML13EA::Feature < UML13EA::ModelElement
+   has_attr 'ownerScope', UML13EA::ScopeKind, :defaultValueLiteral => "instance" 
+end
+
+class UML13EA::BehavioralFeature < UML13EA::Feature
+   has_attr 'isQuery', Boolean 
+end
+
+class UML13EA::Method < UML13EA::BehavioralFeature
+end
+
+class UML13EA::Actor < UML13EA::Classifier
+end
+
+class UML13EA::DataType < UML13EA::Classifier
+end
+
+class UML13EA::Primitive < UML13EA::DataType
+end
+
+class UML13EA::Action < UML13EA::ModelElement
+   has_attr 'isAsynchronous', Boolean 
+end
+
+class UML13EA::SendAction < UML13EA::Action
+end
+
+class UML13EA::Interface < UML13EA::Classifier
+end
+
+class UML13EA::Event < UML13EA::ModelElement
+end
+
+class UML13EA::ChangeEvent < UML13EA::Event
+end
+
+class UML13EA::Partition < UML13EA::ModelElement
+end
+
+class UML13EA::Comment < UML13EA::ModelElement
+   has_attr 'body', String 
+end
+
+class UML13EA::ProgrammingLanguageType < UML13EA::DataType
+end
+
+class UML13EA::StateMachine < UML13EA::ModelElement
+end
+
+class UML13EA::Call < RGen::MetamodelBuilder::MMBase
+end
+
+class UML13EA::Operation < UML13EA::BehavioralFeature
+   has_attr 'concurrency', UML13EA::CallConcurrencyKind, :defaultValueLiteral => "sequential" 
+   has_attr 'isRoot', Boolean 
+   has_attr 'isLeaf', Boolean 
+   has_attr 'isAbstract', Boolean 
+end
+
+class UML13EA::XmiIdProvider < RGen::MetamodelBuilder::MMBase
+end
+
+class UML13EA::StateVertex < RGen::MetamodelBuilder::MMMultiple(UML13EA::ModelElement, UML13EA::XmiIdProvider)
+end
+
+class UML13EA::SynchState < UML13EA::StateVertex
+   has_attr 'bound', Integer 
+end
+
+class UML13EA::ClassifierInState < UML13EA::Classifier
+end
+
+class UML13EA::Link < UML13EA::ModelElement
+end
+
+class UML13EA::ProcedureExpression < UML13EA::Expression
+end
+
+class UML13EA::CallEvent < UML13EA::Event
+end
+
+class UML13EA::AssignmentAction < UML13EA::Action
+end
+
+class UML13EA::Relationship < UML13EA::ModelElement
+end
+
+class UML13EA::Association < RGen::MetamodelBuilder::MMMultiple(UML13EA::GeneralizableElement, UML13EA::Relationship, UML13EA::XmiIdProvider)
+end
+
+class UML13EA::AssociationRole < UML13EA::Association
+end
+
+class UML13EA::Diagram < UML13EA::PresentationElement
+   has_attr 'name', String 
+   has_attr 'toolName', String 
+   has_attr 'diagramType', String 
+   has_attr 'style', String 
+end
+
+class UML13EA::MultiplicityRange < RGen::MetamodelBuilder::MMBase
+   has_attr 'lower', String 
+   has_attr 'upper', String 
+end
+
+class UML13EA::ActionSequence < UML13EA::Action
+end
+
+class UML13EA::Constraint < UML13EA::ModelElement
+end
+
+class UML13EA::Instance < UML13EA::ModelElement
+end
+
+class UML13EA::UseCaseInstance < UML13EA::Instance
+end
+
+class UML13EA::State < UML13EA::StateVertex
+end
+
+class UML13EA::CompositeState < UML13EA::State
+   has_attr 'isConcurrent', Boolean 
+end
+
+class UML13EA::SubmachineState < UML13EA::CompositeState
+end
+
+class UML13EA::SubactivityState < UML13EA::SubmachineState
+   has_attr 'isDynamic', Boolean 
+end
+
+class UML13EA::StructuralFeature < UML13EA::Feature
+   has_attr 'changeable', UML13EA::ChangeableKind, :defaultValueLiteral => "changeable" 
+   has_attr 'targetScope', UML13EA::ScopeKind, :defaultValueLiteral => "instance" 
+end
+
+class UML13EA::Attribute < UML13EA::StructuralFeature
+end
+
+class UML13EA::Flow < UML13EA::Relationship
+end
+
+class UML13EA::Class < RGen::MetamodelBuilder::MMMultiple(UML13EA::Classifier, UML13EA::XmiIdProvider)
+   has_attr 'isActive', Boolean 
+end
+
+class UML13EA::Guard < UML13EA::ModelElement
+end
+
+class UML13EA::CreateAction < UML13EA::Action
+end
+
+class UML13EA::IterationExpression < UML13EA::Expression
+end
+
+class UML13EA::ReturnAction < UML13EA::Action
+end
+
+class UML13EA::Parameter < UML13EA::ModelElement
+   has_attr 'kind', UML13EA::ParameterDirectionKind, :defaultValueLiteral => "inout" 
+end
+
+class UML13EA::Dependency < UML13EA::Relationship
+end
+
+class UML13EA::Binding < UML13EA::Dependency
+end
+
+class UML13EA::Package < RGen::MetamodelBuilder::MMMultiple(UML13EA::Namespace, UML13EA::GeneralizableElement, UML13EA::XmiIdProvider)
+end
+
+class UML13EA::ObjectSetExpression < UML13EA::Expression
+end
+
+class UML13EA::StubState < UML13EA::StateVertex
+   has_attr 'referenceState', String 
+end
+
+class UML13EA::Stereotype < UML13EA::GeneralizableElement
+   has_attr 'icon', String 
+   has_attr 'baseClass', String 
+end
+
+class UML13EA::Object < UML13EA::Instance
+end
+
+class UML13EA::LinkObject < RGen::MetamodelBuilder::MMMultiple(UML13EA::Link, UML13EA::Object)
+end
+
+class UML13EA::ComponentInstance < UML13EA::Instance
+end
+
+class UML13EA::Usage < UML13EA::Dependency
+end
+
+class UML13EA::SignalEvent < UML13EA::Event
+end
+
+class UML13EA::Structure < UML13EA::DataType
+end
+
+class UML13EA::AssociationEnd < RGen::MetamodelBuilder::MMMultiple(UML13EA::ModelElement, UML13EA::XmiIdProvider)
+   has_attr 'isNavigable', Boolean, :defaultValueLiteral => "false" 
+   has_attr 'isOrdered', Boolean, :defaultValueLiteral => "false" 
+   has_attr 'aggregation', UML13EA::AggregationKind, :defaultValueLiteral => "none" 
+   has_attr 'targetScope', UML13EA::ScopeKind, :defaultValueLiteral => "instance" 
+   has_attr 'changeable', UML13EA::ChangeableKind, :defaultValueLiteral => "changeable" 
+   has_attr 'multiplicity', String 
+end
+
+class UML13EA::AssociationEndRole < UML13EA::AssociationEnd
+end
+
+class UML13EA::Signal < UML13EA::Classifier
+end
+
+class UML13EA::Exception < UML13EA::Signal
+end
+
+class UML13EA::Extend < UML13EA::Relationship
+end
+
+class UML13EA::Argument < UML13EA::ModelElement
+end
+
+class UML13EA::TemplateParameter < RGen::MetamodelBuilder::MMBase
+end
+
+class UML13EA::PseudoState < UML13EA::StateVertex
+   has_attr 'kind', UML13EA::PseudostateKind, :defaultValueLiteral => "initial" 
+end
+
+class UML13EA::SimpleState < UML13EA::State
+end
+
+class UML13EA::ActionState < UML13EA::SimpleState
+   has_attr 'isDynamic', Boolean 
+end
+
+class UML13EA::TypeExpression < UML13EA::Expression
+end
+
+class UML13EA::DestroyAction < UML13EA::Action
+end
+
+class UML13EA::TerminateAction < UML13EA::Action
+end
+
+class UML13EA::Generalization < RGen::MetamodelBuilder::MMMultiple(UML13EA::Relationship, UML13EA::XmiIdProvider)
+   has_attr 'discriminator', String 
+end
+
+class UML13EA::FinalState < UML13EA::State
+end
+
+class UML13EA::Subsystem < RGen::MetamodelBuilder::MMMultiple(UML13EA::Package, UML13EA::Classifier)
+   has_attr 'isInstantiable', Boolean 
+end
+
+class UML13EA::TimeExpression < UML13EA::Expression
+end
+
+class UML13EA::TaggedValue < UML13EA::Element
+   has_attr 'tag', String 
+   has_attr 'value', String 
+end
+
+class UML13EA::DataValue < UML13EA::Instance
+end
+
+class UML13EA::Transition < UML13EA::ModelElement
+end
+
+class UML13EA::NodeInstance < UML13EA::Instance
+end
+
+class UML13EA::Component < UML13EA::Classifier
+end
+
+class UML13EA::Message < UML13EA::ModelElement
+end
+
+class UML13EA::Enumeration < UML13EA::DataType
+end
+
+class UML13EA::Reception < UML13EA::BehavioralFeature
+   has_attr 'isPolymorphic', Boolean 
+   has_attr 'specification', String 
+end
+
+class UML13EA::Include < UML13EA::Relationship
+end
+
+class UML13EA::CallState < UML13EA::ActionState
+end
+
+class UML13EA::ElementResidence < RGen::MetamodelBuilder::MMBase
+   has_attr 'visibility', UML13EA::VisibilityKind, :defaultValueLiteral => "public" 
+end
+
+class UML13EA::UninterpretedAction < UML13EA::Action
+end
+
+class UML13EA::ArgListsExpression < UML13EA::Expression
+end
+
+class UML13EA::Stimulus < UML13EA::ModelElement
+end
+
+class UML13EA::AssociationClass < RGen::MetamodelBuilder::MMMultiple(UML13EA::Class, UML13EA::Association)
+end
+
+class UML13EA::Node < UML13EA::Classifier
+end
+
+class UML13EA::ElementImport < RGen::MetamodelBuilder::MMBase
+   has_attr 'visibility', UML13EA::VisibilityKind, :defaultValueLiteral => "public" 
+   has_attr 'alias', String 
+end
+
+class UML13EA::BooleanExpression < UML13EA::Expression
+end
+
+class UML13EA::Collaboration < RGen::MetamodelBuilder::MMMultiple(UML13EA::GeneralizableElement, UML13EA::Namespace)
+end
+
+class UML13EA::CallAction < UML13EA::Action
+end
+
+class UML13EA::UseCase < UML13EA::Classifier
+end
+
+class UML13EA::ActivityModel < UML13EA::StateMachine
+end
+
+class UML13EA::Permission < UML13EA::Dependency
+end
+
+class UML13EA::Interaction < UML13EA::ModelElement
+end
+
+class UML13EA::EnumerationLiteral < RGen::MetamodelBuilder::MMBase
+   has_attr 'name', String 
+end
+
+class UML13EA::Model < UML13EA::Package
+end
+
+class UML13EA::LinkEnd < UML13EA::ModelElement
+end
+
+class UML13EA::ExtensionPoint < UML13EA::ModelElement
+   has_attr 'location', String 
+end
+
+class UML13EA::Multiplicity < RGen::MetamodelBuilder::MMBase
+end
+
+class UML13EA::ObjectFlowState < UML13EA::SimpleState
+   has_attr 'isSynch', Boolean 
+end
+
+class UML13EA::AttributeLink < UML13EA::ModelElement
+end
+
+class UML13EA::MappingExpression < UML13EA::Expression
+end
+
+class UML13EA::TimeEvent < UML13EA::Event
+end
+
+class UML13EA::Abstraction < UML13EA::Dependency
+end
+
+class UML13EA::ActionInstance < RGen::MetamodelBuilder::MMBase
+end
+
+
+UML13EA::ClassifierRole.contains_one_uni 'multiplicity', UML13EA::Multiplicity 
+UML13EA::ClassifierRole.has_many 'availableContents', UML13EA::ModelElement 
+UML13EA::ClassifierRole.has_many 'availableFeature', UML13EA::Feature 
+UML13EA::ClassifierRole.has_one 'base', UML13EA::Classifier, :lowerBound => 1 
+UML13EA::Diagram.contains_many 'element', UML13EA::DiagramElement, 'diagram' 
+UML13EA::Method.many_to_one 'specification', UML13EA::Operation, 'method' 
+UML13EA::Method.contains_one_uni 'body', UML13EA::ProcedureExpression 
+UML13EA::SendAction.has_one 'signal', UML13EA::Signal, :lowerBound => 1 
+UML13EA::ChangeEvent.contains_one_uni 'changeExpression', UML13EA::BooleanExpression 
+UML13EA::Partition.has_many 'contents', UML13EA::ModelElement 
+UML13EA::Comment.many_to_many 'annotatedElement', UML13EA::ModelElement, 'comment' 
+UML13EA::ProgrammingLanguageType.contains_one_uni 'type', UML13EA::TypeExpression 
+UML13EA::Action.contains_one_uni 'recurrence', UML13EA::IterationExpression 
+UML13EA::Action.contains_one_uni 'target', UML13EA::ObjectSetExpression 
+UML13EA::Action.contains_one_uni 'script', UML13EA::ActionExpression 
+UML13EA::Action.contains_many_uni 'actualArgument', UML13EA::Argument 
+UML13EA::StateMachine.many_to_one 'context', UML13EA::ModelElement, 'behavior' 
+UML13EA::StateMachine.contains_many_uni 'transitions', UML13EA::Transition 
+UML13EA::StateMachine.contains_one_uni 'top', UML13EA::State, :lowerBound => 1 
+UML13EA::Operation.one_to_many 'occurrence', UML13EA::CallEvent, 'operation' 
+UML13EA::ClassifierInState.has_one 'type', UML13EA::Classifier, :lowerBound => 1 
+UML13EA::ClassifierInState.has_many 'inState', UML13EA::State 
+UML13EA::Link.contains_many_uni 'connection', UML13EA::LinkEnd, :lowerBound => 2 
+UML13EA::Link.has_one 'association', UML13EA::Association, :lowerBound => 1 
+UML13EA::PresentationElement.many_to_many 'subject', UML13EA::ModelElement, 'presentation' 
+UML13EA::AssociationRole.contains_one_uni 'multiplicity', UML13EA::Multiplicity 
+UML13EA::AssociationRole.has_one 'base', UML13EA::Association 
+UML13EA::Diagram.has_one 'owner', UML13EA::ModelElement, :lowerBound => 1 
+UML13EA::ActionSequence.contains_many_uni 'action', UML13EA::Action 
+UML13EA::Constraint.contains_one_uni 'body', UML13EA::BooleanExpression 
+UML13EA::Constraint.many_to_many 'constrainedElement', UML13EA::ModelElement, 'constraint', :lowerBound => 1 
+UML13EA::SubactivityState.contains_one_uni 'dynamicArguments', UML13EA::ArgListsExpression 
+UML13EA::AssociationEnd.contains_many 'qualifier', UML13EA::Attribute, 'associationEnd' 
+UML13EA::Attribute.contains_one_uni 'initialValue', UML13EA::Expression 
+UML13EA::Flow.many_to_many 'source', UML13EA::ModelElement, 'sourceFlow' 
+UML13EA::Flow.many_to_many 'target', UML13EA::ModelElement, 'targetFlow' 
+UML13EA::Guard.contains_one_uni 'expression', UML13EA::BooleanExpression 
+UML13EA::CreateAction.has_one 'instantiation', UML13EA::Classifier, :lowerBound => 1 
+UML13EA::Namespace.contains_many 'ownedElement', UML13EA::ModelElement, 'namespace' 
+UML13EA::Parameter.contains_one_uni 'defaultValue', UML13EA::Expression 
+UML13EA::Parameter.many_to_many 'state', UML13EA::ObjectFlowState, 'parameter' 
+UML13EA::Parameter.has_one 'type', UML13EA::Classifier, :lowerBound => 1 
+UML13EA::Binding.has_many 'argument', UML13EA::ModelElement, :lowerBound => 1 
+UML13EA::Event.contains_many_uni 'parameters', UML13EA::Parameter 
+UML13EA::Dependency.many_to_many 'supplier', UML13EA::ModelElement, 'supplierDependency', :opposite_lowerBound => 1 
+UML13EA::Dependency.many_to_many 'client', UML13EA::ModelElement, 'clientDependency', :opposite_lowerBound => 1 
+UML13EA::Package.contains_many 'importedElement', UML13EA::ElementImport, 'package' 
+UML13EA::Classifier.contains_many 'feature', UML13EA::Feature, 'owner' 
+UML13EA::Stereotype.one_to_many 'extendedElement', UML13EA::ModelElement, 'stereotype' 
+UML13EA::Stereotype.has_many 'requiredTag', UML13EA::TaggedValue 
+UML13EA::ComponentInstance.has_many 'resident', UML13EA::Instance 
+UML13EA::SignalEvent.many_to_one 'signal', UML13EA::Signal, 'occurrence', :lowerBound => 1 
+UML13EA::Instance.contains_many_uni 'slot', UML13EA::AttributeLink 
+UML13EA::Instance.one_to_many 'linkEnd', UML13EA::LinkEnd, 'instance' 
+UML13EA::Instance.has_many 'classifier', UML13EA::Classifier, :lowerBound => 1 
+UML13EA::AssociationEndRole.has_many 'availableQualifier', UML13EA::Attribute 
+UML13EA::AssociationEndRole.has_one 'base', UML13EA::AssociationEnd 
+UML13EA::Extend.many_to_one 'extension', UML13EA::UseCase, 'extend' 
+UML13EA::Extend.contains_one_uni 'condition', UML13EA::BooleanExpression 
+UML13EA::Extend.has_many 'extensionPoint', UML13EA::ExtensionPoint, :lowerBound => 1 
+UML13EA::Extend.has_one 'base', UML13EA::UseCase, :lowerBound => 1 
+UML13EA::Argument.contains_one_uni 'value', UML13EA::Expression 
+UML13EA::TemplateParameter.has_one 'modelElement', UML13EA::ModelElement 
+UML13EA::TemplateParameter.has_one 'defaultElement', UML13EA::ModelElement 
+UML13EA::ActionState.contains_one_uni 'dynamicArguments', UML13EA::ArgListsExpression 
+UML13EA::GeneralizableElement.one_to_many 'specialization', UML13EA::Generalization, 'supertype' 
+UML13EA::GeneralizableElement.one_to_many 'generalization', UML13EA::Generalization, 'subtype' 
+UML13EA::StateVertex.one_to_many 'incoming', UML13EA::Transition, 'target', :opposite_lowerBound => 1 
+UML13EA::StateVertex.one_to_many 'outgoing', UML13EA::Transition, 'source', :opposite_lowerBound => 1 
+UML13EA::CompositeState.contains_many 'substate', UML13EA::StateVertex, 'container', :lowerBound => 1 
+UML13EA::ModelElement.contains_many 'taggedValue', UML13EA::TaggedValue, 'modelElement' 
+UML13EA::StructuralFeature.contains_one_uni 'multiplicity', UML13EA::Multiplicity 
+UML13EA::StructuralFeature.has_one 'type', UML13EA::Classifier, :lowerBound => 1 
+UML13EA::Transition.has_one 'trigger', UML13EA::Event 
+UML13EA::Transition.contains_one_uni 'effect', UML13EA::Action 
+UML13EA::Transition.contains_one_uni 'guard', UML13EA::Guard 
+UML13EA::NodeInstance.has_many 'resident', UML13EA::ComponentInstance 
+UML13EA::Component.contains_many 'residentElement', UML13EA::ElementResidence, 'implementationLocation' 
+UML13EA::Component.many_to_many 'deploymentLocation', UML13EA::Node, 'resident' 
+UML13EA::Message.has_one 'action', UML13EA::Action, :lowerBound => 1 
+UML13EA::Message.has_one 'communicationConnection', UML13EA::AssociationRole 
+UML13EA::Message.has_many 'predecessor', UML13EA::Message 
+UML13EA::Message.has_one 'receiver', UML13EA::ClassifierRole, :lowerBound => 1 
+UML13EA::Message.has_one 'sender', UML13EA::ClassifierRole, :lowerBound => 1 
+UML13EA::Message.has_one 'activator', UML13EA::Message 
+UML13EA::Interaction.contains_many 'message', UML13EA::Message, 'interaction', :lowerBound => 1 
+UML13EA::ModelElement.one_to_many 'elementResidence', UML13EA::ElementResidence, 'resident' 
+UML13EA::ModelElement.contains_many_uni 'templateParameter', UML13EA::TemplateParameter 
+UML13EA::ModelElement.one_to_many 'elementImport', UML13EA::ElementImport, 'modelElement' 
+UML13EA::Enumeration.contains_many_uni 'literal', UML13EA::EnumerationLiteral, :lowerBound => 1 
+UML13EA::Reception.many_to_one 'signal', UML13EA::Signal, 'reception' 
+UML13EA::Association.contains_many 'connection', UML13EA::AssociationEnd, 'association', :lowerBound => 2 
+UML13EA::Include.many_to_one 'base', UML13EA::UseCase, 'include' 
+UML13EA::Include.has_one 'addition', UML13EA::UseCase, :lowerBound => 1 
+UML13EA::Classifier.many_to_many 'participant', UML13EA::AssociationEnd, 'specification' 
+UML13EA::Classifier.one_to_many 'associationEnd', UML13EA::AssociationEnd, 'type' 
+UML13EA::Stimulus.has_one 'dispatchAction', UML13EA::Action, :lowerBound => 1 
+UML13EA::Stimulus.has_one 'communicationLink', UML13EA::Link 
+UML13EA::Stimulus.has_one 'receiver', UML13EA::Instance, :lowerBound => 1 
+UML13EA::Stimulus.has_one 'sender', UML13EA::Instance, :lowerBound => 1 
+UML13EA::Stimulus.has_many 'argument', UML13EA::Instance 
+UML13EA::State.contains_one_uni 'doActivity', UML13EA::Action 
+UML13EA::State.contains_many_uni 'internalTransition', UML13EA::Transition 
+UML13EA::State.has_many 'deferrableEvent', UML13EA::Event 
+UML13EA::State.contains_one_uni 'exit', UML13EA::Action 
+UML13EA::State.contains_one_uni 'entry', UML13EA::Action 
+UML13EA::Collaboration.has_one 'representedOperation', UML13EA::Operation 
+UML13EA::Collaboration.has_one 'representedClassifier', UML13EA::Classifier 
+UML13EA::Collaboration.has_many 'constrainingElement', UML13EA::ModelElement 
+UML13EA::Collaboration.contains_many 'interaction', UML13EA::Interaction, 'context' 
+UML13EA::CallAction.has_one 'operation', UML13EA::Operation, :lowerBound => 1 
+UML13EA::UseCase.has_many 'extensionPoint', UML13EA::ExtensionPoint 
+UML13EA::ActivityModel.contains_many_uni 'partition', UML13EA::Partition 
+UML13EA::Interaction.contains_many_uni 'link', UML13EA::Link 
+UML13EA::LinkEnd.has_one 'associationEnd', UML13EA::AssociationEnd, :lowerBound => 1 
+UML13EA::LinkEnd.has_one 'participant', UML13EA::Instance, :lowerBound => 1 
+UML13EA::BehavioralFeature.many_to_many 'raisedSignal', UML13EA::Signal, 'context' 
+UML13EA::BehavioralFeature.contains_many_uni 'parameter', UML13EA::Parameter 
+UML13EA::SubmachineState.has_one 'submachine', UML13EA::StateMachine, :lowerBound => 1 
+UML13EA::Multiplicity.contains_many_uni 'range', UML13EA::MultiplicityRange, :lowerBound => 1 
+UML13EA::ObjectFlowState.has_one 'type', UML13EA::Classifier, :lowerBound => 1 
+UML13EA::ObjectFlowState.has_one 'available', UML13EA::Parameter, :lowerBound => 1 
+UML13EA::AttributeLink.has_one 'value', UML13EA::Instance, :lowerBound => 1 
+UML13EA::AttributeLink.has_one 'attribute', UML13EA::Attribute, :lowerBound => 1 
+UML13EA::TimeEvent.contains_one_uni 'when', UML13EA::TimeExpression 
+UML13EA::Abstraction.contains_one_uni 'mapping', UML13EA::MappingExpression