puppet 3.6.2 → 3.7.0

data/lib/puppet/vendor/pathspec/lib/pathspec/regexspec.rb

@@ -0,0 +1,17 @@
+require 'pathspec/spec'
+
+class RegexSpec < Spec
+  def initialize(regex)
+    @regex = Regexp.compile regex
+
+    super
+  end
+
+  def inclusive?
+    true
+  end
+
+  def match(path)
+    @regex.match(path) if @regex
+  end
+end

data/lib/puppet/vendor/pathspec/lib/pathspec/spec.rb

@@ -0,0 +1,14 @@
+class Spec
+  attr_reader :regex
+
+  def initialize(*_)
+  end
+
+  def match(files)
+    raise "Unimplemented"
+  end
+
+  def inclusive?
+    true
+  end
+end

data/lib/puppet/vendor/require_vendored.rb

@@ -5,3 +5,5 @@ require 'safe_yaml'
 require 'puppet/vendor/safe_yaml_patches'
 
 # The vendored library 'semantic' is loaded on demand.
+# The vendored library 'rgen' is loaded on demand.
+# The vendored library 'pathspec' is loaded on demand.

data/lib/puppet/vendor/rgen/CHANGELOG

@@ -0,0 +1,197 @@
+=0.1.0 (August 3rd, 2006)
+
+* First public release
+
+=0.2.0 (September 3rd, 2006)
+
+* Added model transformation language (Transformer)
+* Now RGen is distributed as a gem
+* More complete documentation
+
+=0.3.0 (October 9th, 2006)
+
+* Improved XML Instantiator (Namespaces, Resolver, Customization)
+* Added many_to_one builder method
+* Added attribute reflection to MMBase (one_attributes, many_attributes)
+* Added +copy+ method to Transformer
+* Added simple model dumper module
+* Fixed mmgen/mmgen.rb
+
+=0.4.0 (Aug 8th, 2007)
+
+* Added ECore metamodel and use it as the core metametamodel
+* Revised and extended MetamodelBuilder language
+* There is an ECore instance describing each metamodel built using MetamodelBuilder now
+* Metamodel generator is now ECore based
+* Added Ruby implementation of Boolean and Enum types
+* Switched XML Instantiator to xmlscan for performance reasons
+* Cleaned up instantiator file structure
+* Renamed RGen::XMLInstantiator into RGen::Instantiator::DefaultXMLInstantiator
+* Included xmlscan as a redistributed module
+* Added support for chardata within XML tags
+* Added (Enterprise Architect) XMI to ECore instantiator
+* Some minor fixes in NameHelper
+* Some fixes to template language
+* Added UML1.3 Metamodel
+* Added tranformation from UML1.3 to ECore
+
+=0.4.1 (Nov 25th, 2007)
+
+* Template language performance improvement
+* Bugfix: use true/false instead of symbols for boolean attribute default values in metamodel classes
+* Minor fixes on metamodel generator and ecore primitive type handling
+* Made transformer implementation non-recursive to prevent "stack level too deep" exception for large models
+* Minor fixes on EAInstantiator
+* Made transformer search for matching rules for superclasses 
+* Bugfix: Enums are now added to EPackages created using the "ecore" method on a module
+* Bugfix: Metamodel generator now writes enum names
+* Performance improvement: don't require ecore transformer every time someone calls "ecore"
+* Major performance improvement of template engine (no Regexps to check \n at end of line)
+* Major performance improvement: AbstractXMLInstantiator optionally controls the garbage collector
+* Major performance improvement: ERB templates are reused in metamodel_builder
+* Added delete method to Environment
+
+=0.4.2 (Mar 2nd, 2008)
+
+* Performance improvement: collection feature of array extension uses hashes now to speed up array union
+* Performance improvement: find on environment hashes elements by class
+* Extended Transformer to allow sharing of result maps between several Transformer instances
+* Bugfix: User defined upper bound values are no longer overwritten by -1 in all "many" metamodel builder methods
+
+=0.4.3 (Aug 12th, 2008)
+
+* Performance improvement: significant speed up of metamodel reverse registration
+* Bugfix: Use object identity for metamodel to-many add/remove methods
+* Bugfix: If expand's :for expression evaluates to nil an error is generated (silently used current context before)
+* Template language indentation string can be set on DirectoryTemplateContainer and with the "file" command
+
+=0.4.4 (Sep 10th, 2008)
+
+* Added "abstract" metamodel DSL command
+* Added ecore_ext.rb with convenience methods
+* Added XMI1.1 serializer, revised XMLSerializer super class
+
+=0.4.5 (Nov 17th, 2008)
+
+* Updated XMI1.1 serializer to support explicit placement of elements on content level of the XMI file
+
+=0.4.6 (Mar 1st, 2009)
+
+* Bugfix: expand :foreach silently assumed current context if :foreach evalutated to nil
+* Bugfix: fixed unit test for non-Windows plattforms (\r\n)
+* Bugfix: depending on the Ruby version and/or platform constants used in templates could not be resolved
+* Added automatic line ending detection (\n or \r\n) for template language +nl+ command
+
+=0.5.0 (Jun 8th, 2009)
+
+* Added ModelBuilder and ModelSerializer
+* Added template language "define_local" command
+* Added template language "evaluate" command
+* Fixed template language bug: indentation problem when expand continues a non-empty line
+* Fixed template language bug: template content expands several times when a template container is called recursively
+* Fixed template language bug: template resolution problem if a template file has the same name as a template directory
+* Cleaned up EA support
+* Added method to clear ecore metamodel reflection cache
+* Improved overriding of metamodel features in reopened classes
+
+=0.5.1 (Nov 10th, 2009)
+
+* Fixed metamodel builder bug: _register at one-side did not unregister from the element referenced by the old value
+* Added helper class for building simple model comparators
+
+=0.5.2 (Jun 13th, 2010)
+
+* Added has_many_attr to metamodel builder, support for "many" attributes
+* Added JSON support (json instantiator and serializer)
+* Added QualifiedNameResolver instantiation helper
+* Added reference proxy support
+* Added more generic access methods on metaclasses
+* Added ReferenceResolver resolver mixin
+* Fixed ecore xml instantiator and serializer to handle references to builtin datatypes correctly
+* Fixed bug in ecore xml serializer to not output references which are opposites of containment references
+
+=0.5.3 (Aug 13th, 2010)
+
+* Fixed string escaping in JSON instantiator and serializer
+* Fixed order of eClassifiers and eSubpackages within an EPackage created by reflection on a RGen module
+
+=0.5.4
+
+* Fixed undeterministic order of child elements in ModelSerializer
+* Fixed undeterministic order of attributes in XMI serializers
+* Fixed ModelSerializer to always serialize the to-one part of bidirectional 1:N references
+* Fixed ModelSerializer to add :as => in case of ambiguous child roles
+* Made JsonInstantiator search subpackages for unqualified class names
+
+=0.6.0
+
+* Added exception when trying to instantiate abstract class
+* Replaced xmlscan by dependency to nokogiri
+* Made RGen work with Ruby 1.9
+* Cleaned up intermediate attribute and reference description, improvement of metamodel load time
+* Added optional data property for MMProxy
+* Added ECoreToRuby which can create Ruby classes and modules from ECore models in memory (without metamodel generator)
+* Refactored out QualifiedNameProvider and OppositeReferenceFilter
+* Added model fragment/fragmented models support
+* Extended Instantiator::ReferenceResolver and changed it into a class
+* Moved utilities into util folder/module
+* Added FileCacheMap
+* Fixed template language bug: indenting not correct after callback into same template container and iinc/idec
+* Added support for fragmented models
+* Added FileChangeDetector utility
+* Added CachedGlob utility
+* Added index parameter to model element add methods
+* Added MMGeneric
+* Modified has_many_attr to allow the same value in the same attribute multiple times 
+* Made Environment#delete faster on large models
+* Added type check of ecore defaultValueLiteral content in MetamodelBuilder
+* Many-feature setters can work with an Enumerable instead of an Array
+* Added pattern matcher utility
+* Fixed problem of Ruby hanging when exceptions occur
+* Fixed metamodel generator to quote illegal enum literal symbols
+* Imporved UML to ECore transformer and EA support
+
+=0.6.1
+
+* Fixed metamodel builder to not overwrite a model element's 'class' method
+* Added enum type transformation to ECoreToUML13 transformer, primitive type mapping based on instanceClassName
+* Fixed default value appearing on read after setting a feature value to nil
+* Added eIsSet and eUnset methods
+* Added eContainer and eContainingFeature methods
+* Fixed ModelFragment#elements not containing root elements
+* Added optional output of invalidation reason to FileCacheMap#load_data
+
+=0.6.2
+
+* Made qualified name provider work with unidirectional containment references
+* Fixed array_extension breaking the Hash[] method
+
+=0.6.3
+
+* Added BigDecimal support
+
+=0.6.4
+
+* Made FileChangeDetector and FileCacheMap robust against missing files
+
+=0.6.5
+
+* Fixed missing default argument of FragmentedModel#resolve
+* Added to_str to methods which aren't forwarded by array extension on empty arrays
+
+=0.6.6
+
+* Added ModelFragment#mark_resolved and ResolutionHelper
+* Added ReferenceResolver option to output failed resolutions
+* Major performance improvement of FragmentedModel#resolve
+* Fixed a Ruby 2.0 related warning
+
+=0.7.0
+
+* Enforce unique container rule by automatically disconnecting elements from other containers
+* Added support for long typed values (ELong), thanks to Thomas Hallgren;
+  Note that this is merely an EMF compatibility thing, RGen could already handle big integers before
+* Added eContents and eAllContents methods
+* Added setNilOrRemoveGeneric and setNilOrRemoveAllGeneric methods
+* Added disconnectContainer method
+

data/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/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/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/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/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/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).
+