puppet 3.1.0.rc1 → 3.1.0.rc2

data/lib/puppet/dsl/resource_type_api.rb

@@ -0,0 +1,34 @@
+require 'puppet/resource/type'
+
+# Type of the objects inside of which pure ruby manifest files are
+# executed.  Provides methods for creating defines, hostclasses, and
+# nodes.
+class Puppet::DSL::ResourceTypeAPI
+  def initialize
+    @__created_ast_objects__ = []
+  end
+
+  def define(name, *args, &block)
+    args = args.inject([]) do |result, item|
+      if item.is_a?(Hash)
+        item.each { |p, v| result << [p, v] }
+      else
+        result << item
+      end
+      result
+    end
+    @__created_ast_objects__.push Puppet::Parser::AST::Definition.new(name, {:arguments => args}, &block)
+    nil
+  end
+
+  def hostclass(name, options = {}, &block)
+    @__created_ast_objects__.push Puppet::Parser::AST::Hostclass.new(name, options, &block)
+    nil
+  end
+
+  def node(name, options = {}, &block)
+    name = [name] unless name.is_a?(Array)
+    @__created_ast_objects__.push Puppet::Parser::AST::Node.new(name, options, &block)
+    nil
+  end
+end

data/lib/puppet/module_tool.rb

@@ -104,20 +104,32 @@ module Puppet
 
     def self.set_option_defaults(options)
       sep = File::PATH_SEPARATOR
-      if options[:target_dir]
-        options[:target_dir] = File.expand_path(options[:target_dir])
-      end
 
-      prepend_target_dir = !! options[:target_dir]
+      if options[:environment]
+        Puppet.settings[:environment] = options[:environment]
+      else
+        options[:environment] = Puppet.settings[:environment]
+      end
 
-      options[:modulepath] ||= Puppet.settings[:modulepath]
-      options[:environment] ||= Puppet.settings[:environment]
-      options[:modulepath] = "#{options[:target_dir]}#{sep}#{options[:modulepath]}" if prepend_target_dir
-      Puppet[:modulepath] = options[:modulepath]
-      Puppet[:environment] = options[:environment]
+      if options[:modulepath]
+        Puppet.settings[:modulepath] = options[:modulepath]
+      else
+        # (#14872) make sure the module path of the desired environment is used
+        # when determining the default value of the --target-dir option
+        Puppet.settings[:modulepath] = options[:modulepath] =
+          Puppet.settings.value(:modulepath, options[:environment])
+      end
 
-      options[:target_dir] = options[:modulepath].split(sep).first
-      options[:target_dir] = File.expand_path(options[:target_dir])
+      if options[:target_dir]
+        options[:target_dir] = File.expand_path(options[:target_dir])
+        # prepend the target dir to the module path
+        Puppet.settings[:modulepath] = options[:modulepath] =
+          options[:target_dir] + sep + options[:modulepath]
+      else
+        # default to the first component of the module path
+        options[:target_dir] =
+          File.expand_path(options[:modulepath].split(sep).first)
+      end
     end
   end
 end

data/lib/puppet/network/formats.rb

@@ -148,7 +148,7 @@ Puppet::Network::FormatHandler.create(:console,
     # Simple hash to table
     if datum.is_a? Hash and datum.keys.all? { |x| x.is_a? String or x.is_a? Numeric }
       output = ''
-      column_a = datum.map do |k,v| k.to_s.length end.max + 2
+      column_a = datum.empty? ? 2 : datum.map{ |k,v| k.to_s.length }.max + 2
       column_b = 79 - column_a
       datum.sort_by { |k,v| k.to_s } .each do |key, value|
         output << key.to_s.ljust(column_a)

data/lib/puppet/node/environment.rb

@@ -1,9 +1,7 @@
 require 'puppet/util'
 require 'puppet/util/cacher'
-require 'puppet/util/manifest_filetype_helper'
 require 'monitor'
 
-
 # Just define it, so this class has fewer load dependencies.
 class Puppet::Node
 end
@@ -218,7 +216,7 @@ class Puppet::Node::Environment
   private
 
   def perform_initial_import
-    return empty_parse_result if Puppet.settings[:ignoreimport] or Puppet::Util::ManifestFiletypeHelper.is_ruby_filename?(Puppet.settings.value(:manifest, name))
+    return empty_parse_result if Puppet.settings[:ignoreimport]
     parser = Puppet::Parser::Parser.new(self)
     if code = Puppet.settings.uninterpolated_value(:code, name.to_s) and code != ""
       parser.string = code

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

@@ -3,12 +3,15 @@ require 'puppet/parser/ast/top_level_construct'
 class Puppet::Parser::AST::Definition < Puppet::Parser::AST::TopLevelConstruct
   attr_accessor :context
 
-  def initialize(name, context = {})
+  def initialize(name, context = {}, &ruby_code)
     @name = name
     @context = context
+    @ruby_code = ruby_code
   end
 
   def instantiate(modname)
-    [Puppet::Resource::Type.new(:definition, @name, @context.merge(:module_name => modname))]
+    new_definition = Puppet::Resource::Type.new(:definition, @name, @context.merge(:module_name => modname))
+    new_definition.ruby_code = @ruby_code if @ruby_code
+    [new_definition]
   end
 end

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

@@ -3,13 +3,15 @@ require 'puppet/parser/ast/top_level_construct'
 class Puppet::Parser::AST::Hostclass < Puppet::Parser::AST::TopLevelConstruct
   attr_accessor :name, :context
 
-  def initialize(name, context = {})
+  def initialize(name, context = {}, &ruby_code)
     @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|
@@ -18,7 +20,6 @@ class Puppet::Parser::AST::Hostclass < Puppet::Parser::AST::TopLevelConstruct
         end
       end
     end
-
     return all_types
   end
 

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

@@ -3,15 +3,18 @@ require 'puppet/parser/ast/top_level_construct'
 class Puppet::Parser::AST::Node < Puppet::Parser::AST::TopLevelConstruct
   attr_accessor :names, :context
 
-  def initialize(names, context = {})
+  def initialize(names, context = {}, &ruby_code)
     raise ArgumentError, "names should be an array" unless names.is_a? Array
     @names = names
     @context = context
+    @ruby_code = ruby_code
   end
 
   def instantiate(modname)
     @names.collect do |name|
-      Puppet::Resource::Type.new(:node, name, @context.merge(:module_name => modname))
+      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
   end
 end

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

@@ -11,7 +11,7 @@ class Puppet::Parser::AST
 
     # Return the parameter and the value.
     def evaluate(scope)
-      Puppet::Parser::Resource::Param.new(
+      return Puppet::Parser::Resource::Param.new(
         :name   => @param,
         :value  => @value.safeevaluate(scope),
         :source => scope.source, :line => self.line, :file => self.file,

data/lib/puppet/parser/compiler.rb

@@ -3,10 +3,8 @@ require 'forwardable'
 require 'puppet/node'
 require 'puppet/resource/catalog'
 require 'puppet/util/errors'
-require 'puppet/util/manifest_filetype_helper'
 
 require 'puppet/resource/type_collection_helper'
-require 'puppet/dsl/parser'
 
 # Maintain a graph of scopes, along with a bunch of data
 # about the individual catalog we're compiling.
@@ -92,7 +90,6 @@ class Puppet::Parser::Compiler
   # This is the main entry into our catalog.
   def compile
     # Set the client's parameters into the top scope.
-
     set_node_parameters
     create_settings_scope
 
@@ -113,10 +110,6 @@ class Puppet::Parser::Compiler
 
   def_delegator :@collections, :delete, :delete_collection
 
-  def assign_ruby_code(file)
-    Puppet::DSL::Parser.prepare_for_evaluation @main, File.read(file), file
-  end
-
   # Return the node's environment.
   def environment
     unless defined?(@environment)
@@ -286,9 +279,6 @@ class Puppet::Parser::Compiler
 
     add_resource(@topscope, @main_resource)
 
-    file = Puppet.settings.value :manifest, environment
-    assign_ruby_code file if Puppet::Util::ManifestFiletypeHelper.is_ruby_filename? file
-
     @main_resource.evaluate
   end
 

data/lib/puppet/parser/lexer.rb

@@ -25,6 +25,8 @@ class Puppet::Parser::Lexer
   end
 
   class Token
+    ALWAYS_ACCEPTABLE = Proc.new { |context| true }
+
     include Puppet::Util::MethodHelper
 
     attr_accessor :regex, :name, :string, :skip, :incr_line, :skip_text, :accumulate
@@ -40,6 +42,7 @@ class Puppet::Parser::Lexer
       end
 
       set_options(options)
+      @acceptable_when = ALWAYS_ACCEPTABLE
     end
 
     def to_s
@@ -47,8 +50,15 @@ class Puppet::Parser::Lexer
     end
 
     def acceptable?(context={})
-      # By default tokens are aceeptable in any context
-      true
+      @acceptable_when.call(context)
+    end
+
+    # Define when the token is able to match.
+    # This provides context that cannot be expressed otherwise, such as feature flags.
+    #
+    # @param block [Proc] a proc that given a context returns a boolean
+    def acceptable_when(block)
+      @acceptable_when = block
     end
   end
 
@@ -157,15 +167,40 @@ class Puppet::Parser::Lexer
     "<boolean>" => :BOOLEAN
   )
 
+  module Contextual
+    QUOTE_TOKENS = [:DQPRE,:DQMID]
+    REGEX_INTRODUCING_TOKENS = [:NODE,:LBRACE,:RBRACE,:MATCH,:NOMATCH,:COMMA]
+
+    NOT_INSIDE_QUOTES = Proc.new do |context|
+      !QUOTE_TOKENS.include? context[:after]
+    end
+
+    INSIDE_QUOTES = Proc.new do |context|
+      QUOTE_TOKENS.include? context[:after]
+    end
+
+    IN_REGEX_POSITION = Proc.new do |context|
+      REGEX_INTRODUCING_TOKENS.include? context[:after]
+    end
+
+    IN_STRING_INTERPOLATION = Proc.new do |context|
+      context[:string_interpolation_depth] > 0
+    end
+
+    DASHED_VARIABLES_ALLOWED = Proc.new do |context|
+      Puppet[:allow_variables_with_dashes]
+    end
+
+    VARIABLE_AND_DASHES_ALLOWED = Proc.new do |context|
+      Contextual::DASHED_VARIABLES_ALLOWED.call(context) and TOKENS[:VARIABLE].acceptable?(context)
+    end
+  end
+
   # Numbers are treated separately from names, so that they may contain dots.
   TOKENS.add_token :NUMBER, %r{\b(?:0[xX][0-9A-Fa-f]+|0?\d+(?:\.\d+)?(?:[eE]-?\d+)?)\b} do |lexer, value|
     [TOKENS[:NAME], value]
   end
-  #:stopdoc: # Issue #4161
-  def (TOKENS[:NUMBER]).acceptable?(context={})
-    ![:DQPRE,:DQMID].include? context[:after]
-  end
-  #:startdoc:
+  TOKENS[:NUMBER].acceptable_when Contextual::NOT_INSIDE_QUOTES
 
   TOKENS.add_token :NAME, %r{((::)?[a-z0-9][-\w]*)(::[a-z0-9][-\w]*)*} do |lexer, value|
     string_token = self
@@ -179,13 +214,9 @@ class Puppet::Parser::Lexer
     end
     [string_token, value]
   end
-  [:NAME,:CLASSNAME,:CLASSREF].each { |name_token|
-    #:stopdoc: # Issue #4161
-    def (TOKENS[name_token]).acceptable?(context={})
-      ![:DQPRE,:DQMID].include? context[:after]
-    end
-    #:startdoc:
-  }
+  [:NAME, :CLASSREF].each do |name_token|
+    TOKENS[name_token].acceptable_when Contextual::NOT_INSIDE_QUOTES
+  end
 
   TOKENS.add_token :COMMENT, %r{#.*}, :accumulate => true, :skip => true do |lexer,value|
     value.sub!(/# ?/,'')
@@ -208,12 +239,7 @@ class Puppet::Parser::Lexer
     regex = value.sub(%r{\A/}, "").sub(%r{/\Z}, '').gsub("\\/", "/")
     [self, Regexp.new(regex)]
   end
-
-  #:stopdoc: # Issue #4161
-  def (TOKENS[:REGEX]).acceptable?(context={})
-    [:NODE,:LBRACE,:RBRACE,:MATCH,:NOMATCH,:COMMA].include? context[:after]
-  end
-  #:startdoc:
+  TOKENS[:REGEX].acceptable_when Contextual::IN_REGEX_POSITION
 
   TOKENS.add_token :RETURN, "\n", :skip => true, :incr_line => true, :skip_text => true
 
@@ -231,20 +257,14 @@ class Puppet::Parser::Lexer
   TOKENS.add_token :DQCONT, /\}/ do |lexer, value|
     lexer.tokenize_interpolated_string(DQ_continuation_token_types)
   end
-  #:stopdoc: # Issue #4161
-  def (TOKENS[:DQCONT]).acceptable?(context={})
-    context[:string_interpolation_depth] > 0
-  end
-  #:startdoc:
+  TOKENS[:DQCONT].acceptable_when Contextual::IN_STRING_INTERPOLATION
 
   TOKENS.add_token :DOLLAR_VAR_WITH_DASH, %r{\$(?:::)?(?:[-\w]+::)*[-\w]+} do |lexer, value|
     lexer.warn_if_variable_has_hyphen(value)
 
     [TOKENS[:VARIABLE], value[1..-1]]
   end
-  def (TOKENS[:DOLLAR_VAR_WITH_DASH]).acceptable?(context = {})
-    Puppet[:allow_variables_with_dashes]
-  end
+  TOKENS[:DOLLAR_VAR_WITH_DASH].acceptable_when Contextual::DASHED_VARIABLES_ALLOWED
 
   TOKENS.add_token :DOLLAR_VAR, %r{\$(::)?(\w+::)*\w+} do |lexer, value|
     [TOKENS[:VARIABLE],value[1..-1]]
@@ -255,19 +275,10 @@ class Puppet::Parser::Lexer
 
     [TOKENS[:VARIABLE], value]
   end
-  #:stopdoc: # Issue #4161
-  def (TOKENS[:VARIABLE_WITH_DASH]).acceptable?(context={})
-    Puppet[:allow_variables_with_dashes] and TOKENS[:VARIABLE].acceptable?(context)
-  end
-  #:startdoc:
+  TOKENS[:VARIABLE_WITH_DASH].acceptable_when Contextual::VARIABLE_AND_DASHES_ALLOWED
 
   TOKENS.add_token :VARIABLE, %r{(::)?(\w+::)*\w+}
-  #:stopdoc: # Issue #4161
-  def (TOKENS[:VARIABLE]).acceptable?(context={})
-    [:DQPRE,:DQMID].include? context[:after]
-  end
-  #:startdoc:
-
+  TOKENS[:VARIABLE].acceptable_when Contextual::INSIDE_QUOTES
 
   TOKENS.sort_tokens
 

data/lib/puppet/parser/parser_support.rb

@@ -136,18 +136,36 @@ class Puppet::Parser::Parser
 
   # how should I do error handling here?
   def parse(string = nil)
-    self.string = string if string
-
-    @yydebug = false
-    code = yyparse(@lexer, :scan)
-    Puppet::Parser::AST::Hostclass.new('', :code => code)
-  rescue Puppet::ParseError => except
-    except.line ||= @lexer.line
-    except.file ||= @lexer.file
-    raise except
-  rescue => except
-    raise Puppet::ParseError.new(except.message, @lexer.file, @lexer.line, except)
+    if self.file =~ /\.rb$/
+      main = parse_ruby_file
+    else
+      self.string = string if string
+      begin
+        @yydebug = false
+        main = yyparse(@lexer,:scan)
+      rescue Puppet::ParseError => except
+        except.line ||= @lexer.line
+        except.file ||= @lexer.file
+        raise except
+      rescue => except
+        raise Puppet::ParseError.new(except.message, @lexer.file, @lexer.line, except)
+      end
+    end
+    # Store the results as the top-level class.
+    return Puppet::Parser::AST::Hostclass.new('', :code => main)
   ensure
     @lexer.clear
   end
+
+  def parse_ruby_file
+    Puppet.deprecation_warning("Use of the Ruby DSL is deprecated.")
+
+    # Execute the contents of the file inside its own "main" object so
+    # that it can call methods in the resource type API.
+    main_object = Puppet::DSL::ResourceTypeAPI.new
+    main_object.instance_eval(File.read(self.file))
+
+    # Then extract any types that were created.
+    Puppet::Parser::AST::ASTArray.new :children => main_object.instance_eval { @__created_ast_objects__ }
+  end
 end

data/lib/puppet/parser/scope.rb

@@ -379,7 +379,7 @@ class Puppet::Parser::Scope
 
     if options[:append]
       table[name] = append_value(undef_as('', self[name]), value)
-    else
+    else 
       table[name] = value
     end
   end
@@ -407,7 +407,7 @@ class Puppet::Parser::Scope
       bound_value.merge(new_value)
     else
       if bound_value.is_a?(Hash)
-        raise ArgumentError, "Trying to append to a hash with something which is not a hash is unsupported"
+        raise ArgumentError, "Trying to append to a hash with something which is not a hash is unsupported" 
       end
       bound_value + new_value
     end

data/lib/puppet/parser/type_loader.rb

@@ -1,8 +1,6 @@
 require 'find'
 require 'forwardable'
 require 'puppet/node/environment'
-require 'puppet/dsl/parser'
-require 'puppet/util/manifest_filetype_helper'
 
 class Puppet::Parser::TypeLoader
   extend  Forwardable
@@ -84,38 +82,17 @@ class Puppet::Parser::TypeLoader
     end
 
     loaded_asts = []
-    loaded_ruby_types = []
     files.each do |file|
-      file = File.join dir, file unless Puppet::Util.absolute_path? file
-
+      unless Puppet::Util.absolute_path?(file)
+        file = File.join(dir, file)
+      end
       @loading_helper.do_once(file) do
-        if Puppet::Util::ManifestFiletypeHelper.is_ruby_filename? file
-          known_before = known_resource_types.definitions.values +
-            known_resource_types.nodes.values +
-            known_resource_types.hostclasses.values
-
-          type = Puppet::Resource::Type.new(:hostclass, '')
-          begin
-            Puppet::DSL::Parser.prepare_for_evaluation type, File.read(file), file
-          rescue => e
-            raise Puppet::ParseError, e.message
-          end
-          type.ruby_code.each { |c| c.evaluate(nil, known_resource_types) }
-
-          known_now    = known_resource_types.definitions.values +
-            known_resource_types.nodes.values +
-            known_resource_types.hostclasses.values
-          loaded_ruby_types = known_now - known_before
-        else
-          loaded_asts << parse_file(file)
-        end
+        loaded_asts << parse_file(file)
       end
     end
-
-    loaded_puppet_types = loaded_asts.inject([]) do |loaded_types, ast|
+    loaded_asts.inject([]) do |loaded_types, ast|
       loaded_types + known_resource_types.import_ast(ast, modname)
     end
-    loaded_ruby_types + loaded_puppet_types
   end
 
   def import_all
@@ -124,8 +101,7 @@ class Puppet::Parser::TypeLoader
     # given first/foo and second/foo, only files from first/foo will be loaded.
     environment.modules.each do |mod|
       Find.find(mod.manifests) do |path|
-        if Puppet::Util::ManifestFiletypeHelper.is_ruby_filename? path or
-          Puppet::Util::ManifestFiletypeHelper.is_puppet_filename? path
+        if path =~ /\.pp$/ or path =~ /\.rb$/
           import(path)
         end
       end
@@ -163,7 +139,7 @@ class Puppet::Parser::TypeLoader
     Puppet.debug("importing '#{file}' in environment #{environment}")
     parser = Puppet::Parser::Parser.new(environment)
     parser.file = file
-    parser.parse
+    return parser.parse
   end
 
   private