puppet 0.25.5 → 2.6.0

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

@@ -1,76 +1,21 @@
+require 'puppet/parser/ast'
 require 'puppet/parser/ast/branch'
 
-class Puppet::Parser::AST
-    # A reference to an object.  Only valid as an rvalue.
-    class ResourceReference < AST::Branch
-        attr_accessor :title, :type
-        # Is the type a builtin type?
-        def builtintype?(type)
-            if typeklass = Puppet::Type.type(type)
-                return typeklass
-            else
-                return false
-            end
-        end
-
-        def each
-            [@type,@title].flatten.each { |param|
-                #Puppet.debug("yielding param %s" % param)
-                yield param
-            }
-        end
-
-        # Evaluate our object, but just return a simple array of the type
-        # and name.
-        def evaluate(scope)
-            title = @title.safeevaluate(scope)
-            title = [title] unless title.is_a?(Array)
-
-            if @type.to_s.downcase == "class"
-                resource_type = "class"
-                title = title.collect { |t| qualified_class(scope, t) }
-            else
-                resource_type = qualified_type(scope)
-            end
-
-            title = title.collect { |t| Puppet::Parser::Resource::Reference.new(
-                :type => resource_type, :title => t
-            ) }
-            return title.pop if title.length == 1
-            return title
-        end
-
-        # Look up a fully qualified class name.
-        def qualified_class(scope, title)
-            # Look up the full path to the class
-            if classobj = scope.find_hostclass(title)
-                title = classobj.classname
-            else
-                raise Puppet::ParseError, "Could not find class %s" % title
-            end
-        end
-
-        # Look up a fully-qualified type.  This method is
-        # also used in AST::Resource.
-        def qualified_type(scope, title = nil)
-            # We want a lower-case type.  For some reason.
-            objtype = @type.downcase
-            unless builtintype?(objtype)
-                if dtype = scope.find_definition(objtype)
-                    objtype = dtype.classname
-                else
-                    raise Puppet::ParseError, "Could not find resource type %s" % objtype
-                end
-            end
-            return objtype
-        end
-
-        def to_s
-            if title.is_a?(ASTArray)
-                "#{type.to_s.capitalize}#{title}"
-            else
-                "#{type.to_s.capitalize}[#{title}]"
-            end
-        end
+class Puppet::Parser::AST::ResourceReference < Puppet::Parser::AST::Branch
+  attr_accessor :title, :type
+
+  # Evaluate our object, but just return a simple array of the type
+  # and name.
+  def evaluate(scope)
+    titles = Array(title.safeevaluate(scope)).collect { |t| Puppet::Resource.new(type, t, :namespaces => scope.namespaces) }
+    return(titles.length == 1 ? titles.pop : titles)
+  end
+
+  def to_s
+    if title.is_a?(Puppet::Parser::AST::ASTArray)
+      "#{type.to_s.capitalize}#{title}"
+    else
+      "#{type.to_s.capitalize}[#{title}]"
     end
+  end
 end

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

@@ -1,26 +1,29 @@
 require 'puppet/parser/ast/branch'
 
 class Puppet::Parser::AST
-    # The AST object for the parameters inside ResourceDefs and Selectors.
-    class ResourceParam < AST::Branch
-        attr_accessor :value, :param, :add
+  # 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)
 
-        # Return the parameter and the value.
-        def evaluate(scope)
             return Puppet::Parser::Resource::Param.new(
-                :name => @param,
-                :value => @value.safeevaluate(scope),
-                :source => scope.source, :line => self.line, :file => self.file,
-                :add => self.add
-            )
-        end
+                
+        :name => @param,
+        :value => @value.safeevaluate(scope),
+        
+        :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
 end

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

@@ -1,48 +1,44 @@
 require 'puppet/parser/ast/branch'
 
 class Puppet::Parser::AST
-    # The inline conditional operator.  Unlike CaseStatement, which executes
-    # code, we just return a value.
-    class Selector < AST::Branch
-        attr_accessor :param, :values
+  # The inline conditional operator.  Unlike CaseStatement, which executes
+  # code, we just return a value.
+  class Selector < AST::Branch
+    attr_accessor :param, :values
 
-        def each
-            [@param,@values].each { |child| yield child }
-        end
-
-        # Find the value that corresponds with the test.
-        def evaluate(scope)
-            level = scope.ephemeral_level
-            # Get our parameter.
-            paramvalue = @param.safeevaluate(scope)
+    def each
+      [@param,@values].each { |child| yield child }
+    end
 
-            sensitive = Puppet[:casesensitive]
+    # Find the value that corresponds with the test.
+    def evaluate(scope)
+      level = scope.ephemeral_level
+      # Get our parameter.
+      paramvalue = @param.safeevaluate(scope)
 
-            default = nil
+      default = nil
 
-            unless @values.instance_of? AST::ASTArray or @values.instance_of? Array
-                @values = [@values]
-            end
+      @values = [@values] unless @values.instance_of? AST::ASTArray or @values.instance_of? Array
 
-            # Then look for a match in the options.
-            @values.each do |obj|
-                # short circuit asap if we have a match
-                return obj.value.safeevaluate(scope) if obj.param.evaluate_match(paramvalue, scope, :file => file, :line => line, :sensitive => sensitive)
+      # Then look for a match in the options.
+      @values.each do |obj|
+        # short circuit asap if we have a match
+        return obj.value.safeevaluate(scope) if obj.param.evaluate_match(paramvalue, scope)
 
-                # Store the default, in case it's necessary.
-                default = obj if obj.param.is_a?(Default)
-            end
+        # Store the default, in case it's necessary.
+        default = obj if obj.param.is_a?(Default)
+      end
 
-            # Unless we found something, look for the default.
-            return default.value.safeevaluate(scope) if default
+      # Unless we found something, look for the default.
+      return default.value.safeevaluate(scope) if default
 
-            self.fail Puppet::ParseError, "No matching value for selector param '%s'" % paramvalue
-        ensure
-            scope.unset_ephemeral_var(level)
-        end
+      self.fail Puppet::ParseError, "No matching value for selector param '#{paramvalue}'"
+    ensure
+      scope.unset_ephemeral_var(level)
+    end
 
-        def to_s
-            param.to_s + " ? { " + values.collect { |v| v.to_s }.join(', ') + " }"
-        end
+    def to_s
+      param.to_s + " ? { " + values.collect { |v| v.to_s }.join(', ') + " }"
     end
+  end
 end

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

@@ -1,24 +1,24 @@
 require 'puppet/parser/ast/branch'
 
 class Puppet::Parser::AST
-    # The code associated with a class.  This is different from components
-    # in that each class is a singleton -- only one will exist for a given
-    # node.
-    class Tag < AST::Branch
-        @name = :class
-        attr_accessor :type
+  # The code associated with a class.  This is different from components
+  # in that each class is a singleton -- only one will exist for a given
+  # node.
+  class Tag < AST::Branch
+    @name = :class
+    attr_accessor :type
 
-        def evaluate(scope)
-            types = @type.safeevaluate(scope)
+    def evaluate(scope)
+      types = @type.safeevaluate(scope)
 
-            types = [types] unless types.is_a? Array
+      types = [types] unless types.is_a? Array
 
-            types.each do |type|
-                # Now set our class.  We don't have to worry about checking
-                # whether we've been evaluated because we're not evaluating
-                # any code.
-                scope.setclass(self.object_id, type)
-            end
-        end
+      types.each do |type|
+        # Now set our class.  We don't have to worry about checking
+        # whether we've been evaluated because we're not evaluating
+        # any code.
+        scope.setclass(self.object_id, type)
+      end
     end
+  end
 end

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

@@ -1,29 +1,33 @@
 require 'puppet/parser/ast/branch'
 
 class Puppet::Parser::AST
-    # Define a variable.  Stores the value in the current scope.
-    class VarDef < AST::Branch
+  # Define a variable.  Stores the value in the current scope.
+  class VarDef < AST::Branch
 
-        associates_doc
+    associates_doc
 
-        attr_accessor :name, :value, :append
+    attr_accessor :name, :value, :append
 
-        @settor = true
+    @settor = true
 
-        # Look up our name and value, and store them appropriately.  The
-        # lexer strips off the syntax stuff like '$'.
-        def evaluate(scope)
-            name = @name.safeevaluate(scope)
-            value = @value.safeevaluate(scope)
+    # Look up our name and value, and store them appropriately.  The
+    # lexer strips off the syntax stuff like '$'.
+    def evaluate(scope)
+      value = @value.safeevaluate(scope)
+      if name.is_a?(HashOrArrayAccess)
+        name.assign(scope, value)
+      else
+        name = @name.safeevaluate(scope)
 
-            parsewrap do
-                scope.setvar(name,value, :file => @file, :line => @line, :append => @append)
-            end
+        parsewrap do
+          scope.setvar(name,value, :file => @file, :line => @line, :append => @append)
         end
+      end
+    end
 
-        def each
-            [@name,@value].each { |child| yield child }
-        end
+    def each
+      [@name,@value].each { |child| yield child }
     end
+  end
 
 end

data/lib/puppet/parser/collector.rb

@@ -1,231 +1,223 @@
 # An object that collects stored objects from the central cache and returns
 # them to the current host, yo.
 class Puppet::Parser::Collector
-    attr_accessor :type, :scope, :vquery, :equery, :form, :resources, :overrides, :collected
-
-    # Call the collection method, mark all of the returned objects as non-virtual,
-    # optionally applying parameter overrides. The collector can also delete himself
-    # from the compiler if there is no more resources to collect (valid only for resource fixed-set collector
-    # which get their resources from +collect_resources+ and not from the catalog)
-    def evaluate
-        # Shortcut if we're not using storeconfigs and they're trying to collect
-        # exported resources.
-        if form == :exported and Puppet[:storeconfigs] != true
-            Puppet.warning "Not collecting exported resources without storeconfigs"
-            return false
-        end
+  attr_accessor :type, :scope, :vquery, :equery, :form, :resources, :overrides, :collected
+
+  # Call the collection method, mark all of the returned objects as non-virtual,
+  # optionally applying parameter overrides. The collector can also delete himself
+  # from the compiler if there is no more resources to collect (valid only for resource fixed-set collector
+  # which get their resources from +collect_resources+ and not from the catalog)
+  def evaluate
+    # Shortcut if we're not using storeconfigs and they're trying to collect
+    # exported resources.
+    if form == :exported and Puppet[:storeconfigs] != true
+      Puppet.warning "Not collecting exported resources without storeconfigs"
+      return false
+    end
 
-        if self.resources
-            unless objects = collect_resources and ! objects.empty?
-                return false
-            end
-        else
-            method = "collect_#{@form.to_s}"
-            objects = send(method).each do |obj|
-                obj.virtual = false
-            end
-            if objects.empty?
-                return false
-            end
-        end
+    if self.resources
+      unless objects = collect_resources and ! objects.empty?
+        return false
+      end
+    else
+      method = "collect_#{@form.to_s}"
+      objects = send(method).each do |obj|
+        obj.virtual = false
+      end
+      return false if objects.empty?
+    end
 
-        # we have an override for the collected resources
-        if @overrides and !objects.empty?
-
-            # force the resource to be always child of any other resource
-            overrides[:source].meta_def(:child_of?) do
-                true
-            end
-
-            # tell the compiler we have some override for him unless we already
-            # overrided those resources
-            objects.each do |res|
-                unless @collected.include?(res.ref)
-                    res = Puppet::Parser::Resource.new(
-                        :type => res.type,
-                        :title => res.title,
-                        :params => overrides[:params],
-                        :file => overrides[:file],
-                        :line => overrides[:line],
-                        :source => overrides[:source],
-                        :scope => overrides[:scope]
-                    )
-
-                    scope.compiler.add_override(res)
-                end
-            end
+    # we have an override for the collected resources
+    if @overrides and !objects.empty?
+
+      # force the resource to be always child of any other resource
+      overrides[:source].meta_def(:child_of?) do
+        true
+      end
+
+      # tell the compiler we have some override for him unless we already
+      # overrided those resources
+      objects.each do |res|
+        unless @collected.include?(res.ref)
+
+                newres = Puppet::Parser::Resource.new(
+        res.type, res.title,
+            :parameters => overrides[:parameters],
+            :file => overrides[:file],
+            :line => overrides[:line],
+            :source => overrides[:source],
+        
+            :scope => overrides[:scope]
+          )
+
+          scope.compiler.add_override(newres)
         end
+      end
+    end
 
-        # filter out object that already have been collected by ourself
-        objects.reject! { |o| @collected.include?(o.ref) }
+    # filter out object that already have been collected by ourself
+    objects.reject! { |o| @collected.include?(o.ref) }
 
-        return false if objects.empty?
+    return false if objects.empty?
 
-        # keep an eye on the resources we have collected
-        objects.inject(@collected) { |c,o| c[o.ref]=o; c }
+    # keep an eye on the resources we have collected
+    objects.inject(@collected) { |c,o| c[o.ref]=o; c }
 
-        # return our newly collected resources
-        objects
-    end
+    # return our newly collected resources
+    objects
+  end
 
-    def initialize(scope, type, equery, vquery, form)
-        @scope = scope
+  def initialize(scope, type, equery, vquery, form)
+    @scope = scope
 
-        # initialisation
-        @collected = {}
+    # initialisation
+    @collected = {}
 
-        # Canonize the type
-        @type = Puppet::Resource::Reference.new(type, "whatever").type
-        @equery = equery
-        @vquery = vquery
+    # Canonize the type
+    @type = Puppet::Resource.new(type, "whatever").type
+    @equery = equery
+    @vquery = vquery
 
-        raise(ArgumentError, "Invalid query form %s" % form) unless [:exported, :virtual].include?(form)
-        @form = form
-    end
+    raise(ArgumentError, "Invalid query form #{form}") unless [:exported, :virtual].include?(form)
+    @form = form
+  end
 
-    # add a resource override to the soon to be exported/realized resources
-    def add_override(hash)
-        unless hash[:params]
-            raise ArgumentError, "Exported resource try to override without parameters"
-        end
+  # add a resource override to the soon to be exported/realized resources
+  def add_override(hash)
+    raise ArgumentError, "Exported resource try to override without parameters" unless hash[:parameters]
 
-        # schedule an override for an upcoming collection
-        @overrides = hash
-    end
+    # schedule an override for an upcoming collection
+    @overrides = hash
+  end
 
-    private
-
-    # Create our active record query.
-    def build_active_record_query
-        Puppet::Rails.init unless ActiveRecord::Base.connected?
-
-        raise Puppet::DevError, "Cannot collect resources for a nil host" unless @scope.host
-        host = Puppet::Rails::Host.find_by_name(@scope.host)
-
-        search = "(exported=? AND restype=?)"
-        values = [true, @type]
-
-        search += " AND (%s)" % @equery if @equery
-
-        # note:
-        # we're not eagerly including any relations here because
-        # it can creates so much objects we'll throw out later.
-        # We used to eagerly include param_names/values but the way
-        # the search filter is built ruined those efforts and we
-        # were eagerly loading only the searched parameter and not
-        # the other ones. 
-        query = {}
-        case search
-        when /puppet_tags/
-            query = {:joins => {:resource_tags => :puppet_tag}}
-        when /param_name/
-            query = {:joins => {:param_values => :param_name}}
-        end
+  private
 
-        # We're going to collect objects from rails, but we don't want any
-        # objects from this host.
-        search = ("host_id != ? AND %s" % search) and values.unshift(host.id) if host
+  # Create our active record query.
+  def build_active_record_query
+    Puppet::Rails.init unless ActiveRecord::Base.connected?
 
-        query[:conditions] = [search, *values]
+    raise Puppet::DevError, "Cannot collect resources for a nil host" unless @scope.host
+    host = Puppet::Rails::Host.find_by_name(@scope.host)
 
-        return query
+    search = "(exported=? AND restype=?)"
+    values = [true, @type]
+
+    search += " AND (#{@equery})" if @equery
+
+    # note:
+    # we're not eagerly including any relations here because
+    # it can creates so much objects we'll throw out later.
+    # We used to eagerly include param_names/values but the way
+    # the search filter is built ruined those efforts and we
+    # were eagerly loading only the searched parameter and not
+    # the other ones.
+    query = {}
+    case search
+    when /puppet_tags/
+      query = {:joins => {:resource_tags => :puppet_tag}}
+    when /param_name/
+      query = {:joins => {:param_values => :param_name}}
     end
 
-    # Collect exported objects.
-    def collect_exported
-        # First get everything from the export table.  Just reuse our
-        # collect_virtual method but tell it to use 'exported? for the test.
-        resources = collect_virtual(true).reject { |r| ! r.virtual? }
-
-        count = resources.length
-
-        query = build_active_record_query
-
-        # Now look them up in the rails db.  When we support attribute comparison
-        # and such, we'll need to vary the conditions, but this works with no
-        # attributes, anyway.
-        time = Puppet::Util.thinmark do
-            Puppet::Rails::Resource.find(:all, query).each do |obj|
-                if resource = exported_resource(obj)
-                    count += 1
-                    resources << resource
-                end
-            end
-        end
+    # We're going to collect objects from rails, but we don't want any
+    # objects from this host.
+    search = ("host_id != ? AND #{search}") and values.unshift(host.id) if host
 
-        scope.debug("Collected %s %s resource%s in %.2f seconds" %
-            [count, @type, count == 1 ? "" : "s", time])
+    query[:conditions] = [search, *values]
 
-        return resources
-    end
+    query
+  end
 
-    def collect_resources
-        unless @resources.is_a?(Array)
-            @resources = [@resources]
-        end
-        method = "collect_#{form.to_s}_resources"
-        send(method)
-    end
+  # Collect exported objects.
+  def collect_exported
+    # First get everything from the export table.  Just reuse our
+    # collect_virtual method but tell it to use 'exported? for the test.
+    resources = collect_virtual(true).reject { |r| ! r.virtual? }
 
-    def collect_exported_resources
-        raise Puppet::ParseError, "realize() is not yet implemented for exported resources"
-    end
+    count = resources.length
 
-    # Collect resources directly; this is the result of using 'realize',
-    # which specifies resources, rather than using a normal collection.
-    def collect_virtual_resources
-        return [] unless defined?(@resources) and ! @resources.empty?
-        result = @resources.dup.collect do |ref|
-            if res = @scope.findresource(ref.to_s)
-                @resources.delete(ref)
-                res
-            end
-        end.reject { |r| r.nil? }.each do |res|
-            res.virtual = false
-        end
+    query = build_active_record_query
 
-        # If there are no more resources to find, delete this from the list
-        # of collections.
-        if @resources.empty?
-            @scope.compiler.delete_collection(self)
+    # Now look them up in the rails db.  When we support attribute comparison
+    # and such, we'll need to vary the conditions, but this works with no
+    # attributes, anyway.
+    time = Puppet::Util.thinmark do
+      Puppet::Rails::Resource.find(:all, query).each do |obj|
+        if resource = exported_resource(obj)
+          count += 1
+          resources << resource
         end
+      end
+    end
 
-        return result
+    scope.debug("Collected %s %s resource%s in %.2f seconds" % [count, @type, count == 1 ? "" : "s", time])
+
+    resources
+  end
+
+  def collect_resources
+    @resources = [@resources] unless @resources.is_a?(Array)
+    method = "collect_#{form.to_s}_resources"
+    send(method)
+  end
+
+  def collect_exported_resources
+    raise Puppet::ParseError, "realize() is not yet implemented for exported resources"
+  end
+
+  # Collect resources directly; this is the result of using 'realize',
+  # which specifies resources, rather than using a normal collection.
+  def collect_virtual_resources
+    return [] unless defined?(@resources) and ! @resources.empty?
+    result = @resources.dup.collect do |ref|
+      if res = @scope.findresource(ref.to_s)
+        @resources.delete(ref)
+        res
+      end
+    end.reject { |r| r.nil? }.each do |res|
+      res.virtual = false
     end
 
-    # Collect just virtual objects, from our local compiler.
-    def collect_virtual(exported = false)
-        scope.compiler.resources.find_all do |resource|
-            resource.type == @type and (exported ? resource.exported? : true) and match?(resource)
-        end
+    # If there are no more resources to find, delete this from the list
+    # of collections.
+    @scope.compiler.delete_collection(self) if @resources.empty?
+
+    result
+  end
+
+  # Collect just virtual objects, from our local compiler.
+  def collect_virtual(exported = false)
+    scope.compiler.resources.find_all do |resource|
+      resource.type == @type and (exported ? resource.exported? : true) and match?(resource)
     end
+  end
 
-    # Seek a specific exported resource.
-    def exported_resource(obj)
-        if existing = @scope.findresource(obj.restype, obj.title)
-            # Next see if we've already collected this resource
-            return nil if existing.rails_id == obj.id
+  # Seek a specific exported resource.
+  def exported_resource(obj)
+    if existing = @scope.findresource(obj.restype, obj.title)
+      # Next see if we've already collected this resource
+      return nil if existing.rails_id == obj.id
 
-            # This is the one we've already collected
-            raise Puppet::ParseError, "Exported resource %s cannot override local resource" % [obj.ref]
-        end
+      # This is the one we've already collected
+      raise Puppet::ParseError, "Exported resource #{obj.ref} cannot override local resource"
+    end
 
-        resource = obj.to_resource(self.scope)
+    resource = obj.to_resource(self.scope)
 
-        resource.exported = false
+    resource.exported = false
 
-        scope.compiler.add_resource(scope, resource)
+    scope.compiler.add_resource(scope, resource)
 
-        return resource
-    end
+    resource
+  end
 
-    # Does the resource match our tests?  We don't yet support tests,
-    # so it's always true at the moment.
-    def match?(resource)
-        if self.vquery
-            return self.vquery.call(resource)
-        else
-            return true
-        end
+  # Does the resource match our tests?  We don't yet support tests,
+  # so it's always true at the moment.
+  def match?(resource)
+    if self.vquery
+      return self.vquery.call(resource)
+    else
+      return true
     end
+  end
 end