bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/gettext/config.rb

@@ -1,252 +0,0 @@
-require 'puppet/util/platform'
-require 'puppet/file_system'
-
-module Puppet::GettextConfig
-  LOCAL_PATH = File.absolute_path('../../../locales', File.dirname(__FILE__))
-  POSIX_PATH = File.absolute_path('../../../../../share/locale', File.dirname(__FILE__))
-  WINDOWS_PATH = File.absolute_path('../../../../../../../puppet/share/locale', File.dirname(__FILE__))
-
-  DEFAULT_TEXT_DOMAIN = 'default-text-domain'
-
-  # Load gettext helpers and track whether they're available.
-  # Used instead of features because we initialize gettext before features is available.
-  begin
-    require 'fast_gettext'
-    require 'locale'
-
-    # Make translation methods (e.g. `_()` and `n_()`) available everywhere.
-    class ::Object
-      include FastGettext::Translation
-    end
-
-    @gettext_loaded = true
-  rescue LoadError
-    # Stub out gettext's `_` and `n_()` methods, which attempt to load translations,
-    # with versions that do nothing
-    require 'puppet/gettext/stubs'
-    @gettext_loaded = false
-  end
-
-  # @api private
-  # Whether we were able to require fast_gettext and locale
-  # @return [Boolean] true if translation gems were successfully loaded
-  def self.gettext_loaded?
-    @gettext_loaded
-  end
-
-  # @api private
-  # Returns the currently selected locale from FastGettext,
-  # or 'en' of gettext has not been loaded
-  # @return [String] the active locale
-  def self.current_locale
-    if gettext_loaded?
-      return FastGettext.default_locale
-    else
-      return 'en'
-    end
-  end
-
-  # @api private
-  # Returns a list of the names of the loaded text domains
-  # @return [[String]] the names of the loaded text domains
-  def self.loaded_text_domains
-    return [] if @gettext_disabled || !gettext_loaded?
-
-    return FastGettext.translation_repositories.keys
-  end
-
-  # @api private
-  # Clears the translation repository for the given text domain,
-  # creating it if it doesn't exist, then adds default translations
-  # and switches to using this domain.
-  # @param [String] domain_name the name of the domain to create
-  def self.reset_text_domain(domain_name)
-    return if @gettext_disabled || !gettext_loaded?
-
-    FastGettext.add_text_domain(domain_name,
-                                type: :chain,
-                                chain: [],
-                                report_warning: false)
-    copy_default_translations(domain_name)
-    FastGettext.text_domain = domain_name
-  end
-
-  # @api private
-  # Creates a default text domain containing the translations for
-  # Puppet as the start of chain. When semantic_puppet gets initialized,
-  # its translations are added to this chain. This is used as a cache
-  # so that all non-module translations only need to be loaded once as
-  # we create and reset environment-specific text domains.
-  #
-  # @return true if Puppet translations were successfully loaded, false
-  # otherwise
-  def self.create_default_text_domain
-    return if @gettext_disabled || !gettext_loaded?
-
-    FastGettext.add_text_domain(DEFAULT_TEXT_DOMAIN,
-                                type: :chain,
-                                chain: [],
-                                report_warning: false)
-    FastGettext.default_text_domain = DEFAULT_TEXT_DOMAIN
-
-    load_translations('puppet', puppet_locale_path, translation_mode(puppet_locale_path), DEFAULT_TEXT_DOMAIN)
-  end
-
-  # @api private
-  # Switches the active text domain, if the requested domain exists.
-  # @param [String] domain_name the name of the domain to switch to
-  def self.use_text_domain(domain_name)
-    return if @gettext_disabled || !gettext_loaded?
-
-    if FastGettext.translation_repositories.include?(domain_name)
-      FastGettext.text_domain = domain_name
-    end
-  end
-
-  # @api private
-  # Delete all text domains.
-  def self.delete_all_text_domains
-    FastGettext.translation_repositories.clear
-    FastGettext.default_text_domain = nil
-    FastGettext.text_domain = nil
-  end
-
-  # @api private
-  # Deletes the text domain with the given name
-  # @param [String] domain_name the name of the domain to delete
-  def self.delete_text_domain(domain_name)
-    return if @gettext_disabled || !gettext_loaded?
-
-    FastGettext.translation_repositories.delete(domain_name)
-    if FastGettext.text_domain == domain_name
-      FastGettext.text_domain = nil
-    end
-  end
-
-  # @api private
-  # Deletes all text domains except the default one
-  def self.delete_environment_text_domains
-    return if @gettext_disabled || !gettext_loaded?
-
-    FastGettext.translation_repositories.keys.each do |key|
-      # do not clear default translations
-      next if key == DEFAULT_TEXT_DOMAIN
-
-      FastGettext.translation_repositories.delete(key)
-    end
-    FastGettext.text_domain = nil
-  end
-
-  # @api private
-  # Adds translations from the default text domain to the specified
-  # text domain. Creates the default text domain if one does not exist
-  # (this will load Puppet's translations).
-  #
-  # Since we are currently (Nov 2017) vendoring semantic_puppet, in normal
-  # flows these translations will be copied along with Puppet's.
-  #
-  # @param [String] domain_name the name of the domain to add translations to
-  def self.copy_default_translations(domain_name)
-    return if @gettext_disabled || !gettext_loaded?
-
-    if FastGettext.default_text_domain.nil?
-      create_default_text_domain
-    end
-
-    puppet_translations = FastGettext.translation_repositories[FastGettext.default_text_domain].chain
-    FastGettext.translation_repositories[domain_name].chain.push(*puppet_translations)
-  end
-
-  # @api private
-  # Search for puppet gettext config files
-  # @return [String] path to the config, or nil if not found
-  def self.puppet_locale_path
-    if Puppet::FileSystem.exist?(LOCAL_PATH)
-      return LOCAL_PATH
-    elsif Puppet::Util::Platform.windows? && Puppet::FileSystem.exist?(WINDOWS_PATH)
-      return WINDOWS_PATH
-    elsif !Puppet::Util::Platform.windows? && Puppet::FileSystem.exist?(POSIX_PATH)
-      return POSIX_PATH
-    else
-      nil
-    end
-  end
-
-  # @api private
-  # Determine which translation file format to use
-  # @param [String] conf_path the path to the gettext config file
-  # @return [Symbol] :mo if in a package structure, :po otherwise
-  def self.translation_mode(conf_path)
-    if WINDOWS_PATH == conf_path || POSIX_PATH == conf_path
-      return :mo
-    else
-      return :po
-    end
-  end
-
-  # @api private
-  # Prevent future gettext initializations
-  def self.disable_gettext
-    @gettext_disabled = true
-  end
-
-  # @api private
-  # Attempt to load translations for the given project.
-  # @param [String] project_name the project whose translations we want to load
-  # @param [String] locale_dir the path to the directory containing translations
-  # @param [Symbol] file_format translation file format to use, either :po or :mo
-  # @return true if initialization succeeded, false otherwise
-  def self.load_translations(project_name, locale_dir, file_format, text_domain = FastGettext.text_domain)
-    if project_name.nil? || project_name.empty?
-      raise Puppet::Error, "A project name must be specified in order to initialize translations."
-    end
-
-    return false if @gettext_disabled || !@gettext_loaded
-
-    return false unless locale_dir && Puppet::FileSystem.exist?(locale_dir)
-
-    unless file_format == :po || file_format == :mo
-      raise Puppet::Error, "Unsupported translation file format #{file_format}; please use :po or :mo"
-    end
-
-    add_repository_to_domain(project_name, locale_dir, file_format, text_domain)
-    return true
-  end
-
-  # @api private
-  # Add the translations for this project to the domain's repository chain
-  # chain for the currently selected text domain, if needed.
-  # @param [String] project_name the name of the project for which to load translations
-  # @param [String] locale_dir the path to the directory containing translations
-  # @param [Symbol] file_format the format of the translations files, :po or :mo
-  def self.add_repository_to_domain(project_name, locale_dir, file_format, text_domain = FastGettext.text_domain)
-    return if @gettext_disabled || !gettext_loaded?
-
-    current_chain = FastGettext.translation_repositories[text_domain].chain
-
-    repository = FastGettext::TranslationRepository.build(project_name,
-                                                          path: locale_dir,
-                                                          type: file_format,
-                                                          report_warning: false)
-    current_chain << repository
-  end
-
-  # @api private
-  # Sets FastGettext's locale to the current system locale
-  def self.setup_locale
-    return if @gettext_disabled || !gettext_loaded?
-
-    set_locale(Locale.current.language)
-  end
-
-  # @api private
-  # Sets the language in which to display strings.
-  # @param [String] locale the language portion of a locale string (e.g. "ja")
-  def self.set_locale(locale)
-    return if @gettext_disabled || !gettext_loaded?
-    # make sure we're not using the `available_locales` machinery
-    FastGettext.default_available_locales = nil
-
-    FastGettext.default_locale = locale
-  end
-end

data/vendored/puppet/lib/puppet/gettext/module_translations.rb

@@ -1,42 +0,0 @@
-require 'puppet/gettext/config'
-
-module Puppet::ModuleTranslations
-
-  # @api private
-  # Loads translation files for each of the specified modules,
-  # if present. Requires the modules to have `forge_name` specified.
-  # @param [[Module]] modules a list of modules for which to
-  #        load translations
-  def self.load_from_modulepath(modules)
-    modules.each do |mod|
-      next unless mod.forge_name && mod.has_translations?(Puppet::GettextConfig.current_locale)
-
-      module_name = mod.forge_name.gsub('/', '-')
-      if Puppet::GettextConfig.load_translations(module_name, mod.locale_directory, :po)
-        Puppet.debug "Loaded translations for #{module_name}."
-      elsif Puppet::GettextConfig.gettext_loaded?
-        Puppet.debug "Could not find translation files for #{module_name} at #{mod.locale_directory}. Skipping translation initialization."
-      else
-        Puppet.warn_once("gettext_unavailable", "gettext_unavailable", "No gettext library found, skipping translation initialization.")
-      end
-    end
-  end
-
-  # @api private
-  # Loads translation files that have been pluginsync'd for modules
-  # from the $vardir.
-  # @param [String] vardir the path to Puppet's vardir
-  def self.load_from_vardir(vardir)
-    locale = Puppet::GettextConfig.current_locale
-    Dir.glob("#{vardir}/locales/#{locale}/*.po") do |f|
-      module_name = File.basename(f, ".po")
-      if Puppet::GettextConfig.load_translations(module_name, File.join(vardir, "locales"), :po)
-        Puppet.debug "Loaded translations for #{module_name}."
-      elsif Puppet::GettextConfig.gettext_loaded?
-        Puppet.debug "Could not load translations for #{module_name}."
-      else
-        Puppet.warn_once("gettext_unavailable", "gettext_unavailable", "No gettext library found, skipping translation initialization.")
-      end
-    end
-  end
-end

data/vendored/puppet/lib/puppet/gettext/stubs.rb

@@ -1,11 +0,0 @@
-# These stub the translation methods normally brought in
-# by FastGettext. Used when Gettext could not be properly
-# initialized.
-def _(msg)
-  msg
-end
-
-def n_(*args, &block)
-  plural = args[2] == 1 ? args[0] : args[1]
-  block ? block.call : plural
-end

data/vendored/puppet/lib/puppet/graph.rb

@@ -1,11 +0,0 @@
-module Puppet::Graph
-  require 'puppet/graph/prioritizer'
-  require 'puppet/graph/sequential_prioritizer'
-  require 'puppet/graph/title_hash_prioritizer'
-  require 'puppet/graph/random_prioritizer'
-
-  require 'puppet/graph/simple_graph'
-  require 'puppet/graph/rb_tree_map'
-  require 'puppet/graph/key'
-  require 'puppet/graph/relationship_graph'
-end

data/vendored/puppet/lib/puppet/graph/key.rb

@@ -1,26 +0,0 @@
-# Sequential, nestable keys for tracking order of insertion in "the graph"
-# @api private
-class Puppet::Graph::Key
-  include Comparable
-
-  attr_reader :value
-  protected :value
-
-  def initialize(value = [0])
-    @value = value
-  end
-
-  def next
-    next_values = @value.clone
-    next_values[-1] += 1
-    Puppet::Graph::Key.new(next_values)
-  end
-
-  def down
-    Puppet::Graph::Key.new(@value + [0])
-  end
-
-  def <=>(other)
-    @value <=> other.value
-  end
-end

data/vendored/puppet/lib/puppet/graph/prioritizer.rb

@@ -1,29 +0,0 @@
-# Base, template method, class for Prioritizers. This provides the basic
-# tracking facilities used.
-#
-# @api private
-class Puppet::Graph::Prioritizer
-  def initialize
-    @priority = {}
-  end
-
-  def forget(key)
-    @priority.delete(key)
-  end
-
-  def record_priority_for(key, priority)
-    @priority[key] = priority
-  end
-
-  def generate_priority_for(key)
-    raise NotImplementedError
-  end
-
-  def generate_priority_contained_in(container, key)
-    raise NotImplementedError
-  end
-
-  def priority_of(key)
-    @priority[key]
-  end
-end

data/vendored/puppet/lib/puppet/graph/random_prioritizer.rb

@@ -1,16 +0,0 @@
-# Assign a random priority to items.
-#
-# @api private
-class Puppet::Graph::RandomPrioritizer < Puppet::Graph::Prioritizer
-  def generate_priority_for(key)
-    if priority_of(key).nil?
-      record_priority_for(key, SecureRandom.uuid)
-    else
-      priority_of(key)
-    end
-  end
-
-  def generate_priority_contained_in(container, key)
-    generate_priority_for(key)
-  end
-end

data/vendored/puppet/lib/puppet/graph/rb_tree_map.rb

@@ -1,388 +0,0 @@
-# Algorithms and Containers project is Copyright (c) 2009 Kanwei Li
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the 'Software'), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-#
-# A RbTreeMap is a map that is stored in sorted order based on the order of its keys. This ordering is
-# determined by applying the function <=> to compare the keys. No duplicate values for keys are allowed,
-# so duplicate values are overwritten.
-#
-# A major advantage of RBTreeMap over a Hash is the fact that keys are stored in order and can thus be
-# iterated over in order. This is useful for many datasets.
-#
-# The implementation is adapted from Robert Sedgewick's Left Leaning Red-Black Tree implementation,
-# which can be found at https://www.cs.princeton.edu/~rs/talks/LLRB/Java/RedBlackBST.java
-#
-# Most methods have O(log n) complexity.
-
-class Puppet::Graph::RbTreeMap
-  include Enumerable
-
-  attr_reader :size
-
-  alias_method :length, :size
-
-  # Create and initialize a new empty TreeMap.
-  def initialize
-    @root = nil
-    @size = 0
-  end
-
-  # Insert an item with an associated key into the TreeMap, and returns the item inserted
-  #
-  # Complexity: O(log n)
-  #
-  # map = Containers::TreeMap.new
-  # map.push("MA", "Massachusetts") #=> "Massachusetts"
-  # map.get("MA") #=> "Massachusetts"
-  def push(key, value)
-    @root = insert(@root, key, value)
-    @root.color = :black
-    value
-  end
-  alias_method :[]=, :push
-
-  # Return true if key is found in the TreeMap, false otherwise
-  #
-  # Complexity: O(log n)
-  #
-  #   map = Containers::TreeMap.new
-  #   map.push("MA", "Massachusetts")
-  #   map.push("GA", "Georgia")
-  #   map.has_key?("GA") #=> true
-  #   map.has_key?("DE") #=> false
-  def has_key?(key)
-    !get_recursive(@root, key).nil?
-  end
-
-  # Return the item associated with the key, or nil if none found.
-  #
-  # Complexity: O(log n)
-  #
-  #   map = Containers::TreeMap.new
-  #   map.push("MA", "Massachusetts")
-  #   map.push("GA", "Georgia")
-  #   map.get("GA") #=> "Georgia"
-  def get(key)
-    node = get_recursive(@root, key)
-    node ? node.value : nil
-    node.value if node
-  end
-  alias_method :[], :get
-
-  # Return the smallest key in the map.
-  #
-  # Complexity: O(log n)
-  #
-  #   map = Containers::TreeMap.new
-  #   map.push("MA", "Massachusetts")
-  #   map.push("GA", "Georgia")
-  #   map.min_key #=> "GA"
-  def min_key
-    @root.nil? ? nil : min_recursive(@root).key
-  end
-
-  # Return the largest key in the map.
-  #
-  # Complexity: O(log n)
-  #
-  #   map = Containers::TreeMap.new
-  #   map.push("MA", "Massachusetts")
-  #   map.push("GA", "Georgia")
-  #   map.max_key #=> "MA"
-  def max_key
-    @root.nil? ? nil : max_recursive(@root).key
-  end
-
-  # Deletes the item and key if it's found, and returns the item. Returns nil
-  # if key is not present.
-  #
-  # Complexity: O(log n)
-  #
-  #   map = Containers::TreeMap.new
-  #   map.push("MA", "Massachusetts")
-  #   map.push("GA", "Georgia")
-  #   map.delete("MA") #=> "Massachusetts"
-  def delete(key)
-    result = nil
-    if @root
-      return unless has_key? key
-      @root, result = delete_recursive(@root, key)
-      @root.color = :black if @root
-      @size -= 1
-    end
-    result
-  end
-
-  # Returns true if the tree is empty, false otherwise
-  def empty?
-    @root.nil?
-  end
-
-  # Deletes the item with the smallest key and returns the item. Returns nil
-  # if key is not present.
-  #
-  # Complexity: O(log n)
-  #
-  #   map = Containers::TreeMap.new
-  #   map.push("MA", "Massachusetts")
-  #   map.push("GA", "Georgia")
-  #   map.delete_min #=> "Massachusetts"
-  #   map.size #=> 1
-  def delete_min
-    result = nil
-    if @root
-      @root, result = delete_min_recursive(@root)
-      @root.color = :black if @root
-      @size -= 1
-    end
-    result
-  end
-
-  # Deletes the item with the largest key and returns the item. Returns nil
-  # if key is not present.
-  #
-  # Complexity: O(log n)
-  #
-  #   map = Containers::TreeMap.new
-  #   map.push("MA", "Massachusetts")
-  #   map.push("GA", "Georgia")
-  #   map.delete_max #=> "Georgia"
-  #   map.size #=> 1
-  def delete_max
-    result = nil
-    if @root
-      @root, result = delete_max_recursive(@root)
-      @root.color = :black if @root
-      @size -= 1
-    end
-    result
-  end
-
-  # Yields [key, value] pairs in order by key.
-  def each(&blk)
-    recursive_yield(@root, &blk)
-  end
-
-  def first
-    return nil unless @root
-    node = min_recursive(@root)
-    [node.key, node.value]
-  end
-
-  def last
-    return nil unless @root
-    node = max_recursive(@root)
-    [node.key, node.value]
-  end
-
-  def to_hash
-    @root ? @root.to_hash : {}
-  end
-
-  class Node # :nodoc: all
-    attr_accessor :color, :key, :value, :left, :right
-    def initialize(key, value)
-      @key = key
-      @value = value
-      @color = :red
-      @left = nil
-      @right = nil
-    end
-
-    def to_hash
-      h = {
-        :node => {
-          :key => @key,
-          :value => @value,
-          :color => @color,
-        }
-      }
-      h.merge!(:left => left.to_hash) if @left
-      h.merge!(:right => right.to_hash) if @right
-      h
-    end
-
-    def red?
-      @color == :red
-    end
-
-    def colorflip
-      @color       = @color == :red       ? :black : :red
-      @left.color  = @left.color == :red  ? :black : :red
-      @right.color = @right.color == :red ? :black : :red
-    end
-
-    def rotate_left
-      r = @right
-      r_key, r_value = r.key, r.value
-      b = r.left
-      r.left = @left
-      @left = r
-      @right = r.right
-      r.right = b
-      r.color, r.key, r.value = :red, @key, @value
-      @key, @value = r_key, r_value
-      self
-    end
-
-    def rotate_right
-      l = @left
-      l_key, l_value = l.key, l.value
-      b = l.right
-      l.right = @right
-      @right = l
-      @left = l.left
-      l.left = b
-      l.color, l.key, l.value = :red, @key, @value
-      @key, @value = l_key, l_value
-      self
-    end
-
-    def move_red_left
-      colorflip
-      if (@right.left && @right.left.red?)
-        @right.rotate_right
-        rotate_left
-        colorflip
-      end
-      self
-    end
-
-    def move_red_right
-      colorflip
-      if (@left.left && @left.left.red?)
-        rotate_right
-        colorflip
-      end
-      self
-    end
-
-    def fixup
-      rotate_left if @right && @right.red?
-      rotate_right if (@left && @left.red?) && (@left.left && @left.left.red?)
-      colorflip if (@left && @left.red?) && (@right && @right.red?)
-
-      self
-    end
-  end
-
-  private
-
-  def recursive_yield(node, &blk)
-    return unless node
-    recursive_yield(node.left, &blk)
-    yield node.key, node.value
-    recursive_yield(node.right, &blk)
-  end
-
-  def delete_recursive(node, key)
-    if (key <=> node.key) == -1
-      node.move_red_left if ( !isred(node.left) && !isred(node.left.left) )
-      node.left, result = delete_recursive(node.left, key)
-    else
-      node.rotate_right if isred(node.left)
-      if ( ( (key <=> node.key) == 0) && node.right.nil? )
-        return nil, node.value
-      end
-      if ( !isred(node.right) && !isred(node.right.left) )
-        node.move_red_right
-      end
-      if (key <=> node.key) == 0
-        result = node.value
-        min_child = min_recursive(node.right)
-        node.value = min_child.value
-        node.key = min_child.key
-        node.right = delete_min_recursive(node.right).first
-      else
-        node.right, result = delete_recursive(node.right, key)
-      end
-    end
-    return node.fixup, result
-  end
-
-  def delete_min_recursive(node)
-    if node.left.nil?
-      return nil, node.value
-    end
-    if ( !isred(node.left) && !isred(node.left.left) )
-      node.move_red_left
-    end
-    node.left, result = delete_min_recursive(node.left)
-
-    return node.fixup, result
-  end
-
-  def delete_max_recursive(node)
-    if (isred(node.left))
-      node = node.rotate_right
-    end
-    return nil, node.value if node.right.nil?
-    if ( !isred(node.right) && !isred(node.right.left) )
-      node.move_red_right
-    end
-    node.right, result = delete_max_recursive(node.right)
-
-    return node.fixup, result
-  end
-
-  def get_recursive(node, key)
-    return nil if node.nil?
-    case key <=> node.key
-    when  0 then return node
-    when -1 then return get_recursive(node.left, key)
-    when  1 then return get_recursive(node.right, key)
-    end
-  end
-
-  def min_recursive(node)
-    return node if node.left.nil?
-
-    min_recursive(node.left)
-  end
-
-  def max_recursive(node)
-    return node if node.right.nil?
-
-    max_recursive(node.right)
-  end
-
-  def insert(node, key, value)
-    unless node
-      @size += 1
-      return Node.new(key, value)
-    end
-
-    case key <=> node.key
-    when  0 then node.value = value
-    when -1 then node.left = insert(node.left, key, value)
-    when  1 then node.right = insert(node.right, key, value)
-    end
-
-    node.rotate_left if (node.right && node.right.red?)
-    node.rotate_right if (node.left && node.left.red? && node.left.left && node.left.left.red?)
-    node.colorflip if (node.left && node.left.red? && node.right && node.right.red?)
-    node
-  end
-
-  def isred(node)
-    return false if node.nil?
-
-    node.color == :red
-  end
-end