puppet 4.10.0 → 5.0.0

data/lib/puppet/vendor/rgen/lib/rgen/serializer/xmi11_serializer.rb

@@ -1,116 +0,0 @@
-require 'rgen/serializer/xml_serializer'
-
-module RGen
-
-module Serializer
-
-class XMI11Serializer < XMLSerializer
-
-  def initialize(file)
-    super
-    @namespacePrefix = ""
-    @contentLevelElements = []
-  end
-  
-  def setNamespace(shortcut, url)
-    @namespaceShortcut = shortcut
-    @namespaceUrl = url
-    @namespacePrefix = shortcut+":"
-  end
-  
-  def serialize(rootElement, headerInfo=nil)
-    attrs = []
-    attrs << ['xmi.version', "1.1"]
-    attrs << ['xmlns:'+@namespaceShortcut, @namespaceUrl] if @namespaceUrl
-    attrs << ['timestamp', Time.now.to_s]
-    startTag("XMI", attrs)
-    if headerInfo
-      startTag("XMI.header")
-      writeHeaderInfo(headerInfo)
-      endTag("XMI.header")
-    end
-    startTag("XMI.content")
-    @contentLevelElements = []
-    writeElement(rootElement)
-    # write remaining toplevel elements, each of which could have
-    # more toplevel elements as childs
-    while @contentLevelElements.size > 0
-      writeElement(@contentLevelElements.shift)
-    end
-    endTag("XMI.content") 
-    endTag("XMI") 
-  end
-  
-  def writeHeaderInfo(hash)
-    hash.each_pair do |k,v|
-      tag = "XMI." + k.to_s
-      startTag(tag)
-      if v.is_a?(Hash)
-        writeHeaderInfo(v)
-      else
-        writeText(v.to_s)
-      end
-      endTag(tag)
-    end
-  end
-  
-  def writeElement(element)
-    tag = @namespacePrefix + element.class.ecore.name
-    attrs = attributeValues(element)
-    startTag(tag, attrs)
-    containmentReferences(element).each do |r|
-      roletag = @namespacePrefix + r.eContainingClass.name + "." + r.name
-      targets = element.getGeneric(r.name)
-      targets = [ targets ] unless targets.is_a?(Array)
-      targets.compact!
-      next if targets.empty?
-      startTag(roletag)
-      targets.each do |t|
-        if xmiLevel(t) == :content
-          @contentLevelElements << t
-        else
-          writeElement(t)
-        end
-      end
-      endTag(roletag)
-    end
-    endTag(tag)
-  end
-
-  def attributeValues(element)
-    result = [["xmi.id", xmiId(element)]]
-    eAllAttributes(element).select{|a| !a.derived}.each do |a|
-      val = element.getGeneric(a.name)
-      result << [a.name, val] unless val.nil? || val == ""
-    end
-    eAllReferences(element).each do |r|
-      next if r.derived
-      next if r.containment
-      next if r.eOpposite && r.eOpposite.containment && xmiLevel(element).nil?
-      next if r.eOpposite && r.many && !r.eOpposite.many
-      targetElements = element.getGenericAsArray(r.name)
-      targetElements.compact!
-      val = targetElements.collect{|te| xmiId(te)}.compact.join(' ')
-      result << [r.name, val] unless val == ""
-    end
-    result  
-  end
-  
-  def xmiId(element)
-    if element.respond_to?(:_xmi_id) && element._xmi_id
-      element._xmi_id.to_s
-    else
-      element.object_id.to_s
-    end
-  end
-  
-  def xmiLevel(element)
-    return nil unless element.respond_to?(:_xmi_level) 
-    element._xmi_level
-  end
-  
-end
-
-end
-
-end

data/lib/puppet/vendor/rgen/lib/rgen/serializer/xmi20_serializer.rb

@@ -1,71 +0,0 @@
-require 'rgen/serializer/xml_serializer'
-
-module RGen
-
-module Serializer
-
-class XMI20Serializer < XMLSerializer
-
-	def serialize(rootElement)
-		@referenceStrings = {}
-		buildReferenceStrings(rootElement, "#/")
-    addBuiltinReferenceStrings
-		attrs = attributeValues(rootElement)
-		attrs << ['xmi:version', "2.0"]
-		attrs << ['xmlns:xmi', "http://www.omg.org/XMI"]
-		attrs << ['xmlns:xsi', "http://www.w3.org/2001/XMLSchema-instance"]
-		attrs << ['xmlns:ecore', "http://www.eclipse.org/emf/2002/Ecore" ]
-		tag = "ecore:"+rootElement.class.ecore.name
-		startTag(tag, attrs)
-		writeComposites(rootElement)
-		endTag(tag)
-	end
-	
-	def writeComposites(element)
-		eachReferencedElement(element, containmentReferences(element)) do |r,te|
-			attrs = attributeValues(te)
-			attrs << ['xsi:type', "ecore:"+te.class.ecore.name]
-			tag = r.name
-			startTag(tag, attrs)
-			writeComposites(te)
-			endTag(tag)
-		end
-	end
-
-	def attributeValues(element)
-		result = [] 
-		eAllAttributes(element).select{|a| !a.derived}.each do |a|
-			val = element.getGeneric(a.name)
-			result << [a.name, val] unless val.nil? || val == ""
-		end
-		eAllReferences(element).select{|r| !r.containment && !(r.eOpposite && r.eOpposite.containment) && !r.derived}.each do |r|
-			targetElements = element.getGenericAsArray(r.name)
-			val = targetElements.collect{|te| @referenceStrings[te]}.compact.join(' ')
-			result << [r.name, val] unless val.nil? || val == ""
-		end
-		result	
-	end
-	
-	def buildReferenceStrings(element, string)
-		@referenceStrings[element] = string
-		eachReferencedElement(element, containmentReferences(element)) do |r,te|
-			buildReferenceStrings(te, string+"/"+te.name) if te.respond_to?(:name)
-		end
-	end
-
-  def addBuiltinReferenceStrings
-    pre = "ecore:EDataType http://www.eclipse.org/emf/2002/Ecore"
-    @referenceStrings[RGen::ECore::EString] = pre+"#//EString"
-    @referenceStrings[RGen::ECore::EInt] = pre+"#//EInt"
-    @referenceStrings[RGen::ECore::ELong] = pre+"#//ELong"
-    @referenceStrings[RGen::ECore::EFloat] = pre+"#//EFloat"
-    @referenceStrings[RGen::ECore::EBoolean] = pre+"#//EBoolean"
-    @referenceStrings[RGen::ECore::EJavaObject] = pre+"#//EJavaObject"
-    @referenceStrings[RGen::ECore::EJavaClass] = pre+"#//EJavaClass"
-  end
-
-end
-
-end
-
-end

data/lib/puppet/vendor/rgen/lib/rgen/serializer/xml_serializer.rb

@@ -1,98 +0,0 @@
-module RGen
-
-module Serializer
-
-class XMLSerializer
-
-  INDENT_SPACE = 2
-  
-	def initialize(file)
-    @indent = 0
-    @lastStartTag = nil
-    @textContent = false
-    @file = file
-	end
-	
-	def serialize(rootElement)
-		raise "Abstract class, overwrite method in subclass!"
-	end
-  
-  def startTag(tag, attributes={})
-    @textContent = false
-    handleLastStartTag(false, true)
-    if attributes.is_a?(Hash)
-      attrString = attributes.keys.collect{|k| "#{k}=\"#{attributes[k]}\""}.join(" ")
-    else
-      attrString = attributes.collect{|pair| "#{pair[0]}=\"#{pair[1]}\""}.join(" ")
-    end
-    @lastStartTag = " "*@indent*INDENT_SPACE + "<#{tag} "+attrString
-    @indent += 1
-  end
-  
-  def endTag(tag)
-    @indent -= 1
-    unless handleLastStartTag(true, true)
-      output " "*@indent*INDENT_SPACE unless @textContent
-      output "</#{tag}>\n"
-    end
-    @textContent = false
-  end
-
-  def writeText(text)
-    handleLastStartTag(false, false)
-    output "#{text}"
-    @textContent = true
-  end  
-	
-	protected
-
-  def eAllReferences(element)
-    @eAllReferences ||= {}
-    @eAllReferences[element.class] ||= element.class.ecore.eAllReferences
-  end
-
-  def eAllAttributes(element)
-    @eAllAttributes ||= {}
-    @eAllAttributes[element.class] ||= element.class.ecore.eAllAttributes
-  end
-    
-  def eAllStructuralFeatures(element)
-    @eAllStructuralFeatures ||= {}
-    @eAllStructuralFeatures[element.class] ||= element.class.ecore.eAllStructuralFeatures
-  end
-
-	def eachReferencedElement(element, refs, &block)
-		refs.each do |r|
-			targetElements = element.getGeneric(r.name)
-			targetElements = [targetElements] unless targetElements.is_a?(Array)
-			targetElements.each do |te|
-				yield(r,te)
-			end
-		end			
-	end  
-
-  def containmentReferences(element)
-    @containmentReferences ||= {}
-    @containmentReferences[element.class] ||= eAllReferences(element).select{|r| r.containment}
-  end
-  
-  private
-  
-  def handleLastStartTag(close, newline)
-    return false unless @lastStartTag
-    output @lastStartTag
-    output close ? "/>" : ">"
-    output "\n" if newline
-    @lastStartTag = nil
-    true
-  end
-  
-  def output(text)
-    @file.write(text)
-  end
-  
-end
-
-end
-
-end

data/lib/puppet/vendor/rgen/lib/rgen/template_language/directory_template_container.rb

@@ -1,83 +0,0 @@
-# RGen Framework
-# (c) Martin Thiede, 2006
-
-require 'rgen/template_language/template_container'
-require 'rgen/template_language/template_helper'
-
-module RGen
-  
-module TemplateLanguage
-    
-class DirectoryTemplateContainer
-  include TemplateHelper
-  
-  def initialize(metamodel=nil, output_path=nil, parent=nil)
-    @containers = {}
-    @directoryContainers = {}
-    @parent = parent
-    @metamodel = metamodel
-    @output_path = output_path
-  end
-  
-  def load(dir)
-    Dir.foreach(dir) { |f|
-      qf = dir+"/"+f
-      if !File.directory?(qf) && f =~ /^(.*)\.tpl$/
-       (@containers[$1] = TemplateContainer.new(@metamodel, @output_path, self,qf)).load
-      elsif File.directory?(qf) && f != "." && f != ".."
-       (@directoryContainers[f] = DirectoryTemplateContainer.new(@metamodel, @output_path, self)).load(qf)
-      end
-    }
-  end
-  
-  def expand(template, *all_args)
-    if template =~ /^\//
-      if @parent
-        # pass to parent
-        @parent.expand(template, *all_args)
-      else
-        # this is root
-        _expand(template, *all_args)
-      end
-    elsif template =~ /^\.\.\/(.*)/
-      if @parent
-        # pass to parent
-        @parent.expand($1, *all_args)
-      else
-        raise "No parent directory for root"
-      end
-    else
-      _expand(template, *all_args)
-    end
-  end
-  
-  # Set indentation string.
-  # Every generated line will be prependend with n times this string at an indentation level of n.
-  # Defaults to "   " (3 spaces)
-  def indentString=(str)
-    @indentString = str
-  end
-  
-  def indentString
-    @indentString || (@parent && @parent.indentString) || "   "
-  end
-  
-  private
-  
-  def _expand(template, *all_args)
-    if template =~ /^\/?(\w+)::(\w.*)/ 
-      raise "Template not found: #{$1}" unless @containers[$1]
-      @containers[$1].expand($2, *all_args)
-    elsif template =~ /^\/?(\w+)\/(\w.*)/ 
-      raise "Template not found: #{$1}" unless @directoryContainers[$1]
-      @directoryContainers[$1].expand($2, *all_args)
-    else
-      raise "Invalid template name: #{template}"
-    end
-  end
-  
-end
-
-end
-    
-end

data/lib/puppet/vendor/rgen/lib/rgen/template_language/output_handler.rb

@@ -1,87 +0,0 @@
-# RGen Framework
-# (c) Martin Thiede, 2006
-
-module RGen
-  
-module TemplateLanguage
-  
-  class OutputHandler
-    attr_writer :indent
-    attr_accessor :noIndentNextLine
-    
-    def initialize(indent=0, indentString="   ", mode=:explicit)
-      self.mode = mode
-      @indent = indent
-      @indentString = indentString
-      @state = :wait_for_nonws
-      @output = ""
-    end
-    
-    # ERB will call this method for every string s which is part of the
-    # template file in between %> and <%. If s contains a newline, it will
-    # call this method for every part of s which is terminated by a \n
-    # 
-    def concat(s)
-      return @output.concat(s) if s.is_a? OutputHandler
-      #puts [object_id, noIndentNextLine, @state, @output.to_s, s].inspect
-      s = s.to_str.gsub(/^[\t ]*\r?\n/,'') if @ignoreNextNL
-      s = s.to_str.gsub(/^\s+/,'') if @ignoreNextWS
-      @ignoreNextNL = @ignoreNextWS = false if s =~ /\S/
-      if @mode == :direct
-        @output.concat(s)
-      elsif @mode == :explicit
-        while s.size > 0
-          if @state == :wait_for_nl
-            if s =~ /\A([^\r\n]*\r?\n)(.*)/m
-              rest = $2
-              @output.concat($1.gsub(/[\t ]+(?=\r|\n)/,''))
-              s = rest || ""
-              @state = :wait_for_nonws
-            else
-              @output.concat(s)
-              s = ""
-            end
-          elsif @state == :wait_for_nonws
-            if s =~ /\A\s*(\S+.*)/m
-              s = $1 || ""
-              if !@noIndentNextLine && !(@output.to_s.size > 0 && @output.to_s[-1] != "\n"[0])
-                @output.concat(@indentString * @indent)
-              else
-                @noIndentNextLine = false
-              end
-              @state = :wait_for_nl
-            else
-              s = ""
-            end
-          end
-        end
-      end
-    end
-    alias << concat
-    
-    def to_str
-      @output
-    end
-    alias to_s to_str
-    
-    def direct_concat(s)
-      @output.concat(s)
-    end
-    
-    def ignoreNextNL
-      @ignoreNextNL = true
-    end
-    
-    def ignoreNextWS
-      @ignoreNextWS = true
-    end
-    
-    def mode=(m)
-      raise StandardError.new("Unknown mode: #{m}") unless [:direct, :explicit].include?(m)
-      @mode = m
-    end
-  end
-  
-end
-  
-end

data/lib/puppet/vendor/rgen/lib/rgen/template_language/template_container.rb

@@ -1,234 +0,0 @@
-# RGen Framework
-# (c) Martin Thiede, 2006
-
-require 'erb'
-require 'fileutils'
-require 'rgen/template_language/output_handler'
-require 'rgen/template_language/template_helper'
-
-module RGen
-  
-  module TemplateLanguage
-    
-    class TemplateContainer
-      include TemplateHelper
-      
-      def initialize(metamodels, output_path, parent, filename)
-        @templates = {}
-        @parent = parent
-        @filename = filename
-        @indent = 0
-        @output_path = output_path
-    		@metamodels = metamodels
-    		@metamodels = [ @metamodels ] unless @metamodels.is_a?(Array)
-      end
-      
-      def load
-    		File.open(@filename,"rb") do |f|
-          begin
-  	      	@@metamodels = @metamodels
-    	    	fileContent = f.read
-      	  	_detectNewLinePattern(fileContent)
-        		ERB.new(fileContent,nil,nil,'@output').result(binding)
-          rescue Exception => e
-            processAndRaise(e)
-          end
-    		end
-      end
-      
-      def expand(template, *all_args)
-        args, params = _splitArgsAndOptions(all_args)
-    		if params.has_key?(:foreach)
-      		raise StandardError.new("expand :foreach argument is not enumerable") \
-        		unless params[:foreach].is_a?(Enumerable)
-          _expand_foreach(template, args, params)
-        else
-          _expand(template, args, params)
-        end
-      end
-      
-      def evaluate(template, *all_args)
-        args, params = _splitArgsAndOptions(all_args)
-        raise StandardError.new(":foreach can not be used with evaluate") if params[:foreach]
-        _expand(template, args, params.merge({:_evalOnly => true}))
-      end
-      
-      def this
-        @context
-      end
-      
-      def method_missing(name, *args)
-        @context.send(name, *args)
-      end
-      
-      def self.const_missing(name)
-        super unless @@metamodels
-        @@metamodels.each do |mm|
-          return mm.const_get(name) rescue NameError
-        end
-        super
-      end
-      
-      private
-      
-      def nonl
-        @output.ignoreNextNL
-      end
-      
-      def nows
-        @output.ignoreNextWS
-      end
-      
-      def nl
-    		_direct_concat(@newLinePattern)
-      end
-      
-      def ws
-        _direct_concat(" ")
-      end
-      
-      def iinc
-        @indent += 1
-        @output.indent = @indent
-      end
-      
-      def idec
-        @indent -= 1 if @indent > 0
-        @output.indent = @indent
-      end
-      
-      TemplateDesc = Struct.new(:block, :local)
-      
-      def define(template, params={}, &block)
-        _define(template, params, &block)
-      end
-      
-      def define_local(template, params={}, &block)
-        _define(template, params.merge({:local => true}), &block)
-      end
-      
-      def file(name, indentString=nil)
-        old_output, @output = @output, OutputHandler.new(@indent, indentString || @parent.indentString)
-        begin
-          yield
-        rescue Exception => e
-          processAndRaise(e)
-        end
-        path = ""
-        path += @output_path+"/" if @output_path
-        dirname = File.dirname(path+name)
-        FileUtils.makedirs(dirname) unless File.exist?(dirname)
-    		File.open(path+name,"wb") { |f| f.write(@output) }
-        @output = old_output
-      end
-      
-      # private private
-      
-      def _define(template, params={}, &block)
-        @templates[template] ||= {}
-        cls = params[:for] || Object
-        @templates[template][cls] = TemplateDesc.new(block, params[:local])
-      end
-      
-      def _expand_foreach(template, args, params)
-        sep = params[:separator]
-        params[:foreach].each_with_index {|e,i|
-          _direct_concat(sep.to_s) if sep && i > 0 
-          output = _expand(template, args, params.merge({:for => e}))
-        }
-      end
-      
-      LOCAL_TEMPLATE_REGEX = /^:*(\w+)$/
-      
-      def _expand(template, args, params)
-        raise StandardError.new("expand :for argument evaluates to nil") if params.has_key?(:for) && params[:for].nil?
-        context = params[:for]
-        old_indent = @indent
-        @indent = params[:indent] || @indent
-        noIndentNextLine = params[:_noIndentNextLine] || 
-          (@output.is_a?(OutputHandler) && @output.noIndentNextLine) || 
-          (@output.to_s.size > 0 && @output.to_s[-1] != "\n"[0]) 
-        caller = params[:_caller] || self
-        old_context, @context = @context, context if context
-        local_output = nil
-        if template =~ LOCAL_TEMPLATE_REGEX
-          tplname = $1
-          raise StandardError.new("Template not found: #{$1}") unless @templates[tplname]
-          old_output, @output = @output, OutputHandler.new(@indent, @parent.indentString)
-          @output.noIndentNextLine = noIndentNextLine
-          _call_template(tplname, @context, args, caller == self)
-          old_output.noIndentNextLine = false if old_output.is_a?(OutputHandler) && !old_output.noIndentNextLine
-          local_output, @output = @output, old_output
-        else
-          local_output = @parent.expand(template, *(args.dup << {:for => @context, :indent => @indent, :_noIndentNextLine => noIndentNextLine, :_evalOnly => true, :_caller => caller}))
-        end
-        _direct_concat(local_output) unless params[:_evalOnly]
-        @context = old_context if old_context
-        @indent = old_indent
-        local_output.to_s
-      end
-      
-      def processAndRaise(e, tpl=nil)
-        bt = e.backtrace.dup
-        e.backtrace.each_with_index do |t,i|
-          if t =~ /\(erb\):(\d+):/
-            bt[i] = "#{@filename}:#{$1}"
-            bt[i] += ":in '#{tpl}'" if tpl
-            break
-          end
-        end
-        raise e, e.to_s, bt
-      end
-      
-      def _call_template(tpl, context, args, localCall)
-        found = false
-        @templates[tpl].each_pair do |key, value| 
-          if context.is_a?(key)
-            templateDesc = @templates[tpl][key]
-            proc = templateDesc.block
-            arity = proc.arity
-            arity = 0 if arity == -1	# if no args are given
-            raise StandardError.new("Wrong number of arguments calling template #{tpl}: #{args.size} for #{arity} "+
-              "(Beware: Hashes as last arguments are taken as options and are ignored)") \
-              if arity != args.size
-            raise StandardError.new("Template can only be called locally: #{tpl}") \
-              if templateDesc.local && !localCall
-            begin
-             	@@metamodels = @metamodels
-              proc.call(*args) 
-            rescue Exception => e
-              processAndRaise(e, tpl)
-            end
-            found = true
-          end
-        end
-        raise StandardError.new("Template class not matching: #{tpl} for #{context.class.name}") unless found
-      end
-        
-      def _direct_concat(s)
-        if @output.is_a? OutputHandler
-          @output.direct_concat(s)
-        else
-          @output << s
-        end
-      end
 
-      def _detectNewLinePattern(text)
-        tests = 0
-        rnOccurances = 0
-        text.scan(/(\r?)\n/) do |groups|
-          tests += 1
-          rnOccurances += 1 if groups[0] == "\r"
-          break if tests >= 10
-        end
-        if rnOccurances > (tests / 2)
-          @newLinePattern = "\r\n"
-        else
-          @newLinePattern = "\n"
-        end
-      end
-              
-    end
-    
-  end
-  
-end