puppet 4.10.0 → 5.0.0

data/lib/puppet/vendor/rgen/lib/rgen/metamodel_builder.rb

@@ -1,224 +0,0 @@
-# RGen Framework
-# (c) Martin Thiede, 2006
-
-require 'rgen/metamodel_builder/constant_order_helper'
-require 'rgen/metamodel_builder/builder_runtime'
-require 'rgen/metamodel_builder/builder_extensions'
-require 'rgen/metamodel_builder/module_extension'
-require 'rgen/metamodel_builder/data_types'
-require 'rgen/metamodel_builder/mm_multiple'
-require 'rgen/ecore/ecore_interface'
-
-module RGen
-
-# MetamodelBuilder can be used to create a metamodel, i.e. Ruby classes which
-# act as metamodel elements.
-# 
-# To create a new metamodel element, create a Ruby class which inherits from
-# MetamodelBuilder::MMBase
-# 
-# 	class Person < RGen::MetamodelBuilder::MMBase
-# 	end
-# 
-# This way a couple of class methods are made available to the new class.
-# These methods can be used to:
-# * add attributes to the class
-# * add associations with other classes
-# 
-# Here is an example:
-# 
-# 	class Person < RGen::MetamodelBuilder::MMBase
-# 		has_attr 'name', String
-# 		has_attr 'age', Integer
-# 	end
-# 
-# 	class House < RGen::MetamodelBuilder::MMBase
-# 		has_attr 'address' # String is default
-# 	end
-# 
-# 	Person.many_to_many 'homes', House, 'inhabitants'
-# 
-# See BuilderExtensions for details about the available class methods.
-# 
-# =Attributes
-# 
-# The example above creates two classes 'Person' and 'House'. Person has the attributes
-# 'name' and 'age', House has the attribute 'address'. The attributes can be 
-# accessed on instances of the classes in the following way:
-# 
-# 	p = Person.new
-# 	p.name = "MyName"
-# 	p.age = 22
-# 	p.name	# => "MyName"
-# 	p.age 	# => 22
-# 
-# Note that the class Person takes care of the type of its attributes. As 
-# declared above, a 'name' can only be a String, an 'age' must be an Integer.
-# So the following would return an exception:
-# 
-# 	p.name = :myName	# => exception: can not put a Symbol where a String is expected
-# 
-# If the type of an attribute should be left undefined, use Object as type.
-#
-# =Associations
-# 
-# As well as attributes show up as instance methods, associations bring their own
-# accessor methods. For the Person-to-House association this would be:
-# 
-# 	h1 = House.new
-# 	h1.address = "Street1"
-# 	h2 = House.new
-# 	h2.address = "Street2"
-# 	p.addHomes(h1)
-# 	p.addHomes(h2)
-# 	p.removeHomes(h1)
-# 	p.homes	# => [ h2 ]
-# 
-# The Person-to-House association is _bidirectional_. This means that with the 
-# addition of a House to a Person, the Person is also added to the House. Thus:
-# 
-# 	h1.inhabitants	# => []
-# 	h2.inhabitants	# => [ p ]
-# 	
-# Note that the association is defined between two specific classes, instances of
-# different classes can not be added. Thus, the following would result in an 
-# exception:
-# 
-# 	p.addHomes(:justASymbol) # => exception: can not put a Symbol where a House is expected
-#
-# =ECore Metamodel description
-# 
-# The class methods described above are used to create a Ruby representation of the metamodel
-# we have in mind in a very simple and easy way. We don't have to care about all the details
-# of a metamodel at this point (e.g. multiplicities, changeability, etc).
-# 
-# At the same time however, an instance of the ECore metametamodel (i.e. a ECore based
-# description of our metamodel) is provided for all the Ruby classes and modules we create.
-# Since we did not provide the nitty-gritty details of the metamodel, defaults are used to
-# fully complete the ECore metamodel description.
-#
-# In order to access the ECore metamodel description, just call the +ecore+ method on a
-# Ruby class or module object belonging to your metamodel.
-# 
-# Here is the example continued from above:
-# 
-# 	Person.ecore.eAttributes.name # => ["name", "age"]
-# 	h2pRef = House.ecore.eReferences.first
-# 	h2pRef.eType                  # => Person
-# 	h2pRef.eOpposite.eType        # => House
-# 	h2pRef.lowerBound             # => 0
-# 	h2pRef.upperBound             # => -1
-# 	h2pRef.many                   # => true
-# 	h2pRef.containment            # => false
-# 
-# Note that the use of array_extensions.rb is assumed here to make model navigation convenient.
-# 
-# The following metamodel builder methods are supported, see individual method description
-# for details:
-# 
-# Attributes:
-# * BuilderExtensions#has_attr
-# 
-# Unidirectional references:
-# * BuilderExtensions#has_one
-# * BuilderExtensions#has_many
-# * BuilderExtensions#contains_one_uni
-# * BuilderExtensions#contains_many_uni
-# 
-# Bidirectional references:
-# * BuilderExtensions#one_to_one
-# * BuilderExtensions#one_to_many
-# * BuilderExtensions#many_to_one
-# * BuilderExtensions#many_to_many
-# * BuilderExtensions#contains_one
-# * BuilderExtensions#contains_many
-# 
-# Every builder command can optionally take a specification of further ECore properties.
-# Additional properties for Attributes and References are (with defaults in brackets):
-# * :ordered (true), 
-# * :unique (true),
-# * :changeable (true),
-# * :volatile (false),
-# * :transient (false),
-# * :unsettable (false),
-# * :derived (false),
-# * :lowerBound (0),
-# * :resolveProxies (true) <i>references only</i>,
-# 
-# Using these additional properties, the above example can be refined as follows:
-# 
-# 	class Person < RGen::MetamodelBuilder::MMBase
-# 		has_attr 'name', String, :lowerBound => 1
-# 		has_attr 'yearOfBirth', Integer,
-# 		has_attr 'age', Integer, :derived => true
-# 		def age_derived
-# 			Time.now.year - yearOfBirth
-# 		end
-# 	end
-# 
-# 	Person.many_to_many 'homes', House, 'inhabitants', :upperBound => 5
-# 
-# 	Person.ecore.eReferences.find{|r| r.name == 'homes'}.upperBound # => 5
-# 
-# This way we state that there must be a name for each person, we introduce a new attribute
-# 'yearOfBirth' and make 'age' a derived attribute. We also say that a person can 
-# have at most 5 houses in our metamodel.
-# 
-# ==Derived attributes and references
-# 
-# If the attribute 'derived' of an attribute or reference is set to true, a method +attributeName_derived+
-# has to be provided. This method is called whenever the original attribute is accessed. The
-# original attribute can not be written if it is derived.
-# 
-#
-module MetamodelBuilder	
-
-	# Use this class as a start for new metamodel elements (i.e. Ruby classes)
-	# by inheriting for it.
-	# 
-	# See MetamodelBuilder for an example.
-	class MMBase
-		include BuilderRuntime
-		include DataTypes
-		extend BuilderExtensions
-		extend ModuleExtension
-		extend RGen::ECore::ECoreInterface
-		
-		def initialize(arg=nil)
-			raise StandardError.new("Class #{self.class} is abstract") if self.class._abstract_class 
-	    arg.each_pair { |k,v| setGeneric(k, v) } if arg.is_a?(Hash)
-		end
-
-    # Object#inspect causes problems on most models 
-    def inspect
-      self.class.name
-    end
-    
-	  def self.method_added(m)
-	    raise "Do not add methods to model classes directly, add them to the ClassModule instead"
-	  end
-	end
-	
-  # Instances of MMGeneric can be used as values of any attribute are reference
-  class MMGeneric
-    # empty implementation so we don't have to check if a value is a MMGeneriv before setting the container
-    def _set_container(container, containing_feature_name)
-    end
-  end
-
-  # MMProxy objects can be used instead of real target elements in case references should be resolved later on
-  class MMProxy < MMGeneric
-    # The +targetIdentifer+ is an object identifying the element the proxy represents
-    attr_accessor :targetIdentifier
-    # +data+ is optional additional information to be associated with the proxy
-    attr_accessor :data
-
-    def initialize(ident=nil, data=nil)
-      @targetIdentifier = ident
-      @data = data
-    end
-  end
-
-end
-
-end

data/lib/puppet/vendor/rgen/lib/rgen/model_builder/builder_context.rb

@@ -1,334 +0,0 @@
-require 'rgen/ecore/ecore_ext'
-require 'rgen/model_builder/reference_resolver'
-
-module RGen
-  
-module ModelBuilder
-  
-class BuilderContext
-  attr_reader :toplevelElements
-  
-  def initialize(package, extensionsModule, resolver, env=nil)
-    package = package.ecore unless package.is_a?(RGen::ECore::EPackage)
-    raise "First argument must be a metamodel package" \
-      unless package.is_a?(RGen::ECore::EPackage)
-    @rootPackage, @env = package, env
-    @commandResolver = CommandResolver.new(package, extensionsModule, self)
-    @package = @rootPackage
-    @resolver = resolver
-    @contextStack = []
-    @toplevelElements = []
-    @helperNames = {}
-  end
-  
-  def const_missing_delegated(delegator, const)
-    ConstPathElement.new(const, self)
-  end
-  
-  # in Ruby 1.9.0 and 1.9.1 #instance_eval looks up constants in the calling scope
-  # that's why const_missing needs to be prepared in BuilderContext, too 
-  class << self
-    def currentBuilderContext=(bc)
-     @@currentBuilderContext = bc
-    end
-
-    def const_missing(name)
-      if @@currentBuilderContext
-        ConstPathElement.new(name, @@currentBuilderContext)
-      else
-        super
-      end
-    end
-  end
-
-  class CommandResolver
-    def initialize(rootPackage, extensionsModule, builderContext)
-      @extensionFactory = ExtensionContainerFactory.new(rootPackage, extensionsModule, builderContext)
-      @packageResolver = PackageResolver.new(rootPackage, @extensionFactory)
-      @resolveCommand = {}
-    end
-    
-    def resolveCommand(cmd, parentPackage)
-      return @resolveCommand[[parentPackage, cmd]] if @resolveCommand.has_key?([parentPackage, cmd])
-      package = @packageResolver.packageByCommand(parentPackage, cmd)
-      result = nil
-	    if package
-  	    extensionContainer = @extensionFactory.extensionContainer(package)
-  	    if extensionContainer.respond_to?(cmd)
-          result = extensionContainer
-        else
-    	    className = cmd.to_s[0..0].upcase + cmd.to_s[1..-1]
-    	    result = package.eClasses.find{|c| c.name == className}
-        end
-      end
-      @resolveCommand[[parentPackage, cmd]] = [package, result]
-	  end
-  end
-  
-  def method_missing(m, *args, &block)
-    package, classOrContainer = @commandResolver.resolveCommand(m, @package)
-    return super if package.nil?
-    return classOrContainer.send(m, *args, &block) if classOrContainer.is_a?(ExtensionContainerFactory::ExtensionContainer)
-    eClass = classOrContainer
-    nameArg, argHash = self.class.processArguments(args)
-    internalName = nameArg || argHash[:name]
-    argHash[:name] ||= nameArg if nameArg && self.class.hasNameAttribute(eClass)
-    resolverJobs, asRole, helperName = self.class.filterArgHash(argHash, eClass)
-    element = eClass.instanceClass.new(argHash)
-    @resolver.setElementName(element, internalName)
-    @env << element if @env
-    contextElement = @contextStack.last
-    if contextElement
-      self.class.associateWithContextElement(element, contextElement, asRole)
-    else
-      @toplevelElements << element
-    end
-    resolverJobs.each do |job|
-      job.receiver = element
-      job.namespace = contextElement
-      @resolver.addJob(job)
-    end
-    # process block
-    if block
-      @contextStack.push(element)
-      @package, oldPackage = package, @package
-      instance_eval(&block)
-      @package = oldPackage
-      @contextStack.pop
-    end
-    element
-  end
-  
-  def _using(constPathElement, &block)
-    @package, oldPackage = 
-      self.class.resolvePackage(@package, @rootPackage, constPathElement.constPath), @package
-    instance_eval(&block)
-    @package = oldPackage
-  end
-  
-  def _context(depth=1)
-    @contextStack[-depth]
-  end
-
-  class ExtensionContainerFactory
-    
-    class ExtensionContainer
-      def initialize(builderContext)
-        @builderContext = builderContext
-      end
-      def method_missing(m, *args, &block)
-        @builderContext.send(m, *args, &block)
-      end
-    end
-    
-    def initialize(rootPackage, extensionsModule, builderContext)
-      @rootPackage, @extensionsModule, @builderContext = rootPackage, extensionsModule, builderContext
-      @extensionContainer = {}
-    end
-    
-    def moduleForPackage(package)
-      qName = package.qualifiedName
-      rqName = @rootPackage.qualifiedName
-      raise "Package #{qName} is not contained within #{rqName}" unless qName.index(rqName) == 0
-      path = qName.sub(rqName,'').split('::')
-      path.shift if path.first == ""
-      mod = @extensionsModule
-      path.each do |p|
-        if mod && mod.const_defined?(p)
-          mod = mod.const_get(p)
-        else
-          mod = nil
-          break
-        end
-      end
-      mod
-    end
-    
-    def extensionContainer(package)
-      return @extensionContainer[package] if @extensionContainer[package]
-      container = ExtensionContainer.new(@builderContext)
-      extensionModule = moduleForPackage(package)
-      container.extend(extensionModule) if extensionModule
-      @extensionContainer[package] = container
-    end
-  end
-  
-  class PackageResolver
-    def initialize(rootPackage, extensionFactory)
-      @rootPackage = rootPackage
-      @extensionFactory = extensionFactory
-      @packageByCommand = {}
-    end
-    
-    def packageByCommand(contextPackage, name)
-      return @packageByCommand[[contextPackage, name]] if @packageByCommand.has_key?([contextPackage, name])
-      if @extensionFactory.extensionContainer(contextPackage).respond_to?(name)
-        result = contextPackage
-      else
-        className = name.to_s[0..0].upcase + name.to_s[1..-1]
-        eClass = contextPackage.eClasses.find{|c| c.name == className}
-        if eClass
-          result = contextPackage
-        elsif contextPackage != @rootPackage
-          result = packageByCommand(contextPackage.eSuperPackage, name)
-        else
-          result = nil
-        end
-      end
-      @packageByCommand[[contextPackage, name]] = result
-    end
-  end
-  
-  class ConstPathElement < Module
-    def initialize(name, builderContext, parent=nil)
-      @name = name.to_s
-      @builderContext = builderContext
-      @parent = parent
-    end
-    
-    def const_missing(const)
-      ConstPathElement.new(const, @builderContext, self)
-    end
-    
-    def method_missing(m, *args, &block)
-      @builderContext._using(self) do
-        send(m, *args, &block)
-      end
-    end
-    
-    def constPath
-      if @parent
-        @parent.constPath << @name
-      else
-        [@name]
-      end
-    end
-  end
-
-  # helper methods put in the class object to be out of the way of 
-  # method evaluation in the builder context
-  class << self
-    class PackageNotFoundException < Exception
-    end
-  
-    def resolvePackage(contextPackage, rootPackage, path)
-      begin
-        return resolvePackageDownwards(contextPackage, path)
-      rescue PackageNotFoundException
-        if contextPackage.eSuperPackage && contextPackage != rootPackage
-          return resolvePackage(contextPackage.eSuperPackage, rootPackage, path)
-        else
-          raise
-        end
-      end
-    end
-  
-    def resolvePackageDownwards(contextPackage, path)
-      first, *rest = path
-      package = contextPackage.eSubpackages.find{|p| p.name == first}
-      raise PackageNotFoundException.new("Could not resolve package: #{first} is not a subpackage of #{contextPackage.name}") unless package
-      if rest.empty?
-        package 
-      else
-        resolvePackageDownwards(package, rest)
-      end
-    end
-    
-    def processArguments(args)
-      unless (args.size == 2 && args.first.is_a?(String) && args.last.is_a?(Hash)) ||
-        (args.size == 1 && (args.first.is_a?(String) || args.first.is_a?(Hash))) ||
-        args.size == 0
-        raise "Provide a Hash to set feature values, " +
-          "optionally the first argument may be a String specifying " + 
-          "the value of the \"name\" attribute."
-      end
-      if args.last.is_a?(Hash)
-        argHash = args.last
-      else
-        argHash = {}
-      end
-      nameArg = args.first if args.first.is_a?(String)
-      [nameArg, argHash]
-    end
-    
-    def filterArgHash(argHash, eClass)
-      resolverJobs = []
-      asRole, helperName = nil, nil
-      refByName = {}
-      eAllReferences(eClass).each {|r| refByName[r.name] = r}
-      argHash.each_pair do |k,v|
-        if k == :as
-          asRole = v
-          argHash.delete(k)
-        elsif k == :name && !hasNameAttribute(eClass)
-          helperName = v          
-          argHash.delete(k)
-        elsif v.is_a?(String)
-          ref = refByName[k.to_s]#eAllReferences(eClass).find{|r| r.name == k.to_s}
-          if ref
-            argHash.delete(k)
-            resolverJobs << ReferenceResolver::ResolverJob.new(nil, ref, nil,  v)
-          end
-        elsif v.is_a?(Array)
-          ref = refByName[k.to_s] #eAllReferences(eClass).find{|r| r.name == k.to_s}
-          ref && v.dup.each do |e|
-            if e.is_a?(String)
-              v.delete(e)
-              resolverJobs << ReferenceResolver::ResolverJob.new(nil, ref, nil, e)
-            end
-          end
-        end
-      end
-      [ resolverJobs, asRole, helperName ]
-    end
-    
-    def hasNameAttribute(eClass)
-      @hasNameAttribute ||= {}
-      @hasNameAttribute[eClass] ||= eClass.eAllAttributes.any?{|a| a.name == "name"}
-    end
-  
-    def eAllReferences(eClass)
-      @eAllReferences ||= {}
-      @eAllReferences[eClass] ||= eClass.eAllReferences
-    end
-    
-    def containmentRefs(contextClass, eClass)
-      @containmentRefs ||= {}
-      @containmentRefs[[contextClass, eClass]] ||=
-        eAllReferences(contextClass).select do |r| 
-          r.containment && (eClass.eAllSuperTypes << eClass).include?(r.eType)
-        end
-    end
-  
-    def associateWithContextElement(element, contextElement, asRole)
-      return unless contextElement
-      contextClass = contextElement.class.ecore
-      if asRole
-        asRoleRef = eAllReferences(contextClass).find{|r| r.name == asRole.to_s}
-        raise "Context class #{contextClass.name} has no reference named #{asRole}" unless asRoleRef
-        ref = asRoleRef
-      else
-        possibleContainmentRefs = containmentRefs(contextClass, element.class.ecore)
-        if possibleContainmentRefs.size == 1
-          ref = possibleContainmentRefs.first
-        elsif possibleContainmentRefs.size == 0
-          raise "Context class #{contextClass.name} can not contain a #{element.class.ecore.name}"
-        else
-          raise "Context class #{contextClass.name} has several containment references to a #{element.class.ecore.name}." +
-            " Clearify using \":as => <role>\""
-        end
-      end
-      if ref.many
-        contextElement.addGeneric(ref.name, element)
-      else
-        contextElement.setGeneric(ref.name, element)
-      end
-    end
-    
-  end
-  
-end
-
-end
-  
-end