bolt 0.11.0 → 0.12.0

data/vendored/puppet/lib/puppet/application/describe.rb

@@ -37,7 +37,6 @@ class Formatter
   def scrub(text)
     # For text with no carriage returns, there's nothing to do.
     return text if text !~ /\n/
-    indent = nil
 
     # If we can match an indentation, then just remove that same level of
     # indent from every line.

data/vendored/puppet/lib/puppet/configurer.rb

@@ -170,7 +170,7 @@ class Puppet::Configurer
     begin
       report.configuration_version = catalog.version
 
-      benchmark(:notice, _("Applied catalog")) do
+      benchmark(:notice, _("Applied catalog in %{seconds} seconds")) do
         catalog.apply(options)
       end
     ensure

data/vendored/puppet/lib/puppet/configurer/plugin_handler.rb

@@ -4,7 +4,8 @@
 require 'puppet/configurer'
 
 class Puppet::Configurer::PluginHandler
-  # Retrieve facts from the central server.
+  SUPPORTED_LOCALES_MOUNT_AGENT_VERSION = Gem::Version.new("5.3.4")
+
   def download_plugins(environment)
     source_permissions = Puppet.features.microsoft_windows? ? :ignore : :use
 
@@ -23,18 +24,23 @@ class Puppet::Configurer::PluginHandler
       environment,
       source_permissions
     )
-    locales_downloader = Puppet::Configurer::Downloader.new(
-      "locales",
-      Puppet[:localedest],
-      Puppet[:localesource],
-      Puppet[:localeignore],
-      environment
-    )
 
     result = []
     result += plugin_fact_downloader.evaluate
     result += plugin_downloader.evaluate
-    result += locales_downloader.evaluate
+
+    server_agent_version = Puppet.lookup(:server_agent_version) { "0.0" }
+    if Gem::Version.new(server_agent_version) >= SUPPORTED_LOCALES_MOUNT_AGENT_VERSION
+      locales_downloader = Puppet::Configurer::Downloader.new(
+        "locales",
+        Puppet[:localedest],
+        Puppet[:localesource],
+        Puppet[:localeignore],
+        environment
+      )
+      result += locales_downloader.evaluate
+    end
+
 
     Puppet::Util::Autoload.reload_changed
 

data/vendored/puppet/lib/puppet/datatypes.rb

@@ -0,0 +1,213 @@
+# Data types in the Puppet Language can have implementations written in Ruby
+# and distributed in puppet modules. A data type can be declared together with
+# its implementation by creating a file in 'lib/puppet/functions/<modulename>'.
+# The name of the file must be the downcased name of the data type followed by
+# the extension '.rb'.
+#
+# A data type is created by calling {Puppet::DataTypes.create_type(<type name>)}
+# and passing it a block that defines the data type interface and implementation.
+#
+# Data types are namespaced inside the modules that contains them. The name of the
+# data type is prefixed with the name of the module. As with all type names, each
+# segment of the name must start with an uppercase letter.
+#
+# @example A simple data type
+#   Puppet::DataTypes.create_type('Auth::User') do
+#     interface <<-PUPPET
+#       attributes => {
+#         name => String,
+#         email => String
+#       }
+#     PUPPET
+#   end
+#
+# The above example does not declare an implementation which makes it equivalent
+# to adding the following contents in a file named 'user.pp' under the 'types' directory
+# of the module root.
+#
+#   type Auth::User = Object[
+#     attributes => {
+#       name => String,
+#       email => String
+#     }]
+#
+# Both declarations are valid and will be found by the module loader.
+#
+# Structure of a data type
+# ---
+#
+# A Data Type consists of an interface and an implementation. Unless a registered implementation
+# is found, the type system will automatically generate one. An  automatically generated
+# implementation is all that is needed when the interface fully  defines the behaviour (for
+# example in the common case when the data type has no other behaviour than having attributes).
+#
+# When the automatically generated implementation is not sufficient, one must be implemented and
+# registered. The implementation can either be done next to the interface definition by passing
+# a block to `implementation`, or map to an existing implementation class by passing the class
+# as an argument to `implementation_class`. An implementation class does not have to be special
+# in other respects than that it must implemented the type's interface. This makes it possible
+# to use existing Ruby data types as data types in the puppet language.
+#
+# Note that when using `implementation_class` there can only be one such implementation across
+# all environments managed by one puppet server and you must handle and install these
+# implementations as if they are part of the puppet platform. In contrast; the type
+# implementations that are done inside of the type's definition are safe to use in different
+# versions in different environments (given that they do not need additional external logic to
+# be loaded).
+#
+# When using an `implementation_class` it is sometimes desirable to load this class from the
+# 'lib' directory of the module. The method `load_file` is provided to facilitate such a load.
+# The `load_file` will use the `Puppet::Util::Autoload` to search for the given file in the 'lib'
+# directory of the current environment and the 'lib' directory in each included module.
+#
+# @example Adding implementation on top of the generated type using `implementation`
+#   Puppet::DataTypes.create_type('Auth::User') do
+#     interface <<-PUPPET
+#       attributes => {
+#         name => String,
+#         email => String,
+#         year_of_birth => Integer,
+#         age => { type => Integer, kind => derived }
+#       }
+#       PUPPET
+#
+#     implementation do
+#       def age
+#         DateTime.now.year - @year_of_birth
+#       end
+#     end
+#   end
+#
+# @example Appointing an already existing implementation class
+#
+# Assumes the following class is declared under 'lib/puppetx/auth' in the module:
+#
+#   class PuppetX::Auth::User
+#     attr_reader :name, :year_of_birth
+#     def initialize(name, year_of_birth)
+#       @name = name
+#       @year_of_birth = year_of_birth
+#     end
+#
+#     def age
+#       DateTime.now.year - @year_of_birth
+#     end
+#
+#     def send_text(sender, text)
+#       sender.send_text_from(@name, text)
+#     end
+#   end
+#
+# Then the type declaration can look like this:
+#
+#   Puppet::DataTypes.create_type('Auth::User') do
+#     interface <<-PUPPET
+#       attributes => {
+#         name => String,
+#         email => String,
+#         year_of_birth => Integer,
+#         age => { type => Integer, kind => derived }
+#       },
+#       functions => {
+#         send_text => Callable[Sender, String[1]]
+#       }
+#       PUPPET
+#
+#     # This load_file is optional and only needed in case
+#     # the implementation is not loaded by other means.
+#     load_file 'puppetx/auth/user'
+#
+#     implementation_class PuppetX::Auth::User
+#   end
+#
+module Puppet::DataTypes
+  def self.create_type(type_name, &block)
+    # Ruby < 2.1.0 does not have method on Binding, can only do eval
+    # and it will fail unless protected with an if defined? if the local
+    # variable does not exist in the block's binder.
+    #
+    begin
+      loader = block.binding.eval('loader_injected_arg if defined?(loader_injected_arg)')
+      create_loaded_type(type_name, loader, &block)
+    rescue StandardError => e
+      raise ArgumentError, _("Data Type Load Error for type '%{type_name}': %{message}") % {type_name: type_name, message: e.message}
+    end
+
+  end
+
+  def self.create_loaded_type(type_name, loader, &block)
+    builder = TypeBuilder.new(type_name.to_s)
+    api = TypeBuilderAPI.new(builder).freeze
+    api.instance_eval(&block)
+    builder.create_type(loader)
+  end
+
+  # @api private
+  class TypeBuilder
+    attr_accessor :interface, :implementation, :implementation_class
+
+    def initialize(type_name)
+      @type_name = type_name
+      @implementation = nil
+      @implementation_class = nil
+    end
+
+    def create_type(loader)
+      raise ArgumentError, _('a data type must have an interface') unless @interface.is_a?(String)
+      created_type = Puppet::Pops::Types::PObjectType.new(
+        @type_name,
+        Puppet::Pops::Parser::EvaluatingParser.new.parse_string("{ #{@interface} }").body)
+
+      if !@implementation_class.nil?
+        if @implementation_class < Puppet::Pops::Types::PuppetObject
+          @implementation_class.instance_eval do
+            include Puppet::Pops::Types::PuppetObject
+            @_pcore_type = created_type
+
+            def self._pcore_type
+              @_pcore_type
+            end
+          end
+        else
+          Puppet::Pops::Loaders.implementation_registry.register_implementation(created_type, @implementation_class, loader)
+        end
+        created_type.implementation_class = @implementation_class
+      elsif !@implementation.nil?
+        created_type.implementation_override = @implementation
+      end
+      created_type
+    end
+
+    def has_implementation?
+      !(@implementation_class.nil? && @implementation.nil?)
+    end
+  end
+
+  # The TypeBuilderAPI class exposes only those methods that the builder API provides
+  # @api public
+  class TypeBuilderAPI
+    # @api private
+    def initialize(type_builder)
+      @type_builder = type_builder
+    end
+
+    def interface(type_string)
+      raise ArgumentError, _('a data type can only have one interface') unless @type_builder.interface.nil?
+      @type_builder.interface = type_string
+    end
+
+    def implementation(&block)
+      raise ArgumentError, _('a data type can only have one implementation') if @type_builder.has_implementation?
+      @type_builder.implementation = block
+    end
+
+    def implementation_class(ruby_class)
+      raise ArgumentError, _('a data type can only have one implementation') if @type_builder.has_implementation?
+      @type_builder.implementation_class = ruby_class
+    end
+
+    def load_file(file_name)
+      Puppet::Util::Autoload.load_file(file_name, nil)
+    end
+  end
+end

data/vendored/puppet/lib/puppet/datatypes/error.rb

@@ -0,0 +1,19 @@
+Puppet::DataTypes.create_type('Error') do
+  interface <<-PUPPET
+    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
+
+  require 'puppet/datatypes/impl/error'
+
+  implementation_class Puppet::DataTypes::Error
+end

data/vendored/puppet/lib/puppet/datatypes/impl/error.rb

@@ -0,0 +1,42 @@
+class Puppet::DataTypes::Error
+  attr_reader :message, :kind, :issue_code, :partial_result, :details
+
+  def self.from_asserted_hash(hash)
+    new(hash['message'], hash['kind'], hash['issue_code'], hash['partial_result'], hash['details'])
+  end
+
+  def _pcore_init_hash
+    result = { 'message' => @message }
+    result['kind'] = @kind unless @kind.nil?
+    result['issue_code'] = @issue_code unless @issue_code.nil?
+    result['partial_result'] = @partial_result unless @partial_result.nil?
+    result['details'] = @details unless @details.nil?
+    result
+  end
+
+  def initialize(message, kind = nil, issue_code = nil, partial_result = nil, details = nil)
+    @message = message
+    @kind = kind
+    @issue_code = issue_code
+    @partial_result = partial_result
+    @details = details
+  end
+
+  def eql?(o)
+    self.class.equal?(o.class) &&
+      @message == o.message &&
+      @kind == o.kind &&
+      @issue_code == o.issue_code &&
+      @partial_result == o.partial_result &&
+      @details == o.details
+  end
+  alias == eql?
+
+  def hash
+    @message.hash ^ @kind.hash ^ @issue_code.hash
+  end
+
+  def to_s
+    Puppet::Pops::Types::StringConverter.singleton.convert(self)
+  end
+end

data/vendored/puppet/lib/puppet/error.rb

@@ -84,7 +84,7 @@ module Puppet
       if stacktrace.size > 0
         filename, line = stacktrace[0]
       else
-        file = nil
+        filename = nil
         line = nil
       end
       self.new(

data/vendored/puppet/lib/puppet/face/catalog.rb

@@ -71,7 +71,7 @@ Puppet::Indirector::Face.define(:catalog, '0.0.1') do
       Puppet::Util::Log.newdestination(report)
 
       begin
-        benchmark(:notice, "Finished catalog run") do
+        benchmark(:notice, "Finished catalog run in %{seconds} seconds") do
           catalog.apply(:report => report)
         end
       rescue => detail

data/vendored/puppet/lib/puppet/face/epp.rb

@@ -63,7 +63,7 @@ Puppet::Face.define(:epp, '0.0.1') do
     when_invoked do |*args|
       options = args.pop
       # pass a dummy node, as facts are not needed for validation
-      options[:node] = node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}))
+      options[:node] = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}))
       compiler = create_compiler(options)
 
       status = true # no validation error yet
@@ -145,7 +145,7 @@ Puppet::Face.define(:epp, '0.0.1') do
       require 'puppet/pops'
       options = args.pop
       # pass a dummy node, as facts are not needed for dump
-      options[:node] = node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}))
+      options[:node] = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}))
       options[:header] = options[:header].nil? ? true : options[:header]
       options[:validate] = options[:validate].nil? ? true : options[:validate]
 
@@ -176,7 +176,7 @@ Puppet::Face.define(:epp, '0.0.1') do
         end
 
         show_filename = templates.count > 1
-        dumps = templates.each do |file|
+        templates.each do |file|
           buffer.print dump_parse(Puppet::FileSystem.read(file, :encoding => 'utf-8'), file, options, show_filename)
         end
 

data/vendored/puppet/lib/puppet/face/help.rb

@@ -78,26 +78,24 @@ Puppet::Face.define(:help, '0.0.1') do
   def render_application_help(applicationname)
     return Puppet::Application[applicationname].help
   rescue StandardError, LoadError => detail
-    msg = _(<<-MSG) % { applicationname: applicationname, detail: detail.message }
-Could not load help for the application %{applicationname}.
-Please check the error logs for more information.
-
-Detail: "%{detail}"
-MSG
-    fail ArgumentError, msg, detail.backtrace
+    message = []
+    message << _('Could not load help for the application %{application_name}.') % { application_name: applicationname }
+    message << _('Please check the error logs for more information.')
+    message << ''
+    message << _('Detail: "%{detail}"') % { detail: detail.message }
+    fail ArgumentError, message.join("\n"), detail.backtrace
   end
 
   def render_face_help(facename, actionname, version)
     face, action = load_face_help(facename, actionname, version)
     return template_for(face, action).result(binding)
   rescue StandardError, LoadError => detail
-    msg = _(<<-MSG) % { facename: facename, detail: detail.message }
-Could not load help for the face %{facename}.
-Please check the error logs for more information.
-
-Detail: "%{detail}"
-MSG
-    fail ArgumentError, msg, detail.backtrace
+    message = []
+    message << _('Could not load help for the face %{face_name}.') % { face_name: facename }
+    message << _('Please check the error logs for more information.')
+    message << ''
+    message << _('Detail: "%{detail}"') % { detail: detail.message }
+    fail ArgumentError, message.join("\n"), detail.backtrace
   end
 
   def load_face_help(facename, actionname, version)

data/vendored/puppet/lib/puppet/face/man.rb

@@ -25,6 +25,7 @@ Puppet::Face.define(:man, '0.0.1') do
   action(:man) do
     summary _("Display the manual page for a Puppet subcommand.")
     arguments _("<subcommand>")
+    #TRANSLATORS '--render-as s' is a command line option and should not be translated
     returns _(<<-'EOT')
       The man data, in Markdown format, suitable for consumption by Ronn.
 

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

@@ -44,7 +44,7 @@ Puppet::Face.define(:module, '1.0.0') do
       min_widths = Hash[ *headers.map { |k,v| [k, v.length] }.flatten ]
       min_widths['full_name'] = min_widths['author'] = 12
 
-      min_width = min_widths.inject(0) { |sum,pair| sum += pair.last } + (padding.length * (headers.length - 1))
+      min_width = min_widths.inject(0) { |sum,pair| sum + pair.last } + (padding.length * (headers.length - 1))
 
       terminal_width = [Puppet::Util::Terminal.width, min_width].max
 

data/vendored/puppet/lib/puppet/face/node.rb

@@ -17,6 +17,7 @@ Puppet::Indirector::Face.define(:node, '0.0.1') do
   find = get_action(:find)
   find.summary _("Retrieve a node object.")
   find.arguments _("<host>")
+  #TRANSLATORS the following are specific names and should not be translated `classes`, `environment`, `expiration`, `name`, `parameters`, Puppet::Node
   find.returns _(<<-'EOT')
     A hash containing the node's `classes`, `environment`, `expiration`, `name`,
     `parameters` (its facts, combined with any ENC-set parameters), and `time`.