puppet 4.10.12 → 5.0.0

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

@@ -1,5 +0,0 @@
-$:.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

@@ -1,160 +0,0 @@
-$:.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

@@ -1,94 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,49 +0,0 @@
-# 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

@@ -1,75 +0,0 @@
-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/rgen_patch.rb

@@ -1,132 +0,0 @@
-# Patch to improve generated addXXX and setXXX method performance
-#
-# Submitted to rgen as PR: https://github.com/mthiede/rgen/pull/22. This
-# patch should be removed once that PR has been included in an rgen
-# release.
-#
-# The current implementation of the generated addXXX method will iterate
-# over the contained array where each iteration will then test for object_id
-# equality. Once the iteration is done and such an entry is found it
-# checks if the added value is an instance of MMBase or MMGeneric. If it
-# is, then it's considered a duplicate and the method returns.
-#
-# This patch changes the implementation so that the test for MMBase/
-# MMGeneric is made prior to the iteration, thus avoiding the iteration
-# altogether for all non model objects
-#
-# The patch also changes the setXXX method to allow it to optimize the way
-# it ensures that the added elements are unique. Calling the addXXX method
-# to do an increasingly expensive sequential scan is very expensive when
-# large sets of values are assigned.
-#
-require 'rgen/util/name_helper'
-require 'rgen/metamodel_builder/constant_order_helper'
-require 'rgen/metamodel_builder/builder_extensions'
-
-module RGen
-module MetamodelBuilder
-module BuilderExtensions
-
-  def _build_many_methods(props, other_props=nil)
-    name = props.value(:name)
-    other_role = other_props && other_props.value(:name)
-
-    if props.value(:derived)
-      build_derived_method(name, props, :many)
-    else
-      @@many_read_builder ||= ERB.new <<-CODE
-
-          def get<%= firstToUpper(name) %>
-            ( @<%= name %> ? @<%= name %>.dup : [] )
-          end
-          <% if name != "class" %>
-            alias <%= name %> get<%= firstToUpper(name) %>
-          <% end %>
-
-      CODE
-      self::ClassModule.module_eval(@@many_read_builder.result(binding))
-    end
-
-    if props.value(:changeable)
-      @@many_write_builder ||= ERB.new <<-CODE
-
-          def add<%= firstToUpper(name) %>(val, index=-1)
-            @<%= name %> = [] unless @<%= name %>
-            return if val.nil? || (val.is_a?(MMBase) || val.is_a?(MMGeneric)) && @<%= name %>.any? {|e| e.equal?(val)}
-            <%= type_check_code("val", props) %>
-            @<%= name %>.insert(index, val)
-            <% if other_role %>
-              val._register<%= firstToUpper(other_role) %>(self) unless val.is_a?(MMGeneric)
-            <% end %>
-            <% if props.reference? && props.value(:containment) %>
-              val._set_container(self, :<%= name %>)
-            <% end %>
-          end
-
-          def remove<%= firstToUpper(name) %>(val)
-            @<%= name %> = [] unless @<%= name %>
-            @<%= name %>.each_with_index do |e,i|
-              if e.equal?(val)
-                @<%= name %>.delete_at(i)
-                <% if props.reference? && props.value(:containment) %>
-                  val._set_container(nil, nil)
-                <% end %>
-                <% if other_role %>
-                  val._unregister<%= firstToUpper(other_role) %>(self) unless val.is_a?(MMGeneric)
-                <% end %>
-                return
-              end
-            end
-          end
-
-          def set<%= firstToUpper(name) %>(val)
-            return if val.nil?
-            raise _assignmentTypeError(self, val, Enumerable) unless val.is_a? Enumerable
-            get<%= firstToUpper(name) %>.each {|e|
-              remove<%= firstToUpper(name) %>(e)
-            }
-            @<%= name %> = [] unless @<%= name %>
-            <% if props.reference? %>
-            val.uniq {|elem| elem.object_id }.each {|elem|
-              next if elem.nil?
-              <%= type_check_code("elem", props) %>
-              @<%= name %> << elem
-              <% if other_role %>
-                elem._register<%= firstToUpper(other_role) %>(self) unless elem.is_a?(MMGeneric)
-              <% end %>
-              <% if props.value(:containment) %>
-                elem._set_container(self, :<%= name %>)
-              <% end %>
-            }
-            <% else %>
-            val.each {|elem|
-              <%= type_check_code("elem", props) %>
-              @<%= name %> << elem
-           }
-           <% end %>
-          end
-          alias <%= name %>= set<%= firstToUpper(name) %>
-
-          def _register<%= firstToUpper(name) %>(val)
-            @<%= name %> = [] unless @<%= name %>
-            @<%= name %>.push val
-            <% if props.reference? && props.value(:containment) %>
-              val._set_container(self, :<%= name %>)
-            <% end %>
-          end
-
-          def _unregister<%= firstToUpper(name) %>(val)
-            @<%= name %>.delete val
-            <% if props.reference? && props.value(:containment) %>
-              val._set_container(nil, nil)
-            <% end %>
-          end
-
-      CODE
-      self::ClassModule.module_eval(@@many_write_builder.result(binding))
-    end
-  end
-end
-end
-end
-