puppet 4.10.12 → 5.0.0

data/lib/puppet/vendor/rgen/lib/rgen/util/model_comparator.rb

@@ -1,68 +0,0 @@
-require 'rgen/ecore/ecore'
-
-module RGen
-
-module Util
-
-module ModelComparator
-
-# This method compares to models regarding equality
-# For this the identity of a model element is defined based on identity
-# of all attributes and referenced elements.
-# Arrays are sorted before comparison if possible (if <=> is provided).
-# 
-def modelEqual?(a, b, featureIgnoreList=[])
-  @modelEqual_visited = {}
-  _modelEqual_internal(a, b, featureIgnoreList, [])
-end
-  
-def _modelEqual_internal(a, b, featureIgnoreList, path)
-  return true if @modelEqual_visited[[a,b]]
-  @modelEqual_visited[[a,b]] = true
-  return true if a.nil? && b.nil?
-  unless a.class == b.class
-    puts "#{path.inspect}\n  Classes differ: #{a} vs. #{b}"
-    return false 
-  end
-  if a.is_a?(Array)
-    unless a.size == b.size
-      puts "#{path.inspect}\n  Array size differs: #{a.size} vs. #{b.size}"
-      return false 
-    end
-    begin
-      # in Ruby 1.9 every object has the <=> operator but the default one returns
-      # nil and thus sorting won't work (ArgumentError)
-      as = a.sort
-    rescue ArgumentError, NoMethodError
-      as = a
-    end
-    begin
-      bs = b.sort
-    rescue ArgumentError, NoMethodError
-      bs = b
-    end
-    a.each_index do |i|
-      return false unless _modelEqual_internal(as[i], bs[i], featureIgnoreList, path+[i])
-    end
-  else
-    a.class.ecore.eAllStructuralFeatures.reject{|f| f.derived}.each do |feat|
-      next if featureIgnoreList.include?(feat.name)
-      if feat.eType.is_a?(RGen::ECore::EDataType)
-        unless a.getGeneric(feat.name) == b.getGeneric(feat.name)
-          puts "#{path.inspect}\n  Value '#{feat.name}' differs: #{a.getGeneric(feat.name)} vs. #{b.getGeneric(feat.name)}"
-          return false
-        end
-      else
-        return false unless _modelEqual_internal(a.getGeneric(feat.name), b.getGeneric(feat.name), featureIgnoreList, path+["#{a.respond_to?(:name) && a.name}:#{feat.name}"])
-      end
-    end
-  end
-  return true
-end
-
-end
-
-end
-
-end
- 

data/lib/puppet/vendor/rgen/lib/rgen/util/model_comparator_base.rb

@@ -1,142 +0,0 @@
-require 'andand'
-
-module RGen
-
-module Util
-	
-class ModelComparatorBase
-	
-	CompareSpec = Struct.new(:identifier, :recurse, :filter, :ignore_features, :display_name, :sort)
-	INDENT = "  "	
-
-	class << self
-		attr_reader :compareSpecs
-		
-		def compare_spec(clazz, hash)
-			@compareSpecs ||= {}
-			raise "Compare spec already defined for #{clazz}" if @compareSpecs[clazz]
-			spec = CompareSpec.new
-			hash.each_pair do |k,v|
-				spec.send("#{k}=",v)
-			end
-			@compareSpecs[clazz] = spec
-		end
-	end
-	
-	# compares two sets of elements
-	def compare(as, bs, recursive=true)
-		result = []
-		aById = as.select{|e| useElement?(e)}.inject({}){|r, e| r[elementIdentifier(e)] = e; r}
-		bById = bs.select{|e| useElement?(e)}.inject({}){|r, e| r[elementIdentifier(e)] = e; r}
-		onlyA = sortElements((aById.keys - bById.keys).collect{|id| aById[id]})
-		onlyB = sortElements((bById.keys - aById.keys).collect{|id| bById[id]})
-		aAndB = sortElementPairs((aById.keys & bById.keys).collect{|id| [aById[id], bById[id]]})
-		onlyA.each do |e|
-			result << "- #{elementDisplayName(e)}"
-		end
-		onlyB.each do |e|
-			result << "+ #{elementDisplayName(e)}"
-		end
-		if recursive
-			aAndB.each do |ab|
-				a, b = *ab
-				r = compareElements(a, b)
-				if r.size > 0
-					result << "#{elementDisplayName(a)}"
-					result += r.collect{|l| INDENT+l}
-				end
-			end
-		end
-		result
-	end
-	
-	def sortElementPairs(pairs)
-		pairs.sort do |x,y|
-			a, b = x[0], y[0]
-			r = a.class.name <=> b.class.name
-			r = compareSpec(a).sort.call(a,b) if r == 0 && compareSpec(a) && compareSpec(a).sort
-			r
-		end
-	end
-	
-	def sortElements(elements)
-		elements.sort do |a,b|
-			r = a.class.name <=> b.class.name
-			r = compareSpec(a).sort.call(a,b) if r == 0 && compareSpec(a) && compareSpec(a).sort
-			r
-		end
-	end
-	
-	def elementDisplayName(e)
-		if compareSpec(e) && compareSpec(e).display_name
-			compareSpec(e).display_name.call(e)
-		else
-			elementIdentifier(e)
-		end
-	end
-	
-	def compareElements(a, b)
-		result = []
-		if a.class != b.class
-			result << "Class: #{a.class} -> #{b.class}"
-		else
-			a.class.ecore.eAllStructuralFeatures.reject{|f| f.derived || compareSpec(a).andand.ignore_features.andand.include?(f.name.to_sym)}.each do |f|
-				va, vb = a.getGeneric(f.name), b.getGeneric(f.name)
-				if f.is_a?(RGen::ECore::EAttribute)
-					r = compareValues(f.name, va, vb)
-					result << r if r
-				else
-					va, vb = [va].compact, [vb].compact unless f.many
-					r = compare(va, vb, f.containment || compareSpec(a).andand.recurse.andand.include?(f.name.to_sym))
-					if r.size > 0
-						result << "[#{f.name}]"
-						result += r.collect{|l| INDENT+l}
-					end
-				end	
-			end
-		end
-		result
-	end
-	
-	def compareValues(name, val1, val2)
-		result = nil
-		result = "[#{name}] #{val1} -> #{val2}" if val1 != val2
-		result
-	end
-	
-	def elementIdentifier(element)
-		cs = compareSpec(element)
-		if cs && cs.identifier
-			if cs.identifier.is_a?(Proc)
-				cs.identifier.call(element)
-			else
-				cs.identifier
-			end
-		else
-			if element.respond_to?(:name)
-				element.name
-			else
-				element.object_id
-			end
-		end
-	end
-	
-	def useElement?(element)
-		cs = compareSpec(element)
-		!(cs && cs.filter) || cs.filter.call(element)
-	end
-	
-	def compareSpec(element)
-		@compareSpec ||= {}
-		return @compareSpec[element.class] if @compareSpec[element.class]
-		return nil unless self.class.compareSpecs
-		key = self.class.compareSpecs.keys.find{|k| element.is_a?(k)}
-		@compareSpec[element.class] = self.class.compareSpecs[key]
-	end
-	
-end
-
-end
-
-end
-

data/lib/puppet/vendor/rgen/lib/rgen/util/model_dumper.rb

@@ -1,29 +0,0 @@
-module RGen
-
-module Util
-
-module ModelDumper
-
-	def dump(obj=nil)
-		obj ||= self
-		if obj.is_a?(Array)
-			obj.collect {|o| dump(o)}.join("\n\n")
-		elsif obj.class.respond_to?(:ecore)
-			([obj.to_s] +
-			obj.class.ecore.eAllStructuralFeatures.select{|f| !f.many}.collect { |a| 
-				"   #{a} => #{obj.getGeneric(a.name)}"
-			} +
-			obj.class.ecore.eAllStructuralFeatures.select{|f| f.many}.collect { |a|
-				"   #{a} => [ #{obj.getGeneric(a.name).join(', ')} ]"
-			}).join("\n")
-		else
-			obj.to_s
-		end
-	end
-
-end
-
-end
-
-end
-

data/lib/puppet/vendor/rgen/lib/rgen/util/name_helper.rb

@@ -1,42 +0,0 @@
-# RGen Framework
-# (c) Martin Thiede, 2006
-
-module RGen
-
-module Util
-
-module NameHelper
-
-	def normalize(name)
-		name.gsub(/\W/,'_')
-	end
-	
-	def className(object)
-		object.class.name =~ /::(\w+)$/; $1
-	end
-	
-	def firstToUpper(str)
-		str[0..0].upcase + ( str[1..-1] || "" )
-	end
-	
-	def firstToLower(str)
-		str[0..0].downcase + ( str[1..-1] || "" )
-	end
-	
-	def saneClassName(str)
-		firstToUpper(normalize(str)).sub(/^Class$/, 'Clazz')
-	end
-	
-	def saneMethodName(str)
-		firstToLower(normalize(str)).sub(/^class$/, 'clazz')
-	end	
-	
-  def camelize(str)
-    str.split(/[\W_]/).collect{|s| firstToUpper(s.downcase)}.join
-  end
-end
-
-end
-
-end
-

data/lib/puppet/vendor/rgen/lib/rgen/util/pattern_matcher.rb

@@ -1,329 +0,0 @@
-module RGen
-
-module Util
-
-# A PatternMatcher can be used to find, insert and remove patterns on a given model.
-#
-# A pattern is specified by means of a block passed to the add_pattern method.
-# The block must take an Environment as first parameter and at least one model element
-# as connection point as further parameter. The pattern matches if it can be found
-# in a given environment and connected to the given connection point elements.
-#
-class PatternMatcher
-
-  Match = Struct.new(:root, :elements, :bound_values)
-  attr_accessor :debug
-
-  def initialize
-    @patterns = {} 
-    @insert_mode = false
-    @debug = false
-  end
-
-  def add_pattern(name, &block)
-    raise "a pattern needs at least 2 block parameters: " + 
-      "an RGen environment and a model element as connection point" \
-      unless block.arity >= 2
-    @patterns[name] = block
-  end
-
-  def find_pattern(env, name, *connection_points)
-    match = find_pattern_internal(env, name, *connection_points)
-  end
-
-  def insert_pattern(env, name, *connection_points)
-    @insert_mode = true
-    root = evaluate_pattern(name, env, connection_points)
-    @insert_mode = false
-    root
-  end
-
-  def remove_pattern(env, name, *connection_points)
-    match = find_pattern_internal(env, name, *connection_points)
-    if match
-      match.elements.each do |e|
-        disconnect_element(e)
-        env.delete(e)
-      end
-      match
-    else
-      nil
-    end
-  end
-
-  def lazy(&block)
-    if @insert_mode
-      block.call
-    else
-      Lazy.new(&block)
-    end
-  end
-
-  class Lazy < RGen::MetamodelBuilder::MMGeneric
-    def initialize(&block)
-      @block = block
-    end
-    def _eval
-      @block.call
-    end
-  end
-
-  private
-
-  class Proxy < RGen::MetamodelBuilder::MMProxy
-    attr_reader :_target
-    def initialize(target)
-      @_target = target
-    end
-    def method_missing(m, *args)
-      result = @_target.send(m, *args)
-      if result.is_a?(Array)
-        result.collect do |e|
-          if e.is_a?(RGen::MetamodelBuilder::MMBase)
-            Proxy.new(e)
-          else
-            e
-          end
-        end
-      else
-        if result.is_a?(RGen::MetamodelBuilder::MMBase)
-          Proxy.new(result)
-        else
-          result 
-        end
-      end
-    end
-  end
-
-  class Bindable < RGen::MetamodelBuilder::MMGeneric
-    # by being an Enumerable, Bindables can be used for many-features as well
-    include Enumerable
-    def initialize
-      @bound = false
-      @value = nil
-      @many = false
-    end
-    def _bound?
-      @bound
-    end
-    def _many?
-      @many
-    end
-    def _bind(value)
-      @value = value
-      @bound = true
-    end
-    def _value
-      @value
-    end
-    def to_s
-      @value.to_s
-    end
-    # pretend this is an enumerable which contains itself, so the bindable can be
-    # inserted into many-features, when this is done the bindable is marked as a many-bindable
-    def each
-      @many = true
-      yield(self)
-    end
-    def method_missing(m, *args)
-      raise "bindable not bound" unless _bound?
-      @value.send(m, *args)
-    end
-  end
-
-  TempEnv = RGen::Environment.new
-  class << TempEnv
-    def <<(el); end
-  end
-
-  def find_pattern_internal(env, name, *connection_points)
-    proxied_args = connection_points.collect{|a| 
-      a.is_a?(RGen::MetamodelBuilder::MMBase) ?  Proxy.new(a) : a }
-    bindables = create_bindables(name, connection_points)
-    pattern_root = evaluate_pattern(name, TempEnv, proxied_args+bindables)
-    candidates = candidates_via_connection_points(pattern_root, connection_points)
-    candidates ||= env.find(:class => pattern_root.class)
-    candidates.each do |e|
-      # create new bindables for every try, otherwise they can could be bound to old values
-      bindables = create_bindables(name, connection_points) 
-      pattern_root = evaluate_pattern(name, TempEnv, proxied_args+bindables)
-      matched = match(pattern_root, e)
-      return Match.new(e, matched, bindables.collect{|b| b._value}) if matched 
-    end
-    nil
-  end
-
-  def create_bindables(pattern_name, connection_points)
-    (1..(num_pattern_variables(pattern_name) - connection_points.size)).collect{|i| Bindable.new}
-  end
-
-  def candidates_via_connection_points(pattern_root, connection_points)
-    @candidates_via_connection_points_refs ||= {}
-    refs = (@candidates_via_connection_points_refs[pattern_root.class] ||= 
-      pattern_root.class.ecore.eAllReferences.reject{|r| r.derived || r.many || !r.eOpposite})
-    candidates = nil 
-    refs.each do |r|
-      t = pattern_root.getGeneric(r.name)
-      cp = t.is_a?(Proxy) && connection_points.find{|cp| cp.object_id == t._target.object_id}
-      if cp
-        elements = cp.getGenericAsArray(r.eOpposite.name)
-        candidates = elements if candidates.nil? || elements.size < candidates.size 
-      end
-    end
-    candidates
-  end
-  
-  def match(pat_element, test_element)
-    visited = {}
-    check_later = []
-    return false unless match_internal(pat_element, test_element, visited, check_later)
-    while cl = check_later.shift
-      pv, tv = cl.lazy._eval, cl.value
-      if cl.feature.is_a?(RGen::ECore::EAttribute)
-        unless pv == tv
-          match_failed(cl.feature, "wrong attribute value (lazy): #{pv} vs. #{tv}")
-          return false 
-        end
-      else
-        if pv.is_a?(Proxy)
-          unless pv._target.object_id == tv.object_id
-            match_failed(f, "wrong target object")
-            return false 
-          end
-        else
-          unless (pv.nil? && tv.nil?) || (!pv.nil? && !tv.nil? && match_internal(pv, tv, visited, check_later))
-            return false 
-          end
-        end
-      end
-    end
-    visited.keys
-  end
-
-  CheckLater = Struct.new(:feature, :lazy, :value)
-  def match_internal(pat_element, test_element, visited, check_later)
-    return true if visited[test_element]
-    visited[test_element] = true
-    unless pat_element.class == test_element.class
-      match_failed(nil, "wrong class: #{pat_element.class} vs #{test_element.class}")
-      return false 
-    end
-    all_structural_features(pat_element).each do |f|
-      pat_values = pat_element.getGeneric(f.name)
-      # nil values must be kept to support size check with Bindables
-      pat_values = [ pat_values ] unless pat_values.is_a?(Array)
-      test_values = test_element.getGeneric(f.name)
-      test_values = [ test_values] unless test_values.is_a?(Array)
-      if pat_values.size == 1 && pat_values.first.is_a?(Bindable) && pat_values.first._many?
-        unless match_many_bindable(pat_values.first, test_values)
-          return false
-        end
-      else
-        unless pat_values.size == test_values.size
-          match_failed(f, "wrong size #{pat_values.size} vs. #{test_values.size}")
-          return false 
-        end
-        pat_values.each_with_index do |pv,i|
-          tv = test_values[i]
-          if pv.is_a?(Lazy)
-            check_later << CheckLater.new(f, pv, tv)
-          elsif pv.is_a?(Bindable)
-            if pv._bound?
-              unless pv._value == tv
-                match_failed(f, "value does not match bound value #{pv._value.class}:#{pv._value.object_id} vs. #{tv.class}:#{tv.object_id}")
-                return false 
-              end
-            else
-              pv._bind(tv)
-            end
-          else
-            if f.is_a?(RGen::ECore::EAttribute)
-              unless pv == tv 
-                match_failed(f, "wrong attribute value")
-                return false 
-              end
-            else
-              if pv.is_a?(Proxy)
-                unless pv._target.object_id == tv.object_id
-                  match_failed(f, "wrong target object")
-                  return false 
-                end
-              else
-                unless both_nil_or_match(pv, tv, visited, check_later)
-                  return false 
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-    true
-  end
-
-  def match_many_bindable(bindable, test_values)
-    if bindable._bound? 
-      bindable._value.each_with_index do |pv,i|
-        tv = test_values[i]
-        if f.is_a?(RGen::ECore::EAttribute)
-          unless pv == tv 
-            match_failed(f, "wrong attribute value")
-            return false 
-          end
-        else
-          unless both_nil_or_match(pv, tv, visited, check_later)
-            return false 
-          end
-        end
-      end
-    else
-      bindable._bind(test_values.dup)
-    end
-    true
-  end
-
-  def both_nil_or_match(pv, tv, visited, check_later)
-    (pv.nil? && tv.nil?) || (!pv.nil? && !tv.nil? && match_internal(pv, tv, visited, check_later))
-  end
-
-  def match_failed(f, msg)
-    puts "match failed #{f&&f.eContainingClass.name}##{f&&f.name}: #{msg}" if @debug
-  end
-
-  def num_pattern_variables(name)
-    prok = @patterns[name]
-    prok.arity - 1
-  end
-
-  def evaluate_pattern(name, env, connection_points)
-    prok = @patterns[name]
-    raise "unknown pattern #{name}" unless prok
-    raise "wrong number of arguments, expected #{prok.arity-1} connection points)" \
-      unless connection_points.size == prok.arity-1
-    prok.call(env, *connection_points)
-  end
-
-  def disconnect_element(element)
-    return if element.nil?
-    all_structural_features(element).each do |f|
-      if f.many
-        element.setGeneric(f.name, [])
-      else
-        element.setGeneric(f.name, nil)
-      end
-    end
-  end
-
-  def all_structural_features(element)
-    @all_structural_features ||= {}
-    return @all_structural_features[element.class] if @all_structural_features[element.class]
-    @all_structural_features[element.class] = 
-     element.class.ecore.eAllStructuralFeatures.reject{|f| f.derived}
-  end
-
-end
-
-end
-
-end
-