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

data/lib/puppet/parser/ast/hostclass.rb

@@ -3,15 +3,13 @@ require 'puppet/parser/ast/top_level_construct'
 class Puppet::Parser::AST::Hostclass < Puppet::Parser::AST::TopLevelConstruct
   attr_accessor :name, :context
 
-  def initialize(name, context = {}, &ruby_code)
+  def initialize(name, context = {})
     @context = context
     @name = name
-    @ruby_code = ruby_code
   end
 
   def instantiate(modname)
     new_class = Puppet::Resource::Type.new(:hostclass, @name, @context.merge(:module_name => modname))
-    new_class.ruby_code = @ruby_code if @ruby_code
     all_types = [new_class]
     if code
       code.each do |nested_ast_node|

data/lib/puppet/parser/ast/leaf.rb

@@ -1,232 +1,75 @@
-class Puppet::Parser::AST
-  # The base class for all of the leaves of the parse trees.  These
-  # basically just have types and values.  Both of these parameters
-  # are simple values, not AST objects.
-  class Leaf < AST
-    attr_accessor :value, :type
-
-    # Return our value.
-    def evaluate(scope)
-      @value
-    end
-
-    def match(value)
-      @value == value
-    end
-
-    def to_s
-      @value.to_s unless @value.nil?
-    end
+# The base class for all of the leaves of the parse trees.  These
+# basically just have types and values.  Both of these parameters
+# are simple values, not AST objects.
+#
+class Puppet::Parser::AST::Leaf < Puppet::Parser::AST
+  attr_accessor :value, :type
+  # Return our value.
+  def evaluate(scope)
+    @value
   end
 
-  # The boolean class.  True or false.  Converts the string it receives
-  # to a Ruby boolean.
-  class Boolean < AST::Leaf
-    def initialize(hash)
-      super
-
-      unless @value == true or @value == false
-        raise Puppet::DevError, "'#{@value}' is not a boolean"
-      end
-      @value
-    end
+  def match(value)
+    @value == value
   end
 
-  # The base string class.
-  class String < AST::Leaf
-    def evaluate(scope)
-      @value.dup
-    end
-
-    def to_s
-      @value.inspect
-    end
+  def to_s
+    @value.to_s unless @value.nil?
   end
+end
 
-  # An uninterpreted string.
-  class FlatString < AST::Leaf
-    def evaluate(scope)
-      @value
-    end
-
-    def to_s
-      @value.inspect
+# Host names, either fully qualified or just the short name, or even a regex
+#
+class Puppet::Parser::AST::HostName < Puppet::Parser::AST::Leaf
+  def initialize(hash)
+    super
+
+    # Note that this is an AST::Regex, not a Regexp
+    unless @value.is_a?(Regex)
+      @value = @value.to_s.downcase
+      if @value =~ /[^-\w.]/
+        raise Puppet::DevError, "'#{@value}' is not a valid hostname"
+      end
     end
   end
 
-  class Concat < AST::Leaf
-    def evaluate(scope)
-      @value.collect { |x| x.evaluate(scope) }.collect{ |x| x == :undef ? '' : x }.join
-    end
-
-    def to_s
-      "#{@value.map { |s| s.to_s.gsub(/^"(.*)"$/, '\1') }.join}"
-    end
+  # implementing eql? and hash so that when an HostName is stored
+  # in a hash it has the same hashing properties as the underlying value
+  def eql?(value)
+    @value.eql?(value.is_a?(HostName) ? value.value : value)
   end
 
-  # The 'default' option on case statements and selectors.
-  class Default < AST::Leaf; end
-
-  # Capitalized words; used mostly for type-defaults, but also
-  # get returned by the lexer any other time an unquoted capitalized
-  # word is found.
-  class Type < AST::Leaf; end
-
-  # Lower-case words.
-  class Name < AST::Leaf; end
-
-  # double-colon separated class names
-  class ClassName < AST::Leaf; end
-
-  # undef values; equiv to nil
-  class Undef < AST::Leaf; end
-
-  # Host names, either fully qualified or just the short name, or even a regex
-  class HostName < AST::Leaf
-    def initialize(hash)
-      super
-
-      # Note that this is an AST::Regex, not a Regexp
-      unless @value.is_a?(Regex)
-        @value = @value.to_s.downcase
-        @value =~ /[^-\w.]/ and
-          raise Puppet::DevError, "'#{@value}' is not a valid hostname"
-      end
-    end
-
-    # implementing eql? and hash so that when an HostName is stored
-    # in a hash it has the same hashing properties as the underlying value
-    def eql?(value)
-      value = value.value if value.is_a?(HostName)
-      @value.eql?(value)
-    end
-
-    def hash
-      @value.hash
-    end
+  def hash
+    @value.hash
   end
+end
 
-  # A simple variable.  This object is only used during interpolation;
-  # the VarDef class is used for assignment.
-  class Variable < Name
-    # Looks up the value of the object in the scope tree (does
-    # not include syntactical constructs, like '$' and '{}').
-    def evaluate(scope)
-      parsewrap do
-        if scope.include?(@value)
-          scope[@value, {:file => file, :line => line}]
-        else
-          :undef
-        end
-      end
-    end
-
-    def to_s
-      "\$#{value}"
-    end
+class Puppet::Parser::AST::Regex < Puppet::Parser::AST::Leaf
+  def initialize(hash)
+    super
+    # transform value from hash options unless it is already a regular expression
+    @value = Regexp.new(@value) unless @value.is_a?(Regexp)
   end
 
-  class HashOrArrayAccess < AST::Leaf
-    attr_accessor :variable, :key
-
-    def evaluate_container(scope)
-      container = variable.respond_to?(:evaluate) ? variable.safeevaluate(scope) : variable
-      if container.is_a?(Hash) || container.is_a?(Array)
-        container
-      elsif container.is_a?(::String)
-        scope[container, {:file => file, :line => line}]
-      else
-        raise Puppet::ParseError, "#{variable} is #{container.inspect}, not a hash or array"
-      end
-    end
-
-    def evaluate_key(scope)
-      key.respond_to?(:evaluate) ? key.safeevaluate(scope) : key
-    end
-
-    def array_index_or_key(object, key)
-      if object.is_a?(Array)
-        raise Puppet::ParseError, "#{key} is not an integer, but is used as an index of an array" unless key = Puppet::Parser::Scope.number?(key)
-      end
-      key
-    end
-
-    def evaluate(scope)
-      object = evaluate_container(scope)
-      accesskey = evaluate_key(scope)
-      raise Puppet::ParseError, "#{variable} is not a hash or array when accessing it with #{accesskey}" unless object.is_a?(Hash) or object.is_a?(Array)
-
-      result = object[array_index_or_key(object, accesskey)]
-      result.nil? ? :undef : result
-    end
-
-    # Assign value to this hashkey or array index
-    def assign(scope, value)
-      object = evaluate_container(scope)
-      accesskey = evaluate_key(scope)
-
-      if object.is_a?(Hash) and object.include?(accesskey)
-        raise Puppet::ParseError, "Assigning to the hash '#{variable}' with an existing key '#{accesskey}' is forbidden"
-      end
-
-      mutation_deprecation()
-
-      # assign to hash or array
-      object[array_index_or_key(object, accesskey)] = value
-    end
-
-    def to_s
-      "\$#{variable.to_s}[#{key.to_s}]"
-    end
-
-    def mutation_deprecation
-      deprecation_location_text =
-      if file && line
-        " at #{file}:#{line}"
-      elsif file
-        " in file #{file}"
-      elsif line
-        " at #{line}"
-      end
-      Puppet.warning(["The use of mutating operations on Array/Hash is deprecated#{deprecation_location_text}.",
-         " See http://links.puppetlabs.com/puppet-mutation-deprecation"].join(''))
-    end
+  # we're returning self here to wrap the regexp and to be used in places
+  # where a string would have been used, without modifying any client code.
+  # For instance, in many places we have the following code snippet:
+  #  val = @val.safeevaluate(@scope)
+  #  if val.match(otherval)
+  #      ...
+  #  end
+  # this way, we don't have to modify this test specifically for handling
+  # regexes.
+  #
+  def evaluate(scope)
+    self
   end
 
-  class Regex < AST::Leaf
-    def initialize(hash)
-      super
-      @value = Regexp.new(@value) unless @value.is_a?(Regexp)
-    end
-
-    # we're returning self here to wrap the regexp and to be used in places
-    # where a string would have been used, without modifying any client code.
-    # For instance, in many places we have the following code snippet:
-    #  val = @val.safeevaluate(@scope)
-    #  if val.match(otherval)
-    #      ...
-    #  end
-    # this way, we don't have to modify this test specifically for handling
-    # regexes.
-    def evaluate(scope)
-      self
-    end
-
-    def evaluate_match(value, scope, options = {})
-      value = value == :undef ? '' : value.to_s
-
-      if matched = @value.match(value)
-        scope.ephemeral_from(matched, options[:file], options[:line])
-      end
-      matched
-    end
-
-    def match(value)
-      @value.match(value)
-    end
+  def match(value)
+    @value.match(value)
+  end
 
-    def to_s
-      "/#{@value.source}/"
-    end
+  def to_s
+    "/#{@value.source}/"
   end
 end

data/lib/puppet/parser/ast/node.rb

@@ -1,25 +1,17 @@
-require 'puppet/parser/ast/top_level_construct'
-
 class Puppet::Parser::AST::Node < Puppet::Parser::AST::TopLevelConstruct
   attr_accessor :names, :context
 
-  def initialize(names, context = {}, &ruby_code)
+  def initialize(names, context = {})
     raise ArgumentError, "names should be an array" unless names.is_a? Array
     if context[:parent]
-      msg = "Deprecation notice: Node inheritance is not supported in Puppet >= 4.0.0. See http://links.puppetlabs.com/puppet-node-inheritance-deprecation"
-      Puppet.puppet_deprecation_warning(msg, :key => "node-inheritance-#{names.join}", :file => context[:file], :line => context[:line])
+      raise Puppet::DevError, "Node inheritance is removed in Puppet 4.0.0. See http://links.puppetlabs.com/puppet-node-inheritance-deprecation"
     end
 
     @names = names
     @context = context
-    @ruby_code = ruby_code
   end
 
   def instantiate(modname)
-    @names.collect do |name|
-      new_node = Puppet::Resource::Type.new(:node, name, @context.merge(:module_name => modname))
-      new_node.ruby_code = @ruby_code if @ruby_code
-      new_node
-    end
+    @names.map { |name| Puppet::Resource::Type.new(:node, name, @context.merge(:module_name => modname)) }
   end
 end

data/lib/puppet/parser/ast/pops_bridge.rb

@@ -23,11 +23,6 @@ class Puppet::Parser::AST::PopsBridge
       Puppet::Pops::Model::ModelTreeDumper.new.dump(@value)
     end
 
-    def source_text
-      source_adapter = Puppet::Pops::Utils.find_closest_positioned(@value)
-      source_adapter ? source_adapter.extract_text() : nil
-    end
-
     def evaluate(scope)
       object = @@evaluator.evaluate(scope, @value)
       @@evaluator.convert_to_3x(object, scope)
@@ -149,7 +144,7 @@ class Puppet::Parser::AST::PopsBridge
         # when running tests that run a partial setup.
         # This is bad if the logic is trying to compile, but a warning can not be issues since it is a normal
         # use case that there is no scope when requesting the type in order to just get the parameters.
-        Puppet.debug("Instantiating Resource with type checked parameters - scope is missing, skipping type checking.")
+        Puppet.debug {"Instantiating Resource with type checked parameters - scope is missing, skipping type checking."}
         nil
       end
       scope
@@ -197,7 +192,7 @@ class Puppet::Parser::AST::PopsBridge
     end
 
     # Propagates a found Function to the appropriate loader.
-    # This is for 4x future-evaluator/loader
+    # This is for 4x evaluator/loader
     #
     def instantiate_FunctionDefinition(function_definition, modname)
       loaders = (Puppet.lookup(:loaders) { nil })

data/lib/puppet/parser/ast/resource.rb

@@ -1,16 +1,13 @@
-require 'puppet/parser/ast/resource_reference'
-
-# Any normal puppet resource declaration.  Can point to a definition or a
-# builtin type.
-class Puppet::Parser::AST
-class Resource < AST::Branch
-
-  associates_doc
+# Instruction for Resource instantiation.
+# Instantiates resources of both native and user defined types.
+#
+class Puppet::Parser::AST::Resource < Puppet::Parser::AST::Branch
 
   attr_accessor :type, :instances, :exported, :virtual
 
-  # Does not actually return an object; instead sets an object
-  # in the current scope.
+  # Evaluates resources by adding them to the compiler for lazy evaluation
+  # and returning the produced resource references.
+  #
   def evaluate(scope)
     # We want virtual to be true if exported is true.  We can't
     # just set :virtual => self.virtual in the initialization,
@@ -22,12 +19,10 @@ class Resource < AST::Branch
     # First level of implicit iteration: build a resource for each
     # instance.  This handles things like:
     # file { '/foo': owner => blah; '/bar': owner => blah }
-    @instances.collect { |instance|
+    @instances.map do |instance|
 
       # Evaluate all of the specified params.
-      paramobjects = instance.parameters.collect { |param|
-        param.safeevaluate(scope)
-      }
+      paramobjects = instance.parameters.map { |param| param.safeevaluate(scope) }
 
       resource_titles = instance.title.safeevaluate(scope)
 
@@ -39,10 +34,10 @@ class Resource < AST::Branch
       # Second level of implicit iteration; build a resource for each
       # title.  This handles things like:
       # file { ['/foo', '/bar']: owner => blah }
-      resource_titles.flatten.collect { |resource_title|
+      resource_titles.flatten.map do |resource_title|
         exceptwrap :type => Puppet::ParseError do
           resource = Puppet::Parser::Resource.new(
-            fully_qualified_type, resource_title,
+          fully_qualified_type, resource_title,
             :parameters => paramobjects,
             :file => self.file,
             :line => self.line,
@@ -57,11 +52,10 @@ class Resource < AST::Branch
             resource.resource_type.instantiate_resource(scope, resource)
           end
           scope.compiler.add_resource(scope, resource)
-          scope.compiler.evaluate_classes([resource_title], scope, false, true) if fully_qualified_type == 'class'
+          scope.compiler.evaluate_classes([resource_title], scope, false) if fully_qualified_type == 'class'
           resource
         end
-      }
-    }.flatten.reject { |resource| resource.nil? }
+      end
+    end.flatten.reject { |resource| resource.nil? }
   end
 end
-end

data/lib/puppet/parser/ast/resource_instance.rb

@@ -1,9 +1,6 @@
-require 'puppet/parser/ast/branch'
-
-class Puppet::Parser::AST
-  class ResourceInstance < Branch
-    # A simple container for a parameter for an object.  Consists of a
-    # title and a set of parameters.
+# A simple container for a parameter for an object.  Consists of a
+# title and a set of parameters.
+#
+class Puppet::Parser::AST::ResourceInstance < Puppet::Parser::AST::Branch
     attr_accessor :title, :parameters
-  end
 end

data/lib/puppet/parser/ast/resourceparam.rb

@@ -1,27 +1,26 @@
-require 'puppet/parser/ast/branch'
+# The AST object for the parameters inside resource expressions
+#
+class Puppet::Parser::AST::ResourceParam < Puppet::Parser::AST::Branch
+  attr_accessor :value, :param, :add
 
-class Puppet::Parser::AST
-  # The AST object for the parameters inside ResourceDefs and Selectors.
-  class ResourceParam < AST::Branch
-    attr_accessor :value, :param, :add
-
-    def each
-      [@param,@value].each { |child| yield child }
-    end
+  def each
+    [@param, @value].each { |child| yield child }
+  end
 
-    # Return the parameter and the value.
-    def evaluate(scope)
-      value = @value.safeevaluate(scope)
-      return Puppet::Parser::Resource::Param.new(
-        :name   => @param,
-        :value  => value.nil? ? :undef : value,
-        :source => scope.source, :line => self.line, :file => self.file,
-        :add    => self.add
-      )
-    end
+  # Return the parameter and the value.
+  def evaluate(scope)
+    value = @value.safeevaluate(scope)
+    return Puppet::Parser::Resource::Param.new(
+      :name   => @param,
+      :value  => value.nil? ? :undef : value,
+      :source => scope.source, 
+      :line   => self.line,
+      :file   => self.file,
+      :add    => self.add
+    )
+  end
 
-    def to_s
-      "#{@param} => #{@value.to_s}"
-    end
+  def to_s
+    "#{@param} => #{@value.to_s}"
   end
 end