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

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

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

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

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

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

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