puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/lib/puppet/reference/metaparameter.rb

@@ -1,13 +1,4 @@
 Puppet::Util::Reference.newreference :metaparameter, :doc => "All Puppet metaparameters and all their details" do
-  types = {}
-  Puppet::Type.loadall
-
-  Puppet::Type.eachtype { |type|
-    next if type.name == :puppet
-    next if type.name == :component
-    types[type.name] = type
-  }
-
   str = %{
 
 Metaparameters are attributes that work with any resource type, including custom

data/lib/puppet/reference/providers.rb

@@ -91,7 +91,7 @@ providers = Puppet::Util::Reference.newreference :providers, :title => "Provider
 
     ret << markdown_header(type.name.to_s + "_", 2)
 
-    ret << "[#{type.name}](#{"http://docs.puppetlabs.com/references/stable/type.html##{type.name}"})\n\n"
+    ret << "[#{type.name}](http://docs.puppetlabs.com/references/stable/type.html##{type.name})\n\n"
     ret << option("Default provider", default)
     ret << doctable(headers, table_data)
 

data/lib/puppet/reference/type.rb

@@ -3,7 +3,6 @@ Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource types a
   Puppet::Type.loadall
 
   Puppet::Type.eachtype { |type|
-    next if type.name == :puppet
     next if type.name == :component
     next if type.name == :whit
     types[type.name] = type
@@ -21,9 +20,9 @@ Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource types a
   In the following code:
 
       file { "/etc/passwd":
-        owner => root,
-        group => root,
-        mode  => 644
+        owner => "root",
+        group => "root",
+        mode  => "0644"
       }
 
   `/etc/passwd` is considered the title of the file object (used for things like
@@ -95,19 +94,18 @@ Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource types a
     str << markdown_header("Parameters", 4) + "\n"
     type.parameters.sort { |a,b|
       a.to_s <=> b.to_s
-    }.each { |name,param|
-      #docs[name] = indent(scrub(type.paramdoc(name)), $tab)
-      docs[name] = scrub(type.paramdoc(name))
+    }.each { |type_name, param|
+      docs[type_name] = scrub(type.paramdoc(type_name))
     }
 
     additional_key_attributes = type.key_attributes - [:name]
     docs.sort { |a, b|
       a[0].to_s <=> b[0].to_s
-    }.each { |name, doc|
-      if additional_key_attributes.include?(name)
+    }.each { |type_name, doc|
+      if additional_key_attributes.include?(type_name)
         doc = "(**Namevar:** If omitted, this parameter's value defaults to the resource's title.)\n\n" + doc
       end
-      str << markdown_definitionlist(name, doc)
+      str << markdown_definitionlist(type_name, doc)
     }
     str << "\n"
   }

data/lib/puppet/relationship.rb

@@ -1,13 +1,14 @@
 # subscriptions are permanent associations determining how different
 # objects react to an event
 
-require 'puppet/util/pson'
-
 # This is Puppet's class for modeling edges in its configuration graph.
 # It used to be a subclass of GRATR::Edge, but that class has weird hash
 # overrides that dramatically slow down the graphing.
 class Puppet::Relationship
-  extend Puppet::Util::Pson
+
+  # FormatSupport for serialization methods
+  include Puppet::Network::FormatSupport
+
   attr_accessor :source, :target, :callback
 
   attr_reader :event
@@ -27,11 +28,6 @@ class Puppet::Relationship
     new(source, target, args)
   end
 
-  def self.from_pson(pson)
-    Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
-    self.from_data_hash(pson)
-  end
-
   def event=(event)
     raise ArgumentError, "You must pass a callback for non-NONE events" if event != :NONE and ! callback
     @event = event
@@ -88,15 +84,6 @@ class Puppet::Relationship
     data
   end
 
-  # This doesn't include document type as it is part of a catalog
-  def to_pson_data_hash
-    to_data_hash
-  end
-
-  def to_pson(*args)
-    to_data_hash.to_pson(*args)
-  end
-
   def to_s
     ref
   end

data/lib/puppet/resource.rb

@@ -1,21 +1,15 @@
 require 'puppet'
 require 'puppet/util/tagging'
-require 'puppet/util/pson'
 require 'puppet/parameter'
+require 'puppet/data_providers'
 
 # The simplest resource class.  Eventually it will function as the
 # base class for all resource-like behaviour.
 #
 # @api public
 class Puppet::Resource
-  # This stub class is only needed for serialization compatibility with 0.25.x.
-  # Specifically, it exists to provide a compatibility API when using YAML
-  # serialized objects loaded from StoreConfigs.
-  Reference = Puppet::Resource
-
   include Puppet::Util::Tagging
 
-  extend Puppet::Util::Pson
   include Enumerable
   attr_accessor :file, :line, :catalog, :exported, :virtual, :validate_parameters, :strict
   attr_reader :type, :title
@@ -49,11 +43,6 @@ class Puppet::Resource
     resource
   end
 
-  def self.from_pson(pson)
-    Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
-    self.from_data_hash(pson)
-  end
-
   def inspect
     "#{@type}[#{@title}]#{to_hash.inspect}"
   end
@@ -82,11 +71,6 @@ class Puppet::Resource
     data
   end
 
-  # This doesn't include document type as it is part of a catalog
-  def to_pson_data_hash
-    to_data_hash
-  end
-
   def self.value_to_pson_data(value)
     if value.is_a? Array
       value.map{|v| value_to_pson_data(v) }
@@ -121,10 +105,6 @@ class Puppet::Resource
     YAML_ATTRIBUTES & super
   end
 
-  def to_pson(*args)
-    to_data_hash.to_pson(*args)
-  end
-
   # Proxy these methods to the parameters hash.  It's likely they'll
   # be overridden at some point, but this works for now.
   %w{has_key? keys length delete empty? <<}.each do |method|
@@ -211,43 +191,71 @@ class Puppet::Resource
   # @api public
   def initialize(type, title = nil, attributes = {})
     @parameters = {}
-    environment = attributes[:environment]
-    if type.is_a?(Class) && type < Puppet::Type
-      # Set the resource type to avoid an expensive `known_resource_types`
-      # lookup.
-      self.resource_type = type
-      # From this point on, the constructor behaves the same as if `type` had
-      # been passed as a symbol.
-      type = type.name
-    end
+    if type.is_a?(Puppet::Resource)
+      # Copy constructor. Let's avoid munging, extracting, tagging, etc
+      src = type
+      self.file = src.file
+      self.line = src.line
+      self.exported = src.exported
+      self.virtual = src.virtual
+      self.set_tags(src)
+      self.environment = src.environment
+      @rstype = src.resource_type
+      @type = src.type
+      @title = src.title
+
+      src.to_hash.each do |p, v|
+        if v.is_a?(Puppet::Resource)
+          v = Puppet::Resource.new(v.type, v.title)
+        elsif v.is_a?(Array)
+          # flatten resource references arrays
+          v = v.flatten if v.flatten.find { |av| av.is_a?(Puppet::Resource) }
+          v = v.collect do |av|
+            av = Puppet::Resource.new(av.type, av.title) if av.is_a?(Puppet::Resource)
+            av
+          end
+        end
 
-    # Set things like strictness first.
-    attributes.each do |attr, value|
-      next if attr == :parameters
-      send(attr.to_s + "=", value)
-    end
+        self[p] = v
+      end
+    else
+      environment = attributes[:environment]
+      if type.is_a?(Class) && type < Puppet::Type
+        # Set the resource type to avoid an expensive `known_resource_types`
+        # lookup.
+        self.resource_type = type
+        # From this point on, the constructor behaves the same as if `type` had
+        # been passed as a symbol.
+        type = type.name
+      end
 
-    @type, @title = extract_type_and_title(type, title)
+      # Set things like strictness first.
+      attributes.each do |attr, value|
+        next if attr == :parameters
+        send(attr.to_s + "=", value)
+      end
 
-    @type = munge_type_name(@type)
+      @type, @title = extract_type_and_title(type, title)
 
-    if self.class?
-      @title = :main if @title == ""
-      @title = munge_type_name(@title)
-    end
+      @type = munge_type_name(@type)
 
-    if params = attributes[:parameters]
-      extract_parameters(params)
-    end
+      if self.class?
+        @title = :main if @title == ""
+        @title = munge_type_name(@title)
+      end
 
-    if resource_type && resource_type.respond_to?(:deprecate_params)
+      if params = attributes[:parameters]
+        extract_parameters(params)
+      end
+
+    	if resource_type && resource_type.respond_to?(:deprecate_params)
         resource_type.deprecate_params(title, attributes[:parameters])
-    end
+    	end
 
-    tag(self.type)
-    tag(self.title) if valid_tag?(self.title)
+      tag(self.type)
+      tag_if_valid(self.title)
+    end
 
-    @reference = self # for serialization compatibility with 0.25.x
     if strict? and ! resource_type
       if self.class?
         raise ArgumentError, "Could not find declared class #{title}"
@@ -307,10 +315,11 @@ class Puppet::Resource
   end
 
   def uniqueness_key
-    # Temporary kludge to deal with inconsistant use patters
+    # Temporary kludge to deal with inconsistent use patterns; ensure we don't return nil for namevar/:name
     h = self.to_hash
-    h[namevar] ||= h[:name]
-    h[:name]   ||= h[namevar]
+    name = h[namevar] || h[:name] || self.name
+    h[namevar] ||= name
+    h[:name]   ||= name
     h.values_at(*key_attributes.sort_by { |k| k.to_s })
   end
 
@@ -318,6 +327,26 @@ class Puppet::Resource
     resource_type.respond_to?(:key_attributes) ? resource_type.key_attributes : [:name]
   end
 
+  # Convert our resource to yaml for Hiera purposes.
+  def to_hierayaml
+    # Collect list of attributes to align => and move ensure first
+    attr = parameters.keys
+    attr_max = attr.inject(0) { |max,k| k.to_s.length > max ? k.to_s.length : max }
+
+    attr.sort!
+    if attr.first != :ensure  && attr.include?(:ensure)
+      attr.delete(:ensure)
+      attr.unshift(:ensure)
+    end
+
+    attributes = attr.collect { |k|
+      v = parameters[k]
+      "    %-#{attr_max}s: %s\n" % [k, Puppet::Parameter.format_value_for_display(v)]
+    }.join
+
+    "  %s:\n%s" % [self.title, attributes]
+  end
+
   # Convert our resource to Puppet code.
   def to_manifest
     # Collect list of attributes to align => and move ensure first
@@ -378,24 +407,59 @@ class Puppet::Resource
     return nil unless resource_type.type == :hostclass
 
     name = "#{resource_type.name}::#{param}"
-    lookup_with_databinding(name, scope)
+    in_global = lambda { lookup_with_databinding(name, scope) }
+    in_env = lambda { lookup_in_environment(name, scope) }
+    in_module = lambda { lookup_in_module(name, scope) }
+    search(in_global, in_env, in_module)
+  end
+
+  def search(*search_functions)
+    search_functions.each {|f| x = f.call(); return x unless x.nil? }
+    nil
   end
 
   private :lookup_external_default_for
 
   def lookup_with_databinding(name, scope)
     begin
-      Puppet::DataBinding.indirection.find(
-        name,
-        :environment => scope.environment,
-        :variables => scope)
+      found = false
+      value = catch(:no_such_key) do
+        v = Puppet::DataBinding.indirection.find(
+          name,
+          :environment => scope.environment.to_s,
+          :variables => scope)
+        found = true
+        v
+      end
+      found ? value : nil
     rescue Puppet::DataBinding::LookupError => e
       raise Puppet::Error.new("Error from DataBinding '#{Puppet[:data_binding_terminus]}' while looking up '#{name}': #{e.message}", e)
     end
   end
-
   private :lookup_with_databinding
 
+  def lookup_in_environment(name, scope)
+    found = false
+    value = catch(:no_such_key) do
+      v = Puppet::DataProviders.lookup_in_environment(name, scope, nil)
+      found = true
+      v
+    end
+    found ? value : nil
+  end
+  private :lookup_in_environment
+
+  def lookup_in_module(name, scope)
+    found = false
+    value = catch(:no_such_key) do
+      v = Puppet::DataProviders.lookup_in_module(name, scope, nil)
+      found = true
+      v
+    end
+    found ? value : nil
+  end
+  private :lookup_in_module
+
   def set_default_parameters(scope)
     return [] unless resource_type and resource_type.respond_to?(:arguments)
 
@@ -420,50 +484,7 @@ class Puppet::Resource
   end
 
   def copy_as_resource
-    result = Puppet::Resource.new(type, title)
-
-    result.file = self.file
-    result.line = self.line
-    result.exported = self.exported
-    result.virtual = self.virtual
-    result.tag(*self.tags)
-    result.environment = environment
-    result.instance_variable_set(:@rstype, resource_type)
-
-    future_parser_not_in_use = !Puppet.future_parser?(result.environment)
-
-    to_hash.each do |p, v|
-      if v.is_a?(Puppet::Resource)
-        v = Puppet::Resource.new(v.type, v.title)
-      elsif v.is_a?(Array)
-        # flatten resource references arrays
-        v = v.flatten if v.flatten.find { |av| av.is_a?(Puppet::Resource) }
-        v = v.collect do |av|
-          av = Puppet::Resource.new(av.type, av.title) if av.is_a?(Puppet::Resource)
-          av
-        end
-      end
-
-      if future_parser_not_in_use # !Puppet.future_parser?
-        # If the value is an array with only one value, then
-        # convert it to a single value.  This is largely so that
-        # the database interaction doesn't have to worry about
-        # whether it returns an array or a string.
-        #
-        # This behavior is not done in the future parser, but we can't issue a
-        # deprecation warning either since there isn't anything that a user can
-        # do about it.
-        result[p] = if v.is_a?(Array) and v.length == 1
-                      v[0]
-                    else
-                      v
-                    end
-      else
-        result[p] = v
-      end
-    end
-
-    result
+    Puppet::Resource.new(self)
   end
 
   def valid_parameter?(name)
@@ -483,23 +504,20 @@ class Puppet::Resource
     end
 
     # Perform optional type checking
-    if Puppet.future_parser?
-      # Perform type checking
-      arg_types = resource_type.argument_types
-      # Parameters is a map from name, to parameter, and the parameter again has name and value
-      parameters.each do |name, value|
-        next unless t = arg_types[name.to_s]  # untyped, and parameters are symbols here (aargh, strings in the type)
-        unless Puppet::Pops::Types::TypeCalculator.instance?(t, value.value)
-          inferred_type = Puppet::Pops::Types::TypeCalculator.infer_set(value.value)
-          actual = Puppet::Pops::Types::TypeCalculator.generalize!(inferred_type)
-          fail Puppet::ParseError, "Expected parameter '#{name}' of '#{self}' to have type #{t.to_s}, got #{actual.to_s}"
-        end
+    arg_types = resource_type.argument_types
+    # Parameters is a map from name, to parameter, and the parameter again has name and value
+    parameters.each do |name, value|
+      next unless t = arg_types[name.to_s]  # untyped, and parameters are symbols here (aargh, strings in the type)
+      unless Puppet::Pops::Types::TypeCalculator.instance?(t, value.value)
+        inferred_type = Puppet::Pops::Types::TypeCalculator.infer(value.value)
+        actual = Puppet::Pops::Types::TypeCalculator.generalize!(inferred_type)
+        fail Puppet::ParseError, "Expected parameter '#{name}' of '#{self}' to have type #{t.to_s}, got #{actual.to_s}"
       end
     end
   end
 
   def validate_parameter(name)
-    raise ArgumentError, "Invalid parameter #{name}" unless valid_parameter?(name)
+    raise ArgumentError, "Invalid parameter: '#{name}'" unless valid_parameter?(name)
   end
 
   def prune_parameters(options = {})