puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/lib/puppet/vendor/rgen/test/util_test.rb

@@ -0,0 +1,5 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'util/file_cache_map_test'
+require 'util/pattern_matcher_test'
+

data/lib/puppet/vendor/rgen/test/xml_instantiator_test.rb

@@ -0,0 +1,160 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+require 'test/unit'
+require 'rgen/instantiator/default_xml_instantiator'
+require 'rgen/environment'
+require 'rgen/util/model_dumper'
+require 'xml_instantiator_test/simple_xmi_ecore_instantiator'
+require 'xml_instantiator_test/simple_ecore_model_checker'
+
+module EmptyMM
+end
+
+module DefaultMM
+  module MNS
+    class Room < RGen::MetamodelBuilder::MMBase; end
+  end
+  class Person < RGen::MetamodelBuilder::MMBase; end
+  Person.one_to_one 'personalRoom', MNS::Room, 'inhabitant'
+end
+
+class XMLInstantiatorTest < Test::Unit::TestCase
+
+  XML_DIR = File.join(File.dirname(__FILE__),"testmodel")
+  
+  include RGen::Util::ModelDumper
+  
+  class MyInstantiator < RGen::Instantiator::DefaultXMLInstantiator
+  
+    map_tag_ns "testmodel.org/myNamespace", DefaultMM::MNS
+    
+    def class_name(str)
+      camelize(str)
+    end
+    
+#    resolve :type do
+#      @env.find(:xmi_id => getType).first
+#    end
+  
+    resolve_by_id :personalRoom, :id => :getId, :src => :room
+    
+  end
+  
+  class PruneTestInstantiator < RGen::Instantiator::NodebasedXMLInstantiator
+    attr_reader :max_depth
+    
+    set_prune_level 2
+    
+    def initialize(env)
+      super(env)
+      @max_depth = 0
+    end
+    
+    def on_descent(node)
+    end
+    
+    def on_ascent(node)
+      calc_max_depth(node, 0)
+    end
+    
+    def calc_max_depth(node, offset)
+      if node.children.nil? || node.children.size == 0
+        @max_depth = offset if offset > @max_depth
+      else 
+        node.children.each do |c|
+          calc_max_depth(c, offset+1)
+        end
+      end
+    end
+  end
+  
+  module PruneTestMM
+  end
+  
+  def test_pruning
+    env = RGen::Environment.new
+    
+    # prune level 2 is set in the class body
+    inst = PruneTestInstantiator.new(env)
+    inst.instantiate_file(File.join(XML_DIR,"manual_testmodel.xml"))
+    assert_equal 2, inst.max_depth
+    
+    PruneTestInstantiator.set_prune_level(0)
+    inst = PruneTestInstantiator.new(env)
+    inst.instantiate_file(File.join(XML_DIR,"manual_testmodel.xml"))
+    assert_equal 5, inst.max_depth
+    
+    PruneTestInstantiator.set_prune_level(1)
+    inst = PruneTestInstantiator.new(env)
+    inst.instantiate_file(File.join(XML_DIR,"manual_testmodel.xml"))
+    assert_equal 1, inst.max_depth
+  end
+  
+  def test_custom
+    env = RGen::Environment.new
+    inst = MyInstantiator.new(env, DefaultMM, true)
+    inst.instantiate_file(File.join(XML_DIR,"manual_testmodel.xml"))
+    
+    house = env.find(:class => DefaultMM::MNS::House).first
+    assert_not_nil house
+    assert_equal 2, house.room.size
+    
+    rooms = env.find(:class => DefaultMM::MNS::Room)
+    assert_equal 2, rooms.size
+    assert_equal 0, (house.room - rooms).size
+    rooms.each {|r| assert r.parent == house}
+    tomsRoom = rooms.select{|r| r.name == "TomsRoom"}.first
+    assert_not_nil tomsRoom
+    
+    persons = env.find(:class => DefaultMM::Person)
+    assert_equal 4, persons.size
+    tom = persons.select{|p| p.name == "Tom"}.first
+    assert_not_nil tom
+    
+    assert tom.personalRoom == tomsRoom
+    
+    mpns = env.find(:class => DefaultMM::MultiPartName)
+    assert mpns.first.respond_to?("insideMultiPart")
+  end
+  
+  def test_default
+    env = RGen::Environment.new
+    inst = RGen::Instantiator::DefaultXMLInstantiator.new(env, EmptyMM, true)
+    inst.instantiate_file(File.join(XML_DIR,"manual_testmodel.xml"))
+    
+    house = env.find(:class => EmptyMM::MNS_House).first
+    assert_not_nil house
+    assert_equal 2, house.mNS_Room.size
+    assert_equal "before kitchen", remove_whitespace_elements(house.chardata)[0].strip
+    assert_equal "after kitchen", remove_whitespace_elements(house.chardata)[1].strip
+    assert_equal "after toms room", remove_whitespace_elements(house.chardata)[2].strip
+    
+    rooms = env.find(:class => EmptyMM::MNS_Room)
+    assert_equal 2, rooms.size
+    assert_equal 0, (house.mNS_Room - rooms).size
+    rooms.each {|r| assert r.parent == house}
+    tomsRoom = rooms.select{|r| r.name == "TomsRoom"}.first
+    assert_not_nil tomsRoom
+    assert_equal "within toms room", remove_whitespace_elements(tomsRoom.chardata)[0]
+    
+    persons = env.find(:class => EmptyMM::Person)
+    assert_equal 4, persons.size
+    tom = persons.select{|p| p.name == "Tom"}.first
+    assert_not_nil tom
+  end
+
+  def remove_whitespace_elements(elements)
+    elements.reject{|e| e.strip == ""} 
+  end
+
+  include SimpleECoreModelChecker
+  
+  def test_simle_xmi_ecore_instantiator
+    envECore = RGen::Environment.new
+    File.open(XML_DIR+"/ea_testmodel.xml") { |f|
+      SimpleXMIECoreInstantiator.new.instantiateECoreModel(envECore, f.read)
+    }
+    checkECoreModel(envECore)
+  end
+    
+end

data/lib/puppet/vendor/rgen/test/xml_instantiator_test/simple_ecore_model_checker.rb

@@ -0,0 +1,94 @@
+require 'rgen/ecore/ecore'
+
+# This "light" version of the ECore model checker is used to check the
+# model produced by the XMLInstantiatorTest only. 
+# 
+module SimpleECoreModelChecker			
+  include RGen::ECore
+  
+  def checkECoreModel(env)
+    
+    # check main package
+    mainPackage = env.elements.select {|e| e.is_a? EPackage and e.name == "HouseMetamodel"}.first
+    assert_not_nil mainPackage
+    
+    # check Rooms package
+    assert mainPackage.eSubpackages.is_a?(Array)
+    assert_equal 1, mainPackage.eSubpackages.size
+    assert mainPackage.eSubpackages[0].is_a?(EPackage)
+    roomsPackage = mainPackage.eSubpackages[0]
+    assert_equal "Rooms", roomsPackage.name
+    
+    # check main package classes
+    assert mainPackage.eClassifiers.is_a?(Array)
+    assert_equal 3, mainPackage.eClassifiers.size
+    assert mainPackage.eClassifiers.all?{|c| c.is_a?(EClass)}
+    houseClass = mainPackage.eClassifiers.select{|c| c.name == "House"}.first
+    personClass = mainPackage.eClassifiers.select{|c| c.name == "Person"}.first
+    meetingPlaceClass = mainPackage.eClassifiers.select{|c| c.name == "MeetingPlace"}.first
+    assert_not_nil houseClass
+    assert_not_nil personClass
+    assert_not_nil meetingPlaceClass
+    
+    # check Rooms package classes
+    assert roomsPackage.eClassifiers.is_a?(Array)
+    assert_equal 3, roomsPackage.eClassifiers.size
+    assert roomsPackage.eClassifiers.all?{|c| c.is_a?(EClass)}
+    roomClass = roomsPackage.eClassifiers.select{|c| c.name == "Room"}.first
+    kitchenClass = roomsPackage.eClassifiers.select{|c| c.name == "Kitchen"}.first
+    bathroomClass = roomsPackage.eClassifiers.select{|c| c.name == "Bathroom"}.first
+    assert_not_nil roomClass
+    assert_not_nil kitchenClass
+    assert_not_nil bathroomClass
+    
+    # check Room inheritance
+    assert kitchenClass.eSuperTypes.is_a?(Array)
+    assert_equal 2, kitchenClass.eSuperTypes.size
+    assert_equal roomClass.object_id, kitchenClass.eSuperTypes.select{|c| c.name == "Room"}.first.object_id
+    assert_equal meetingPlaceClass.object_id, kitchenClass.eSuperTypes.select{|c| c.name == "MeetingPlace"}.first.object_id
+    assert bathroomClass.eSuperTypes.is_a?(Array)
+    assert_equal 1, bathroomClass.eSuperTypes.size
+    assert_equal roomClass.object_id, bathroomClass.eSuperTypes[0].object_id
+    
+    # check House-Room "part of" association
+    assert houseClass.eAllContainments.eType.is_a?(Array)
+    assert_equal 1, houseClass.eAllContainments.eType.size
+    roomRef = houseClass.eAllContainments.first
+    assert_equal roomClass.object_id, roomRef.eType.object_id
+    assert_equal "room", roomRef.name
+    assert_equal 1, roomRef.lowerBound
+    assert_equal(-1, roomRef.upperBound)
+    assert_not_nil roomRef.eOpposite
+    assert_equal houseClass.object_id, roomRef.eOpposite.eType.object_id
+    
+    partOfRefs = roomClass.eReferences.select{|r| r.eOpposite && r.eOpposite.containment}
+    assert_equal 1, partOfRefs.size
+    assert_equal houseClass.object_id, partOfRefs.first.eType.object_id
+    assert_equal "house", partOfRefs.first.name
+    assert_equal roomRef.object_id, partOfRefs.first.eOpposite.object_id
+    
+    # check House OUT associations
+    assert houseClass.eReferences.is_a?(Array)
+    assert_equal 3, houseClass.eReferences.size
+    bathRef = houseClass.eReferences.find {|e| e.name == "bathroom"}
+    kitchenRef = houseClass.eReferences.find {|e| e.name == "kitchen"}
+    roomRef = houseClass.eReferences.find {|e| e.name == "room"}
+    assert_not_nil bathRef
+    assert_nil bathRef.eOpposite
+    assert_not_nil kitchenRef
+    assert_not_nil roomRef
+    assert_equal 1, kitchenRef.lowerBound
+    assert_equal 1, kitchenRef.upperBound
+    assert_equal 1, roomRef.lowerBound
+    assert_equal(-1, roomRef.upperBound)
+    
+    # check House IN associations
+    houseInRefs = env.find(:class => EReference, :eType => houseClass)
+    assert_equal 3, houseInRefs.size
+    homeEnd = houseInRefs.find{|e| e.name == "home"}
+    assert_not_nil homeEnd
+    assert_equal 0, homeEnd.lowerBound
+    assert_equal(-1, homeEnd.upperBound)
+    
+  end
+end

data/lib/puppet/vendor/rgen/test/xml_instantiator_test/simple_xmi_ecore_instantiator.rb

@@ -0,0 +1,53 @@
+require 'rgen/instantiator/default_xml_instantiator'
+require 'rgen/environment'
+require 'rgen/ecore/ecore'
+require 'xml_instantiator_test/simple_xmi_metamodel'
+
+# SimpleXMIECoreInstantiator demonstrates the usage of the DefaultXMLInstantiator.
+# It can be used to instantiate an ECore model from an XMI description
+# produced by Enterprise Architect.
+# 
+# Note however, that this is *not* the recommended way to read an EA model.
+# See EAInstantiatorTest for the clean way to do this.
+# 
+# This example shows how arbitrary XML content can be used to instantiate
+# an implicit metamodel. The resulting model is transformed into a simple
+# ECore model.
+# 
+# See XMLInstantiatorTest for an example of how to use this class.
+# 
+class SimpleXMIECoreInstantiator < RGen::Instantiator::DefaultXMLInstantiator
+  
+  map_tag_ns "omg.org/UML1.3", SimpleXMIMetaModel::UML
+  
+  resolve_by_id :typeClass, :src => :type, :id => :xmi_id
+  resolve_by_id :subtypeClass, :src => :subtype, :id => :xmi_id
+  resolve_by_id :supertypeClass, :src => :supertype, :id => :xmi_id
+  
+  def initialize
+    @envXMI = RGen::Environment.new 
+    super(@envXMI, SimpleXMIMetaModel, true)
+  end
+  
+  def new_object(node)
+    if node.tag == "EAStub"
+      class_name = saneClassName(node.attributes["UMLType"])
+      mod = XMIMetaModel::UML
+      build_on_error(NameError, :build_class, class_name, mod) do
+        mod.const_get(class_name).new
+      end	 
+    else
+      super
+    end
+  end	
+  
+  # This method does the actual work.
+  def instantiateECoreModel(envOut, str)
+    instantiate(str)
+    
+    require 'xml_instantiator_test/simple_xmi_to_ecore'
+    
+    SimpleXmiToECore.new(@envXMI,envOut).transform
+  end
+  
+end

data/lib/puppet/vendor/rgen/test/xml_instantiator_test/simple_xmi_metamodel.rb

@@ -0,0 +1,49 @@
+# This is an extension of the implicit metamodel created by the
+# DefaultXMLInstantiator when it reads an Enterprise Architect
+# XMI file.
+# 
+module SimpleXMIMetaModel
+  
+  module UML
+    include RGen::MetamodelBuilder
+
+    class Classifier_feature < MMBase
+    end
+
+    class ClassifierRole < MMBase
+    end
+
+    class Clazz < ClassifierRole
+    end
+
+    class Interface < ClassifierRole
+    end
+
+    class Operation < MMBase
+    end
+
+    class Generalization < MMBase
+    end
+
+    class ModelElement_stereotype < MMBase
+    end
+
+    class AssociationEnd < MMBase
+      module ClassModule
+        def otherEnd
+          parent.associationEnd.find{|ae| ae != self}
+        end
+      end
+    end
+
+    class AssociationEndRole < MMBase
+    end
+
+    ClassifierRole.one_to_many 'associationEnds', AssociationEnd, 'typeClass'
+    ClassifierRole.one_to_many 'associationEndRoles', AssociationEndRole, 'typeClass'
+    Clazz.one_to_many 'generalizationsAsSubtype', Generalization, 'subtypeClass'
+    Clazz.one_to_many 'generalizationsAsSupertype', Generalization, 'supertypeClass'
+    
+  end
+  
+end

data/lib/puppet/vendor/rgen/test/xml_instantiator_test/simple_xmi_to_ecore.rb

@@ -0,0 +1,75 @@
+require 'rgen/transformer'
+require 'rgen/ecore/ecore'
+require 'rgen/array_extensions'
+require 'xml_instantiator_test/simple_xmi_metamodel'
+
+class SimpleXmiToECore < RGen::Transformer
+  include RGen::ECore
+  
+  class MapHelper
+    def initialize(keyMethod,valueMethod,elements)
+      @keyMethod, @valueMethod, @elements = keyMethod, valueMethod, elements
+    end
+    def [](key)
+      return @elements.select{|e| e.send(@keyMethod) == key}.first.send(@valueMethod) rescue NoMethodError
+    nil
+    end
+  end
+  
+  class TaggedValueHelper < MapHelper
+    def initialize(element)	
+      super('tag','value',element.modelElement_taggedValue.taggedValue)
+    end
+  end  
+  
+  # Do the actual transformation.
+  # Input and output environment have to be provided to the transformer constructor.
+  def transform
+    trans(:class => SimpleXMIMetaModel::UML::Clazz)
+  end
+  
+  transform SimpleXMIMetaModel::UML::Package, :to => EPackage do
+    { :name => name, 
+      :eSuperPackage => trans(parent.parent.is_a?(SimpleXMIMetaModel::UML::Package) ? parent.parent : nil) }
+  end
+  
+  transform SimpleXMIMetaModel::UML::Clazz, :to => EClass do
+    { :name => name,
+      :ePackage => trans(parent.parent.is_a?(SimpleXMIMetaModel::UML::Package) ? parent.parent : nil),
+      :eStructuralFeatures => trans(classifier_feature.attribute + associationEnds),
+      :eOperations => trans(classifier_feature.operation),
+      :eSuperTypes =>  trans(generalizationsAsSubtype.supertypeClass),
+      :eAnnotations => [ EAnnotation.new(:details => trans(modelElement_taggedValue.taggedValue)) ] }
+  end
+  
+  transform SimpleXMIMetaModel::UML::TaggedValue, :to => EStringToStringMapEntry do
+    { :key => tag, :value => value}
+  end
+  
+  transform SimpleXMIMetaModel::UML::Attribute, :to => EAttribute do
+    typemap = { "String" => EString, "boolean" => EBoolean, "int" => EInt, "long" => ELong, "float" => EFloat }
+    tv = TaggedValueHelper.new(@current_object)
+    {	:name => name, :eType => typemap[tv['type']],
+      :eAnnotations => [ EAnnotation.new(:details => trans(modelElement_taggedValue.taggedValue)) ] }
+  end
+  
+  transform SimpleXMIMetaModel::UML::Operation, :to => EOperation do
+    { :name => name }
+  end
+  
+  transform SimpleXMIMetaModel::UML::AssociationEnd, :to => EReference, :if => :isReference do
+    { :eType => trans(otherEnd.typeClass),
+      :name => otherEnd.name,
+      :eOpposite => trans(otherEnd),
+      :lowerBound => (otherEnd.multiplicity || '0').split('..').first.to_i,
+      :upperBound => (otherEnd.multiplicity || '1').split('..').last.gsub('*','-1').to_i,
+      :containment => (aggregation == 'composite'),
+      :eAnnotations => [ EAnnotation.new(:details => trans(modelElement_taggedValue.taggedValue)) ] }
+  end
+  
+  method :isReference do
+    otherEnd.isNavigable == 'true' || 
+    # composite assocations are bidirectional
+    aggregation == 'composite' || otherEnd.aggregation == 'composite'
+  end			
+end

data/lib/puppet/vendor/safe_yaml/PUPPET_README.md

@@ -0,0 +1,6 @@
+SafeYAML
+=============================================
+
+safe_yaml version 0.9.2
+
+Copied from https://github.com/dtao/safe_yaml/tree/c5591b790472f7db413aaa28716f86ddf4929f48