bolt 0.7.0 → 0.8.0

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

@@ -10,19 +10,58 @@ module Puppet::GettextConfig
   # Used instead of features because we initialize gettext before features is available.
   # Stubbing gettext if unavailable is handled in puppet.rb.
   begin
-    require 'gettext-setup'
+    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
 
-  # Whether we were able to require gettext-setup and locale
-  # @return [Boolean] true if gettext-setup was successfully loaded
+  # @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
+  # Whether translations have been loaded for a given project
+  # @param project_name [String] the project whose translations we are querying
+  # @return [Boolean] true if translations have been loaded for the project
+  def self.translations_loaded?(project_name)
+    return false unless gettext_loaded?
+    if @loaded_repositories[project_name]
+      return true
+    else
+      return false
+    end
+  end
+
+  # @api private
+  # Creates a new empty text domain with the given name, replacing
+  # any existing domain with that name, then switches to using
+  # that domain. Also clears the cache of loaded translations.
+  # @param domain_name [String] the name of the domain to create
+  def self.create_text_domain(domain_name)
+    return unless gettext_loaded?
+    # Clear the cache of loaded translation repositories
+    @loaded_repositories = {}
+    FastGettext.add_text_domain(domain_name, type: :chain, chain: [])
+    #TODO remove this when we start managing domains per environment
+    FastGettext.default_text_domain = domain_name
+    FastGettext.text_domain = domain_name
+  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
@@ -37,6 +76,7 @@ module Puppet::GettextConfig
     end
   end
 
+  # @api private
   # Determine which translation file format to use
   # @param conf_path [String] the path to the gettext config file
   # @return [Symbol] :mo if in a package structure, :po otherwise
@@ -48,44 +88,62 @@ module Puppet::GettextConfig
     end
   end
 
+  # @api private
   # Prevent future gettext initializations
   def self.disable_gettext
     @gettext_disabled = true
   end
 
-  # Attempt to initialize the gettext-setup gem
-  # @param path [String] to gettext config file
+  # @api private
+  # Attempt to load tranlstions for the given project.
+  # @param project_name [String] the project whose translations we want to load
+  # @param locale_dir [String] the path to the directory containing translations
   # @param file_format [Symbol] translation file format to use, either :po or :mo
   # @return true if initialization succeeded, false otherwise
-  def self.initialize(conf_file_dir, file_format)
+  def self.load_translations(project_name, locale_dir, file_format)
     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
 
-    return false if conf_file_dir.nil?
-
-    conf_file = File.join(conf_file_dir, "config.yaml")
-    if Puppet::FileSystem.exist?(conf_file)
-      if GettextSetup.method(:initialize).parameters.count == 1
-        # For use with old gettext-setup gem versions, will load PO files only
-        GettextSetup.initialize(conf_file_dir)
-      else
-        GettextSetup.initialize(conf_file_dir, :file_format => file_format)
-      end
-      # Only change this once.
-      # Because negotiate_locales will only return a non-default locale if
-      # the system locale matches a translation set actually available for the
-      # given gettext project, we don't want this to get set back to default if
-      # we load a module that doesn't have translations, but Puppet does have
-      # translations for the user's locale.
-      if FastGettext.locale == GettextSetup.default_locale
-        FastGettext.locale = GettextSetup.negotiate_locale(Locale.current.language)
-      end
-      true
-    else
-      false
+    if project_name.nil? || project_name.empty?
+      raise Puppet::Error, "A project name must be specified in order to initialize translations."
     end
+
+    add_repository_to_domain(project_name, locale_dir, file_format)
+    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 project_name [String] the name of the project for which to load translations
+  # @param locale_dir [String] the path to the directory containing translations
+  # @param file_format [Symbol] the fomat of the translations files, :po or :mo
+  def self.add_repository_to_domain(project_name, locale_dir, file_format)
+    # check if we've already loaded these transltaions
+    current_chain = FastGettext.translation_repositories[FastGettext.text_domain].chain
+    return current_chain if @loaded_repositories[project_name]
+
+    repository = FastGettext::TranslationRepository.build(project_name,
+                                                          path: locale_dir,
+                                                          type: file_format,
+                                                          ignore_fuzzy: false)
+    @loaded_repositories[project_name] = true
+    current_chain << repository
+  end
+
+  # @api private
+  # Sets the language in which to display strings.
+  # @param locale [String] the language portion of a locale string (e.g. "ja")
+  def self.set_locale(locale)
+    return if !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/indirector/catalog/compiler.rb

@@ -129,10 +129,13 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
   def inlineable?(resource, sources)
     case
       when resource[:ensure] == 'absent'
+        #TRANSLATORS Inlining refers to adding additional metadata (in this case we are not inlining)
         return Puppet::Util::Profiler.profile(_("Not inlining absent resource"), [:compiler, :static_compile_inlining, :skipped_file_metadata, :absent]) { false }
       when sources.empty?
+        #TRANSLATORS Inlining refers to adding additional metadata (in this case we are not inlining)
         return Puppet::Util::Profiler.profile(_("Not inlining resource without sources"), [:compiler, :static_compile_inlining, :skipped_file_metadata, :no_sources]) { false }
       when (not (sources.all? {|source| source =~ /^puppet:/}))
+        #TRANSLATORS Inlining refers to adding additional metadata (in this case we are not inlining)
         return Puppet::Util::Profiler.profile(_("Not inlining unsupported source scheme"), [:compiler, :static_compile_inlining, :skipped_file_metadata, :unsupported_scheme]) { false }
       else
         return true
@@ -154,11 +157,13 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
   # Helper method to log file resources that could not be inlined because they
   # fall outside of an environment.
   def log_file_outside_environment
+    #TRANSLATORS Inlining refers to adding additional metadata (in this case we are not inlining)
     Puppet::Util::Profiler.profile(_("Not inlining file outside environment"), [:compiler, :static_compile_inlining, :skipped_file_metadata, :file_outside_environment]) { true }
   end
 
   # Helper method to log file resources that were successfully inlined.
   def log_metadata_inlining
+    #TRANSLATORS Inlining refers to adding additional metadata
     Puppet::Util::Profiler.profile(_("Inlining file metadata"), [:compiler, :static_compile_inlining, :inlined_file_metadata]) { true }
   end
 
@@ -270,9 +275,19 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
       raise Puppet::Error, _("Unable to find a common checksum type between agent '%{agent_type}' and master '%{master_type}'.") % { agent_type: options[:checksum_type], master_type: known_checksum_types } unless checksum_type
     end
 
-    str = _("Compiled %s for ") % (checksum_type ? _('static catalog') : _('catalog'))
-    str += node.name
-    str += _(" in environment %{env}") % { env: node.environment } if node.environment
+    str = if checksum_type
+            if node.environment
+              _("Compiled static catalog for %{node} in environment %{environment}") % { node: node.name, environment: node.environment }
+            else
+              _("Compiled static catalog for %{node}") % { node: node.name }
+            end
+          else
+            if node.environment
+              _("Compiled catalog for %{node} in environment %{environment}") % { node: node.name, environment: node.environment }
+            else
+              _("Compiled catalog for %{node}") % { node: node.name }
+            end
+          end
     config = nil
 
     benchmark(:notice, str) do
@@ -288,8 +303,13 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
         end
 
         if checksum_type && config.is_a?(model)
-          str = _("Inlined resource metadata into static catalog for %{node}") % { node: node.name }
-          str += _(" in environment %{env}") % { env: node.environment } if node.environment
+          str = if node.environment
+                  #TRANSLATORS Inlined refers to adding additional metadata
+                  _("Inlined resource metadata into static catalog for %{node} in environment %{environment}") % { node: node.name, environment: node.environment }
+                else
+                  #TRANSLATORS Inlined refers to adding additional metadata
+                  _("Inlined resource metadata into static catalog for %{node}") % { node: node.name }
+                end
           benchmark(:notice, str) do
             Puppet::Util::Profiler.profile(str, [:compiler, :static_compile_postprocessing, node.environment, node.name]) do
               inline_metadata(config, checksum_type)

data/vendored/puppet/lib/puppet/indirector/file_bucket_file/file.rb

@@ -219,7 +219,7 @@ module Puppet::FileBucketFile
     #   and content as that in the bucket_file
     # @api private
     def verify_identical_file(contents_file, bucket_file)
-      (bucket_file.size == Puppet::FileSystem.size(contents_file)) &&
+      (bucket_file.to_binary.bytesize == Puppet::FileSystem.size(contents_file)) &&
         (bucket_file.stream() {|s| Puppet::FileSystem.compare_stream(contents_file, s) })
     end
 

data/vendored/puppet/lib/puppet/module.rb

@@ -23,6 +23,7 @@ class Puppet::Module
     "templates" => "templates",
     "plugins" => "lib",
     "pluginfacts" => "facts.d",
+    "locales" => "locales",
   }
 
   # Find and return the +module+ that +path+ belongs to. If +path+ is
@@ -302,6 +303,11 @@ class Puppet::Module
     subpath("facts.d")
   end
 
+  #@return [String]
+  def locale_directory
+    subpath("locales")
+  end
+
   def has_external_facts?
     File.directory?(plugin_fact_directory)
   end
@@ -423,16 +429,15 @@ class Puppet::Module
   end
 
   def initialize_i18n
-    module_name = @forge_name.gsub("/","-") if @forge_name
-    return if module_name.nil? || i18n_initialized?(module_name)
+    # this name takes the form "namespace-module", and should match the name of
+    # the PO file containing the translations.
+    module_name = @forge_name ? @forge_name.gsub("/", "-") : name
+    return if Puppet::GettextConfig.translations_loaded?(module_name)
 
-    locales_path = File.absolute_path('locales', path)
-
-    if Puppet::GettextConfig.initialize(locales_path, :po)
-      Puppet.debug "#{module_name} initialized for i18n: #{GettextSetup.translation_repositories[module_name]}"
+    if Puppet::GettextConfig.load_translations(module_name, locale_directory, :po)
+      Puppet.debug "i18n initialized for #{module_name}"
     elsif Puppet::GettextConfig.gettext_loaded?
-      config_path = File.absolute_path('config.yaml', locales_path)
-      Puppet.debug "Could not find locales configuration file for #{module_name} at #{config_path}. Skipping i18n initialization."
+      Puppet.debug "Could not find translation files for #{module_name} at #{locale_directory}. Skipping i18n initialization."
     else
       Puppet.debug "No gettext library found, skipping i18n initialization."
     end
@@ -440,15 +445,6 @@ class Puppet::Module
 
   private
 
-  def i18n_initialized?(module_name)
-    if Puppet::GettextConfig.gettext_loaded?
-      GettextSetup.translation_repositories.has_key? module_name
-    else
-      # GettextSetup not yet initialized or not found
-      false
-    end
-  end
-
   def wanted_manifests_from(pattern)
     begin
       extended = File.extname(pattern).empty? ? "#{pattern}.pp" : pattern

data/vendored/puppet/lib/puppet/pops/evaluator/access_operator.rb

@@ -148,10 +148,22 @@ class AccessOperator
     end
   end
 
+  def access_PBooleanType(o, scope, keys)
+    keys.flatten!
+    assert_keys(keys, o, 1, 1, TrueClass, FalseClass)
+    Types::TypeFactory.boolean(keys[0])
+  end
+
   def access_PEnumType(o, scope, keys)
     keys.flatten!
+    last = keys.last
+    case_insensitive = false
+    if last == true || last == false
+      keys = keys[0...-1]
+      case_insensitive = last
+    end
     assert_keys(keys, o, 1, Float::INFINITY, String)
-    Types::TypeFactory.enum(*keys)
+    Types::PEnumType.new(keys, case_insensitive)
   end
 
   def access_PVariantType(o, scope, keys)
@@ -282,23 +294,6 @@ class AccessOperator
     Types::TypeFactory.pattern(*keys)
   end
 
-  def access_PErrorType(o, scope, keys)
-    # 1 - 2 parameters where both are string, regexp, or type
-    keys.flatten!
-    case keys.size
-    when 1, 2
-      pt = Types::PErrorType::TYPE_ERROR_PARAM
-      keys.each_with_index do |p, i|
-        unless pt.instance?(p)
-          fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[i], {:base_type => 'Error-Type', :actual => p.class})
-        end
-      end
-      Types::TypeFactory.error(*keys)
-    else
-      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Error-Type', :min => 1, :max => 2, :actual => keys.size})
-    end
-  end
-
   def access_POptionalType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
@@ -331,10 +326,14 @@ class AccessOperator
 
   def access_PObjectType(o, scope, keys)
     keys.flatten!
-    if keys.size == 1
-      Types::TypeFactory.object(keys[0])
+    if o.resolved? && !o.name.nil?
+      Types::PObjectTypeExtension.create(o, keys)
     else
-      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Object-Type', :min => 1, :actual => keys.size})
+      if keys.size == 1
+        Types::TypeFactory.object(keys[0])
+      else
+        fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Object-Type', :min => 1, :actual => keys.size})
+      end
     end
   end
 

data/vendored/puppet/lib/puppet/pops/evaluator/compare_operator.rb

@@ -34,7 +34,7 @@ class CompareOperator
   end
 
   # Performs a match of a and b, and returns true if b matches a
-  def match(a, b, scope)
+  def match(a, b, scope = nil)
     @@match_visitor.visit_this_2(self, b, a, scope)
   end
 
@@ -200,7 +200,7 @@ class CompareOperator
   def match_Regexp(regexp, left, scope)
     return false unless left.is_a? String
     matched = regexp.match(left)
-    set_match_data(matched, scope) # creates or clears ephemeral
+    set_match_data(matched, scope) unless scope.nil? # creates or clears ephemeral
     !!matched # convert to boolean
   end
 
@@ -245,7 +245,7 @@ class CompareOperator
 
   def match_Symbol(symbol, left, scope)
     return true if symbol == :default
-    equals(left, default, scope)
+    equals(left, default)
   end
 end
 end

data/vendored/puppet/lib/puppet/pops/evaluator/evaluator_impl.rb

@@ -178,6 +178,15 @@ class EvaluatorImpl
     end
   end
 
+  # Implementation of case option matching.
+  #
+  # This is the type of matching performed in a case option, using == for every type
+  # of value except regular expression where a match is performed.
+  #
+  def match?(left, right)
+    @@compare_operator.match(left, right, nil)
+  end
+
   protected
 
   def lvalue_VariableExpression(o, scope)

data/vendored/puppet/lib/puppet/pops/loader/static_loader.rb

@@ -76,7 +76,6 @@ class StaticLoader < Loader
     @loaded = {}
     @runtime_3_initialized = false
     create_built_in_types
-    register_aliases
   end
 
   def discover(type, name_authority = Pcore::RUNTIME_NAME_AUTHORITY)
@@ -116,6 +115,26 @@ class StaticLoader < Loader
     @loaded[typed_name]
   end
 
+  def create_built_in_puppet_types
+    Pcore.add_object_type('Error', <<-PUPPET, self)
+      {
+        type_parameters => {
+          kind => Optional[Variant[String,Regexp,Type[Enum],Type[Pattern],Type[NotUndef],Type[Undef]]],
+          issue_code => Optional[Variant[String,Regexp,Type[Enum],Type[Pattern],Type[NotUndef],Type[Undef]]]
+        },
+        attributes => {
+          message => String[1],
+          kind => { type => Optional[String[1]], value => undef },
+          issue_code => { type => Optional[String[1]], value => undef },
+          partial_result => { type => Data, value => undef },
+          details => { type => Optional[Hash[String[1],Data]], value => undef },
+        }
+      }
+    PUPPET
+
+    register_aliases
+  end
+
   def runtime_3_init
     unless @runtime_3_initialized
       @runtime_3_initialized = true

data/vendored/puppet/lib/puppet/pops/loader/task_instantiator.rb

@@ -54,7 +54,8 @@ class TaskInstantiator
       Types::Task::PARAMETER_NAME_PATTERN,
       tf.struct(
         tf.optional('description') => tf.string,
-        tf.optional('type') => Types::PStringType::NON_EMPTY
+        tf.optional('type') => Types::PStringType::NON_EMPTY,
+        tf.optional('sensitive') => tf.boolean
       )
     )
 

data/vendored/puppet/lib/puppet/pops/loaders.rb

@@ -84,7 +84,11 @@ class Loaders
 
   def self.static_loader
     # The static loader can only be changed after a reboot
-    @@static_loader ||= Loader::StaticLoader.new()
+    if !class_variable_defined?(:@@static_loader) || @@static_loader.nil?
+      @@static_loader = Loader::StaticLoader.new()
+      @@static_loader.create_built_in_puppet_types
+    end
+    @@static_loader
   end
 
   def self.implementation_registry
@@ -436,18 +440,6 @@ class Loaders
     def resolved?
       !@private_loader.nil?
     end
-
-    def restrict_to_dependencies?
-      @puppet_module.has_metadata?
-    end
-
-    def unmet_dependencies?
-      @puppet_module.unmet_dependencies.any?
-    end
-
-    def dependency_names
-      @puppet_module.dependencies_as_modules.collect(&:name)
-    end
   end
 
   # Resolves module loaders - resolution of model dependencies is done by Puppet::Module
@@ -476,42 +468,15 @@ class Loaders
       if module_data.resolved?
         nil
       else
-        module_data.private_loader =
-          if module_data.restrict_to_dependencies?
-            create_loader_with_only_dependencies_visible(module_data)
-          else
-            create_loader_with_all_modules_visible(module_data)
-          end
+        module_data.private_loader = create_loader_with_all_modules_visible(module_data)
       end
     end
 
     private
 
     def create_loader_with_all_modules_visible(from_module_data)
-      Puppet.debug{"ModuleLoader: module '#{from_module_data.name}' has unknown dependencies - it will have all other modules visible"}
-
       @loaders.add_loader_by_name(Loader::DependencyLoader.new(from_module_data.public_loader, "#{from_module_data.name} private", all_module_loaders()))
     end
-
-    def create_loader_with_only_dependencies_visible(from_module_data)
-      if from_module_data.unmet_dependencies?
-        if Puppet[:strict] != :off
-          msg = "ModuleLoader: module '#{from_module_data.name}' has unresolved dependencies" \
-              " - it will only see those that are resolved." \
-              " Use 'puppet module list --tree' to see information about modules"
-          case Puppet[:strict]
-          when :error
-              raise LoaderError.new(msg)
-          when :warning
-            Puppet.warn_once(:unresolved_module_dependencies,
-                             "unresolved_dependencies_for_module_#{from_module_data.name}",
-                             msg)
-          end
-        end
-      end
-      dependency_loaders = from_module_data.dependency_names.collect { |name| @index[name].public_loader }
-      @loaders.add_loader_by_name(Loader::DependencyLoader.new(from_module_data.public_loader, "#{from_module_data.name} private", dependency_loaders))
-    end
   end
 end
 end