puppet 4.10.12-universal-darwin → 5.0.0-universal-darwin

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

@@ -1,61 +0,0 @@
-# RGen Framework
-# (c) Martin Thiede, 2006
-
-require 'rgen/metamodel_builder'
-
-module RGen
-
-module Util
-
-class Base
-	extend MetamodelBuilder
-	def initialize(env=nil)
-		env << self if env
-	end
-end
-
-class AutoCreatedClass < Base
-	def method_missing(m,*args)
-		return super unless self.class.parent.accEnabled
-		if m.to_s =~ /(.*)=$/ 
-			self.class.has_one($1)
-			send(m,args[0])
-		elsif args.size == 0
-			self.class.has_many(m)
-			send(m)
-		end
-	end
-end
-
-# will be "extended" to the auto created class
-module ParentAccess
-	def parent=(p)
-		@parent = p
-	end
-	def parent
-		@parent
-	end
-end
-
-module AutoClassCreator
-	attr_reader :accEnabled
-	def const_missing(className)
-		return super unless @accEnabled
-		module_eval("class "+className.to_s+" < RGen::AutoCreatedClass; end")
-		c = const_get(className)
-		c.extend(ParentAccess)
-		c.parent = self
-		c
-	end
-	def enableACC
-		@accEnabled = true
-	end
-	def disableACC
-		@accEnabled = false
-	end
-end
-
-end
-
-end
-

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

@@ -1,67 +0,0 @@
-module RGen
-
-module Util
-
-# WARNING: the mechanism of taking timestamps of directories in order to find out if the
-# content has changed doesn't work reliably across all kinds of filesystems
-#
-class CachedGlob
-
-  def initialize(dir_glob, file_glob)
-    @dir_glob = dir_glob
-    @file_glob = file_glob
-    @root_dirs = []
-    @dirs = {}
-    @files = {}
-    @timestamps = {}
-  end
-
-  # returns all files contained in directories matched by +dir_glob+ which match +file_glob+.
-  # +file_glob+ must be relative to +dir_glob+.
-  # dir_glob "*/a" with file_glob "**/*.txt" is basically equivalent with Dir.glob("*/a/**/*.txt")
-  # the idea is that the file glob will only be re-eavluated when the content of one of the 
-  # directories matched by dir_glob has changed.
-  # this will only be faster than a normal Dir.glob if the number of dirs matched by dir_glob is
-  # relatively large and changes in files affect only a few of them at a time.
-  def glob
-    root_dirs = Dir.glob(@dir_glob)
-    (@root_dirs - root_dirs).each do |d|
-      remove_root_dir(d)
-    end
-    (@root_dirs & root_dirs).each do |d|
-      update_root_dir(d) if dir_changed?(d)
-    end
-    (root_dirs - @root_dirs).each do |d|
-      update_root_dir(d)
-    end
-    @root_dirs = root_dirs
-    @root_dirs.sort.collect{|d| @files[d]}.flatten
-  end
-
-  private
-
-  def dir_changed?(dir)
-    @dirs[dir].any?{|d| File.mtime(d) != @timestamps[dir][d]}
-  end
-
-  def update_root_dir(dir)
-    @dirs[dir] = Dir.glob(dir+"/**/")
-    @files[dir] = Dir.glob(dir+"/"+@file_glob)
-    @timestamps[dir] = {}
-    @dirs[dir].each do |d|
-      @timestamps[dir][d] = File.mtime(d)
-    end
-  end
-
-  def remove_root_dir(dir)
-    @dirs.delete(dir)
-    @files.delete(dir)
-    @timestamps.delete(dir)
-  end
-
-end
-
-end
-
-end
-

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

@@ -1,124 +0,0 @@
-require 'digest'
-require 'fileutils'
-
-module RGen
-
-module Util
-
-# Implements a cache for storing and loading data associated with arbitrary files.
-# The data is stored in cache files within a subfolder of the folder where
-# the associated files exists.
-# The cache files are protected with a checksum and loaded data will be
-# invalid in case either the associated file are the cache file has changed.
-#
-class FileCacheMap
-  # optional program version info to be associated with the cache files
-  # if the program version changes, cached data will also be invalid
-  attr_accessor :version_info
-
-  # +cache_dir+ is the name of the subfolder where cache files are created
-  # +postfix+ is an extension appended to the original file name for 
-  # creating the name of the cache file
-  def initialize(cache_dir, postfix)
-    @postfix = postfix
-    @cache_dir = cache_dir
-  end
-
-  # load data associated with file +key_path+
-  # returns :invalid in case either the associated file or the cache file has changed
-  #
-  # options:
-  #  :invalidation_reasons:
-  #    an array which will receive symbols indicating why the cache is invalid:
-  #    :no_cachefile, :cachefile_corrupted, :keyfile_changed
-  #
-  def load_data(key_path, options={})
-    reasons = options[:invalidation_reasons] || []
-    cf = cache_file(key_path)
-    result = nil
-    begin
-      File.open(cf, "rb") do |f|
-        header = f.read(41)
-        if !header
-          reasons << :cachefile_corrupted
-          return :invalid
-        end
-        checksum = header[0..39]
-        data = f.read
-        if calc_sha1(data) == checksum
-          if calc_sha1_keydata(key_path) == data[0..39]
-            result = data[41..-1]
-          else
-            reasons << :keyfile_changed
-            result = :invalid
-          end
-        else
-          reasons << :cachefile_corrupted
-          result = :invalid
-        end
-      end 
-    rescue Errno::ENOENT
-      reasons << :no_cachefile
-      result = :invalid 
-    end
-    result
-  end
-
-  # store data +value_data+ associated with file +key_path+
-  def store_data(key_path, value_data)
-    data = calc_sha1_keydata(key_path) + "\n" + value_data
-    data = calc_sha1(data) + "\n" + data
-    cf = cache_file(key_path)
-    FileUtils.mkdir(File.dirname(cf)) rescue Errno::EEXIST
-    File.open(cf, "wb") do |f|
-      f.write(data)
-    end 
-  end
-
-  # remove cache files which are not associated with any file in +key_paths+
-  # will only remove files within +root_path+
-  def clean_unused(root_path, key_paths)
-    raise "key paths must be within root path" unless key_paths.all?{|p| p.index(root_path) == 0}
-    used_files = key_paths.collect{|p| cache_file(p)}
-    files = Dir[root_path+"/**/"+@cache_dir+"/*"+@postfix] 
-    files.each do |f|
-      FileUtils.rm(f) unless used_files.include?(f)
-    end
-  end
-
-private
-  
-  def cache_file(path)
-    File.dirname(path) + "/"+@cache_dir+"/" + File.basename(path) + @postfix 
-  end
-
-  def calc_sha1(data)
-    sha1 = Digest::SHA1.new
-    sha1.update(data)
-    sha1.hexdigest
-  end
-
-  def keyData(path)
-    File.read(path)+@version_info.to_s
-  end
-
-  # this method is much faster than calling +keyData+ and putting the result in +calc_sha1+
-  # reason is probably that there are not so many big strings being created
-  def calc_sha1_keydata(path)
-    begin
-      sha1 = Digest::SHA1.new
-      sha1.file(path)
-      sha1.update(@version_info.to_s)
-      sha1.hexdigest
-    rescue Errno::ENOENT
-      "<missing_key_file>"
-    end
-  end
-   
-end
-
-end
-
-end
-
-

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

@@ -1,84 +0,0 @@
-require 'digest'
-
-module RGen
-
-module Util
-
-# The FileChangeDetector detects changes in a set of files.
-# Changes are detected between successive calls to check_files with a give set of files.
-# Changes include files being added, removed or having changed their content.
-#
-class FileChangeDetector
-
-  FileInfo = Struct.new(:timestamp, :digest)
-
-  # Create a FileChangeDetector, options include:
-  #
-  #  :file_added
-  #    a proc which is called when a file is added, receives the filename
-  #
-  #  :file_removed
-  #    a proc which is called when a file is removed, receives the filename
-  #
-  #  :file_changed
-  #    a proc which is called when a file is changed, receives the filename
-  #
-  def initialize(options={})
-    @file_added = options[:file_added]
-    @file_removed = options[:file_removed]
-    @file_changed = options[:file_changed]
-    @file_info = {}
-  end
-
-  # Checks if any of the files has changed compared to the last call of check_files.
-  # When called for the first time on a new object, all files will be reported as being added.
-  # 
-  def check_files(files)
-    files_before = @file_info.keys
-    used_files = {} 
-    files.each do |file|
-      begin
-        if @file_info[file]
-          if @file_info[file].timestamp != File.mtime(file)
-            @file_info[file].timestamp = File.mtime(file)
-            digest = calc_digest(file)
-            if @file_info[file].digest != digest
-              @file_info[file].digest = digest 
-              @file_changed && @file_changed.call(file)
-            end
-          end
-        else
-          @file_info[file] = FileInfo.new
-          @file_info[file].timestamp = File.mtime(file)
-          @file_info[file].digest = calc_digest(file)
-          @file_added && @file_added.call(file)
-        end
-        used_files[file] = true
-      # protect against missing files
-      rescue Errno::ENOENT
-        # used_files is not set and @file_info will be removed below
-        # notification hook hasn't been called yet since it comes after file accesses
-      end
-    end
-    files_before.each do |file|
-      if !used_files[file]
-        @file_info.delete(file)
-        @file_removed && @file_removed.call(file)
-      end
-    end
-  end
-
-  private
-
-  def calc_digest(file)
-    sha1 = Digest::SHA1.new
-    sha1.file(file)
-    sha1.hexdigest
-  end
-
-end
-
-end
-
-end
-

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

@@ -1,114 +0,0 @@
-module RGen
-
-module Util
-  
-module MethodDelegation
-
-class << self
-  
-  def registerDelegate(delegate, object, method)
-    method = method.to_sym
-    createDelegateStore(object)
-    if object._methodDelegates[method]
-      object._methodDelegates[method] << delegate
-    else
-      object._methodDelegates[method] = [delegate]
-      createDelegatingMethod(object, method)
-    end
-  end
-  
-  def unregisterDelegate(delegate, object, method)
-    method = method.to_sym
-    return unless object.respond_to?(:_methodDelegates)
-    return unless object._methodDelegates[method]
-    object._methodDelegates[method].delete(delegate)
-    if object._methodDelegates[method].empty?
-      object._methodDelegates[method] = nil
-      removeDelegatingMethod(object, method)
-      removeDelegateStore(object)
-    end
-  end
-
-  private
-  
-  def createDelegateStore(object)
-    return if object.respond_to?(:_methodDelegates)
-    class << object
-      def _methodDelegates
-        @_methodDelegates ||= {}
-      end
-    end
-  end
-  
-  def removeDelegateStore(object)
-    return unless object.respond_to?(:_methodDelegates)
-    class << object
-      remove_method(:_methodDelegates)
-    end
-  end
-  
-  def createDelegatingMethod(object, method)
-    if hasMethod(object, method)
-      object.instance_eval <<-END
-        class << self
-          alias #{aliasMethodName(method)} #{method}
-        end
-      END
-    end
-    
-    # define the delegating method
-    object.instance_eval <<-END
-      class << self
-        def #{method}(*args, &block)
-          @_methodDelegates[:#{method}].each do |d|
-            catch(:continue) do
-              return d.#{method}_delegated(self, *args, &block)
-            end
-          end
-          # if aliased method does not exist, we want an exception
-          #{aliasMethodName(method)}(*args, &block)
-        end
-      end
-    END
-  end
-
-  def removeDelegatingMethod(object, method)
-    if hasMethod(object, aliasMethodName(method))
-      # there is an aliased original, restore it
-      object.instance_eval <<-END
-        class << self
-          alias #{method} #{aliasMethodName(method)}
-          remove_method(:#{aliasMethodName(method)})
-        end
-      END
-    else
-      # just delete the delegating method
-      object.instance_eval <<-END
-        class << self
-          remove_method(:#{method})
-        end
-      END
-    end
-  end
-  
-  def hasMethod(object, method)
-    # in Ruby 1.9, #methods returns symbols
-    if object.methods.first.is_a?(Symbol)
-      method = method.to_sym
-    else
-      method = method.to_s
-    end
-    object.methods.include?(method)
-  end
-
-  def aliasMethodName(method)
-    "#{method}_delegate_original"
-  end    
-end
-
-end
-
-end
-
-end
-