diff --git a/lib/puppet/indirector/face.rb b/lib/puppet/indirector/face.rb
index 27265beba..588859697 100644
--- a/lib/puppet/indirector/face.rb
+++ b/lib/puppet/indirector/face.rb
@@ -1,138 +1,138 @@
 require 'puppet/face'
 
 class Puppet::Indirector::Face < Puppet::Face
   option "--terminus TERMINUS" do
     summary "The indirector terminus to use."
     description <<-EOT
       Indirector faces expose indirected subsystems of Puppet. These
       subsystems are each able to retrieve and alter a specific type of data
       (with the familiar actions of `find`, `search`, `save`, and `destroy`)
       from an arbitrary number of pluggable backends. In Puppet parlance,
       these backends are called terminuses.
 
       Almost all indirected subsystems have a `rest` terminus that interacts
       with the puppet master's data. Most of them have additional terminuses
       for various local data models, which are in turn used by the indirected
       subsystem on the puppet master whenever it receives a remote request.
 
       The terminus for an action is often determined by context, but
       occasionally needs to be set explicitly. See the "Notes" section of this
       face's manpage for more details.
     EOT
 
     before_action do |action, args, options|
       set_terminus(options[:terminus])
     end
 
     after_action do |action, args, options|
       indirection.reset_terminus_class
     end
   end
 
   def self.indirections
     Puppet::Indirector::Indirection.instances.collect { |t| t.to_s }.sort
   end
 
   def self.terminus_classes(indirection)
     Puppet::Indirector::Terminus.terminus_classes(indirection.to_sym).collect { |t| t.to_s }.sort
   end
 
   def call_indirection_method(method, key, options)
     begin
       result = indirection.__send__(method, key, options)
     rescue => detail
       message = "Could not call '#{method}' on '#{indirection_name}': #{detail}"
       Puppet.log_exception(detail, message)
       raise message
     end
 
     return result
   end
 
   option "--extra HASH" do
     summary "Extra arguments to pass to the indirection request"
     description <<-end
       A terminus can take additional arguments to refine the operation, which
       are passed as an arbitrary hash to the back-end.  Anything passed as
       the extra value is just send direct to the back-end.
     end
     default_to do Hash.new end
   end
 
   action :destroy do
     summary "Delete an object."
     arguments "<key>"
     when_invoked {|key, options| call_indirection_method :destroy, key, options[:extra] }
   end
 
   action :find do
     summary "Retrieve an object by name."
     arguments "<key>"
     when_invoked {|key, options| call_indirection_method :find, key, options[:extra] }
   end
 
   action :save do
     summary "API only: create or overwrite an object."
-    arguments "<object>"
+    arguments "<key>"
     description <<-EOT
       API only: create or overwrite an object. As the Faces framework does not
       currently accept data from STDIN, save actions cannot currently be invoked
       from the command line.
     EOT
     when_invoked {|key, options| call_indirection_method :save, key, options[:extra] }
   end
 
   action :search do
     summary "Search for an object or retrieve multiple objects."
     arguments "<query>"
     when_invoked {|key, options| call_indirection_method :search, key, options[:extra] }
   end
 
   # Print the configuration for the current terminus class
   action :info do
     summary "Print the default terminus class for this face."
     description <<-EOT
       Prints the default terminus class for this subcommand. Note that different
       run modes may have different default termini; when in doubt, specify the
       run mode with the '--mode' option.
     EOT
 
     when_invoked do |options|
       if t = indirection.terminus_class
         "Run mode '#{Puppet.run_mode.name}': #{t}"
       else
         "No default terminus class for run mode '#{Puppet.run_mode.name}'"
       end
     end
   end
 
   attr_accessor :from
 
   def indirection_name
     @indirection_name || name.to_sym
   end
 
   # Here's your opportunity to override the indirection name.  By default it
   # will be the same name as the face.
   def set_indirection_name(name)
     @indirection_name = name
   end
 
   # Return an indirection associated with a face, if one exists;
   # One usually does.
   def indirection
     unless @indirection
       @indirection = Puppet::Indirector::Indirection.instance(indirection_name)
       @indirection or raise "Could not find terminus for #{indirection_name}"
     end
     @indirection
   end
 
   def set_terminus(from)
     begin
       indirection.terminus_class = from
     rescue => detail
       raise "Could not set '#{indirection.name}' terminus to '#{from}' (#{detail}); valid terminus types are #{self.class.terminus_classes(indirection.name).join(", ") }"
     end
   end
 end
diff --git a/lib/puppet/node/environment.rb b/lib/puppet/node/environment.rb
index 9eb70fc02..d10511581 100644
--- a/lib/puppet/node/environment.rb
+++ b/lib/puppet/node/environment.rb
@@ -1,225 +1,223 @@
 require 'puppet/util'
 require 'puppet/util/cacher'
 require 'monitor'
 
 # Just define it, so this class has fewer load dependencies.
 class Puppet::Node
 end
 
 # Model the environment that a node can operate in.  This class just
 # provides a simple wrapper for the functionality around environments.
 class Puppet::Node::Environment
   module Helper
     def environment
       Puppet::Node::Environment.new(@environment)
     end
 
     def environment=(env)
       if env.is_a?(String) or env.is_a?(Symbol)
         @environment = env
       else
         @environment = env.name
       end
     end
   end
 
   include Puppet::Util::Cacher
 
   @seen = {}
 
   # Return an existing environment instance, or create a new one.
   def self.new(name = nil)
     return name if name.is_a?(self)
     name ||= Puppet.settings.value(:environment)
 
     raise ArgumentError, "Environment name must be specified" unless name
 
     symbol = name.to_sym
 
     return @seen[symbol] if @seen[symbol]
 
     obj = self.allocate
     obj.send :initialize, symbol
     @seen[symbol] = obj
   end
 
   def self.current
     Thread.current[:environment] || root
   end
 
   def self.current=(env)
     Thread.current[:environment] = new(env)
   end
 
   def self.root
     @root
   end
 
   def self.clear
     @seen.clear
   end
 
   attr_reader :name
 
   # Return an environment-specific setting.
   def [](param)
     Puppet.settings.value(param, self.name)
   end
 
   def initialize(name)
     @name = name
     extend MonitorMixin
   end
 
   def known_resource_types
     # This makes use of short circuit evaluation to get the right thread-safe
     # per environment semantics with an efficient most common cases; we almost
     # always just return our thread's known-resource types.  Only at the start
     # of a compilation (after our thread var has been set to nil) or when the
     # environment has changed do we delve deeper.
     Thread.current[:known_resource_types] = nil if (krt = Thread.current[:known_resource_types]) && krt.environment != self
     Thread.current[:known_resource_types] ||= synchronize {
       if @known_resource_types.nil? or @known_resource_types.require_reparse?
         @known_resource_types = Puppet::Resource::TypeCollection.new(self)
         @known_resource_types.import_ast(perform_initial_import, '')
       end
       @known_resource_types
     }
   end
 
   def module(name)
-    mod = Puppet::Module.new(name, :environment => self)
-    return nil unless mod.exist?
-    mod
+    modules.find {|mod| mod.name == name}
   end
 
   def module_by_forge_name(forge_name)
     author, modname = forge_name.split('/')
     found_mod = self.module(modname)
     found_mod and found_mod.forge_name == forge_name ?
       found_mod :
       nil
   end
 
   # Cache the modulepath, so that we aren't searching through
   # all known directories all the time.
   cached_attr(:modulepath, Puppet[:filetimeout]) do
     dirs = self[:modulepath].split(File::PATH_SEPARATOR)
     dirs = ENV["PUPPETLIB"].split(File::PATH_SEPARATOR) + dirs if ENV["PUPPETLIB"]
     validate_dirs(dirs)
   end
 
   # Return all modules from this environment.
   # Cache the list, because it can be expensive to create.
   cached_attr(:modules, Puppet[:filetimeout]) do
     module_names =
         modulepath.collect do |path|
           module_names = Dir.entries(path)
           Puppet.debug("Warning: Found directory named 'lib' in module path ('#{path}/lib'); unless " +
               "you are expecting to load a module named 'lib', your module path may be set " +
                "incorrectly.") if module_names.include?("lib")
           module_names
         end .flatten.uniq
 
     module_names.collect do |path|
       begin
         Puppet::Module.new(path, :environment => self)
       rescue Puppet::Module::Error => e
         nil
       end
     end.compact
   end
 
   # Modules broken out by directory in the modulepath
   def modules_by_path
     modules_by_path = {}
     modulepath.each do |path|
       Dir.chdir(path) do
         module_names = Dir.glob('*').select do |d|
           FileTest.directory?(d) && (File.basename(d) =~ /^[\w]+([-]{1}[\w]+)*$/)
         end
         modules_by_path[path] = module_names.sort.map do |name|
           Puppet::Module.new(name, :environment => self, :path => File.join(path, name))
         end
       end
     end
     modules_by_path
   end
 
   def module_requirements
     deps = {}
     modules.each do |mod|
       next unless mod.forge_name
       deps[mod.forge_name] ||= []
       mod.dependencies and mod.dependencies.each do |mod_dep|
         deps[mod_dep['name']] ||= []
         dep_details = {
           'name'                => mod.forge_name,
           'version'             => mod.version,
           'version_requirement' => mod_dep['version_requirement']
         }
         deps[mod_dep['name']] << dep_details
       end
     end
     deps.each do |mod, mod_deps|
       deps[mod] = mod_deps.sort_by {|d| d['name']}
     end
     deps
   end
 
   def to_s
     name.to_s
   end
 
   def to_sym
     to_s.to_sym
   end
 
   # The only thing we care about when serializing an environment is its
   # identity; everything else is ephemeral and should not be stored or
   # transmitted.
   def to_zaml(z)
     self.to_s.to_zaml(z)
   end
 
   def validate_dirs(dirs)
     dirs.collect do |dir|
       unless Puppet::Util.absolute_path?(dir)
         File.expand_path(File.join(Dir.getwd, dir))
       else
         dir
       end
     end.find_all do |p|
       Puppet::Util.absolute_path?(p) && FileTest.directory?(p)
     end
   end
 
   private
 
   def perform_initial_import
     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
     else
       file = Puppet.settings.value(:manifest, name.to_s)
       parser.file = file
     end
     parser.parse
   rescue => detail
     known_resource_types.parse_failed = true
 
     msg = "Could not parse for environment #{self}: #{detail}"
     error = Puppet::Error.new(msg)
     error.set_backtrace(detail.backtrace)
     raise error
   end
 
   def empty_parse_result
     # Return an empty toplevel hostclass to use as the result of
     # perform_initial_import when no file was actually loaded.
     return Puppet::Parser::AST::Hostclass.new('')
   end
 
   @root = new(:'*root*')
 end
diff --git a/lib/puppet/parser/functions/template.rb b/lib/puppet/parser/functions/template.rb
index 6fa110332..8105e2cac 100644
--- a/lib/puppet/parser/functions/template.rb
+++ b/lib/puppet/parser/functions/template.rb
@@ -1,24 +1,25 @@
 Puppet::Parser::Functions::newfunction(:template, :type => :rvalue, :doc =>
   "Evaluate a template and return its value.  See
   [the templating docs](http://docs.puppetlabs.com/guides/templating.html) for 
   more information.
   
   Note that if multiple templates are specified, their output is all
   concatenated and returned as the output of the function.") do |vals|
     require 'erb'
 
     vals.collect do |file|
       # Use a wrapper, so the template can't get access to the full
       # Scope object.
       debug "Retrieving template #{file}"
 
       wrapper = Puppet::Parser::TemplateWrapper.new(self)
       wrapper.file = file
       begin
         wrapper.result
       rescue => detail
+        info = detail.backtrace.first.split(':')
         raise Puppet::ParseError,
-          "Failed to parse template #{file}: #{detail}"
+          "Failed to parse template #{file}:\n  Filepath: #{info[0]}\n  Line: #{info[1]}\n  Detail: #{detail}\n"
       end
     end.join("")
 end
diff --git a/lib/puppet/parser/lexer.rb b/lib/puppet/parser/lexer.rb
index c4bee35aa..1b8b91354 100644
--- a/lib/puppet/parser/lexer.rb
+++ b/lib/puppet/parser/lexer.rb
@@ -1,584 +1,584 @@
 # the scanner/lexer
 
 require 'strscan'
 require 'puppet'
 
 
 module Puppet
   class LexError < RuntimeError; end
 end
 
 module Puppet::Parser; end
 
 class Puppet::Parser::Lexer
   attr_reader :last, :file, :lexing_context, :token_queue
 
   attr_accessor :line, :indefine
 
   def lex_error msg
     raise Puppet::LexError.new(msg)
   end
 
   class Token
     attr_accessor :regex, :name, :string, :skip, :incr_line, :skip_text, :accumulate
 
     def initialize(regex, name)
       if regex.is_a?(String)
         @name, @string = name, regex
         @regex = Regexp.new(Regexp.escape(@string))
       else
         @name, @regex = name, regex
       end
     end
 
     # MQR: Why not just alias?
     %w{skip accumulate}.each do |method|
       define_method(method+"?") do
         self.send(method)
       end
     end
 
     def to_s
       if self.string
         @string
       else
         @name.to_s
       end
     end
 
     def acceptable?(context={})
       # By default tokens are aceeptable in any context
       true
     end
   end
 
   # Maintain a list of tokens.
   class TokenList
     attr_reader :regex_tokens, :string_tokens
 
     def [](name)
       @tokens[name]
     end
 
     # Create a new token.
     def add_token(name, regex, options = {}, &block)
       token = Token.new(regex, name)
       raise(ArgumentError, "Token #{name} already exists") if @tokens.include?(name)
       @tokens[token.name] = token
       if token.string
         @string_tokens << token
         @tokens_by_string[token.string] = token
       else
         @regex_tokens << token
       end
 
       options.each do |name, option|
         token.send(name.to_s + "=", option)
       end
 
       token.meta_def(:convert, &block) if block_given?
 
       token
     end
 
     def initialize
       @tokens = {}
       @regex_tokens = []
       @string_tokens = []
       @tokens_by_string = {}
     end
 
     # Look up a token by its value, rather than name.
     def lookup(string)
       @tokens_by_string[string]
     end
 
     # Define more tokens.
     def add_tokens(hash)
       hash.each do |regex, name|
         add_token(name, regex)
       end
     end
 
     # Sort our tokens by length, so we know once we match, we're done.
     # This helps us avoid the O(n^2) nature of token matching.
     def sort_tokens
       @string_tokens.sort! { |a, b| b.string.length <=> a.string.length }
     end
   end
 
   TOKENS = TokenList.new
 
     TOKENS.add_tokens(
 
       '[' => :LBRACK,
       ']' => :RBRACK,
       '{' => :LBRACE,
       '}' => :RBRACE,
       '(' => :LPAREN,
 
       ')' => :RPAREN,
       '=' => :EQUALS,
       '+=' => :APPENDS,
       '==' => :ISEQUAL,
       '>=' => :GREATEREQUAL,
       '>' => :GREATERTHAN,
       '<' => :LESSTHAN,
       '<=' => :LESSEQUAL,
       '!=' => :NOTEQUAL,
       '!' => :NOT,
       ',' => :COMMA,
       '.' => :DOT,
       ':' => :COLON,
       '@' => :AT,
       '<<|' => :LLCOLLECT,
       '->' => :IN_EDGE,
       '<-' => :OUT_EDGE,
       '~>' => :IN_EDGE_SUB,
       '<~' => :OUT_EDGE_SUB,
       '|>>' => :RRCOLLECT,
       '<|' => :LCOLLECT,
       '|>' => :RCOLLECT,
       ';' => :SEMIC,
       '?' => :QMARK,
       '\\' => :BACKSLASH,
       '=>' => :FARROW,
       '+>' => :PARROW,
       '+' => :PLUS,
       '-' => :MINUS,
       '/' => :DIV,
       '*' => :TIMES,
       '<<' => :LSHIFT,
       '>>' => :RSHIFT,
       '=~' => :MATCH,
       '!~' => :NOMATCH,
       %r{((::){0,1}[A-Z][-\w]*)+} => :CLASSREF,
       "<string>" => :STRING,
       "<dqstring up to first interpolation>" => :DQPRE,
       "<dqstring between two interpolations>" => :DQMID,
       "<dqstring after final interpolation>" => :DQPOST,
       "<boolean>" => :BOOLEAN
       )
 
   # 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.add_token :NAME, %r{((::)?[a-z0-9][-\w]*)(::[a-z0-9][-\w]*)*} do |lexer, value|
     string_token = self
     # we're looking for keywords here
     if tmp = KEYWORDS.lookup(value)
       string_token = tmp
       if [:TRUE, :FALSE].include?(string_token.name)
         value = eval(value)
         string_token = TOKENS[:BOOLEAN]
       end
     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:
   }
 
   TOKENS.add_token :COMMENT, %r{#.*}, :accumulate => true, :skip => true do |lexer,value|
     value.sub!(/# ?/,'')
     [self, value]
   end
 
   TOKENS.add_token :MLCOMMENT, %r{/\*(.*?)\*/}m, :accumulate => true, :skip => true do |lexer, value|
     lexer.line += value.count("\n")
     value.sub!(/^\/\* ?/,'')
     value.sub!(/ ?\*\/$/,'')
     [self,value]
   end
 
   TOKENS.add_token :REGEX, %r{/[^/\n]*/} do |lexer, value|
     # Make sure we haven't matched an escaped /
     while value[-2..-2] == '\\'
       other = lexer.scan_until(%r{/})
       value += other
     end
     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.add_token :RETURN, "\n", :skip => true, :incr_line => true, :skip_text => true
 
   TOKENS.add_token :SQUOTE, "'" do |lexer, value|
     [TOKENS[:STRING], lexer.slurpstring(value,["'"],:ignore_invalid_escapes).first ]
   end
 
   DQ_initial_token_types      = {'$' => :DQPRE,'"' => :STRING}
   DQ_continuation_token_types = {'$' => :DQMID,'"' => :DQPOST}
 
   TOKENS.add_token :DQUOTE, /"/ do |lexer, value|
     lexer.tokenize_interpolated_string(DQ_initial_token_types)
   end
 
   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.add_token :DOLLAR_VAR, %r{\$(::)?([-\w]+::)*[-\w]+} do |lexer, value|
+  TOKENS.add_token :DOLLAR_VAR, %r{\$(::)?(\w+::)*\w+} do |lexer, value|
     [TOKENS[:VARIABLE],value[1..-1]]
   end
 
-  TOKENS.add_token :VARIABLE, %r{(::)?([-\w]+::)*[-\w]+}
+  TOKENS.add_token :VARIABLE, %r{(::)?(\w+::)*\w+}
   #:stopdoc: # Issue #4161
   def (TOKENS[:VARIABLE]).acceptable?(context={})
     [:DQPRE,:DQMID].include? context[:after]
   end
   #:startdoc:
 
 
   TOKENS.sort_tokens
 
   @@pairs = {
     "{" => "}",
     "(" => ")",
     "[" => "]",
     "<|" => "|>",
     "<<|" => "|>>"
   }
 
   KEYWORDS = TokenList.new
 
 
     KEYWORDS.add_tokens(
 
       "case" => :CASE,
       "class" => :CLASS,
       "default" => :DEFAULT,
       "define" => :DEFINE,
       "import" => :IMPORT,
       "if" => :IF,
       "elsif" => :ELSIF,
       "else" => :ELSE,
       "inherits" => :INHERITS,
       "node" => :NODE,
       "and"  => :AND,
       "or"   => :OR,
       "undef"   => :UNDEF,
       "false" => :FALSE,
       "true" => :TRUE,
 
       "in" => :IN,
       "unless" => :UNLESS
   )
 
   def clear
     initvars
   end
 
   def expected
     return nil if @expected.empty?
     name = @expected[-1]
     TOKENS.lookup(name) or lex_error "Could not find expected token #{name}"
   end
 
   # scan the whole file
   # basically just used for testing
   def fullscan
     array = []
 
     self.scan { |token, str|
       # Ignore any definition nesting problems
       @indefine = false
       array.push([token,str])
     }
     array
   end
 
   def file=(file)
     @file = file
     @line = 1
     contents = File.exists?(file) ? File.read(file) : ""
     @scanner = StringScanner.new(contents)
   end
 
   def shift_token
     @token_queue.shift
   end
 
   def find_string_token
     # We know our longest string token is three chars, so try each size in turn
     # until we either match or run out of chars.  This way our worst-case is three
     # tries, where it is otherwise the number of string token we have.  Also,
     # the lookups are optimized hash lookups, instead of regex scans.
     #
     s = @scanner.peek(3)
     token = TOKENS.lookup(s[0,3]) || TOKENS.lookup(s[0,2]) || TOKENS.lookup(s[0,1])
     [ token, token && @scanner.scan(token.regex) ]
   end
 
   # Find the next token that matches a regex.  We look for these first.
   def find_regex_token
     @regex += 1
     best_token = nil
     best_length = 0
 
     # I tried optimizing based on the first char, but it had
     # a slightly negative affect and was a good bit more complicated.
     TOKENS.regex_tokens.each do |token|
       if length = @scanner.match?(token.regex) and token.acceptable?(lexing_context)
         # We've found a longer match
         if length > best_length
           best_length = length
           best_token = token
         end
       end
     end
 
     return best_token, @scanner.scan(best_token.regex) if best_token
   end
 
   # Find the next token, returning the string and the token.
   def find_token
     @find += 1
     shift_token || find_regex_token || find_string_token
   end
 
   def indefine?
     if defined?(@indefine)
       @indefine
     else
       false
     end
   end
 
   def initialize
     @find = 0
     @regex = 0
     initvars
   end
 
   def initvars
     @line = 1
     @previous_token = nil
     @scanner = nil
     @file = nil
     # AAARRGGGG! okay, regexes in ruby are bloody annoying
     # no one else has "\n" =~ /\s/
     @skip = %r{[ \t\r]+}
 
     @namestack = []
     @token_queue = []
     @indefine = false
     @expected = []
     @commentstack = [ ['', @line] ]
     @lexing_context = {
       :after => nil,
       :start_of_line => true,
       :string_interpolation_depth => 0
       }
   end
 
   # Make any necessary changes to the token and/or value.
   def munge_token(token, value)
     @line += 1 if token.incr_line
 
     skip if token.skip_text
 
     return if token.skip and not token.accumulate?
 
     token, value = token.convert(self, value) if token.respond_to?(:convert)
 
     return unless token
 
     if token.accumulate?
       comment = @commentstack.pop
       comment[0] << value + "\n"
       @commentstack.push(comment)
     end
 
     return if token.skip
 
     return token, { :value => value, :line => @line }
   end
 
   # Go up one in the namespace.
   def namepop
     @namestack.pop
   end
 
   # Collect the current namespace.
   def namespace
     @namestack.join("::")
   end
 
   # This value might have :: in it, but we don't care -- it'll be
   # handled normally when joining, and when popping we want to pop
   # this full value, however long the namespace is.
   def namestack(value)
     @namestack << value
   end
 
   def rest
     @scanner.rest
   end
 
   # this is the heart of the lexer
   def scan
     #Puppet.debug("entering scan")
     lex_error "Invalid or empty string" unless @scanner
 
     # Skip any initial whitespace.
     skip
 
     until token_queue.empty? and @scanner.eos? do
       yielded = false
       matched_token, value = find_token
 
       # error out if we didn't match anything at all
       lex_error "Could not match #{@scanner.rest[/^(\S+|\s+|.*)/]}" unless matched_token
 
       newline = matched_token.name == :RETURN
 
       # this matches a blank line; eat the previously accumulated comments
       getcomment if lexing_context[:start_of_line] and newline
       lexing_context[:start_of_line] = newline
 
       final_token, token_value = munge_token(matched_token, value)
 
       unless final_token
         skip
         next
       end
 
       lexing_context[:after]         = final_token.name unless newline
       lexing_context[:string_interpolation_depth] += 1 if final_token.name == :DQPRE
       lexing_context[:string_interpolation_depth] -= 1 if final_token.name == :DQPOST
 
       value = token_value[:value]
 
       if match = @@pairs[value] and final_token.name != :DQUOTE and final_token.name != :SQUOTE
         @expected << match
       elsif exp = @expected[-1] and exp == value and final_token.name != :DQUOTE and final_token.name != :SQUOTE
         @expected.pop
       end
 
       if final_token.name == :LBRACE or final_token.name == :LPAREN
         commentpush
       end
       if final_token.name == :RPAREN
         commentpop
       end
 
       yield [final_token.name, token_value]
 
       if @previous_token
         namestack(value) if @previous_token.name == :CLASS and value != '{'
 
         if @previous_token.name == :DEFINE
           if indefine?
             msg = "Cannot nest definition #{value} inside #{@indefine}"
             self.indefine = false
             raise Puppet::ParseError, msg
           end
 
           @indefine = value
         end
       end
       @previous_token = final_token
       skip
     end
     @scanner = nil
 
     # This indicates that we're done parsing.
     yield [false,false]
   end
 
   # Skip any skipchars in our remaining string.
   def skip
     @scanner.skip(@skip)
   end
 
   # Provide some limited access to the scanner, for those
   # tokens that need it.
   def scan_until(regex)
     @scanner.scan_until(regex)
   end
 
   # we've encountered the start of a string...
   # slurp in the rest of the string and return it
   def slurpstring(terminators,escapes=%w{ \\  $ ' " n t s }+["\n"],ignore_invalid_escapes=false)
     # we search for the next quote that isn't preceded by a
     # backslash; the caret is there to match empty strings
     str = @scanner.scan_until(/([^\\]|^|[^\\])([\\]{2})*[#{terminators}]/) or lex_error "Unclosed quote after '#{last}' in '#{rest}'"
     @line += str.count("\n") # literal carriage returns add to the line count.
     str.gsub!(/\\(.)/m) {
       ch = $1
       if escapes.include? ch
         case ch
         when 'n'; "\n"
         when 't'; "\t"
         when 's'; " "
         when "\n"; ''
         else      ch
         end
       else
         Puppet.warning "Unrecognised escape sequence '\\#{ch}'#{file && " in file #{file}"}#{line && " at line #{line}"}" unless ignore_invalid_escapes
         "\\#{ch}"
       end
     }
     [ str[0..-2],str[-1,1] ]
   end
 
   def tokenize_interpolated_string(token_type,preamble='')
     value,terminator = slurpstring('"$')
     token_queue << [TOKENS[token_type[terminator]],preamble+value]
     if terminator != '$' or @scanner.scan(/\{/)
       token_queue.shift
     elsif var_name = @scanner.scan(TOKENS[:VARIABLE].regex)
       token_queue << [TOKENS[:VARIABLE],var_name]
       tokenize_interpolated_string(DQ_continuation_token_types)
     else
       tokenize_interpolated_string(token_type,token_queue.pop.last + terminator)
     end
   end
 
   # just parse a string, not a whole file
   def string=(string)
     @scanner = StringScanner.new(string)
   end
 
   # returns the content of the currently accumulated content cache
   def commentpop
     @commentstack.pop[0]
   end
 
   def getcomment(line = nil)
     comment = @commentstack.last
     if line.nil? or comment[1] <= line
       @commentstack.pop
       @commentstack.push(['', @line])
       return comment[0]
     end
     ''
   end
 
   def commentpush
     @commentstack.push(['', @line])
   end
 end
diff --git a/spec/unit/node/environment_spec.rb b/spec/unit/node/environment_spec.rb
index 236a043a0..260a8ea8e 100755
--- a/spec/unit/node/environment_spec.rb
+++ b/spec/unit/node/environment_spec.rb
@@ -1,447 +1,452 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'tmpdir'
 
 require 'puppet/node/environment'
 require 'puppet/util/execution'
 require 'puppet_spec/modules'
 
 describe Puppet::Node::Environment do
   let(:env) { Puppet::Node::Environment.new("testing") }
 
   include PuppetSpec::Files
   after do
     Puppet::Node::Environment.clear
   end
 
   it "should use the filetimeout for the ttl for the modulepath" do
     Puppet::Node::Environment.attr_ttl(:modulepath).should == Integer(Puppet[:filetimeout])
   end
 
   it "should use the filetimeout for the ttl for the module list" do
     Puppet::Node::Environment.attr_ttl(:modules).should == Integer(Puppet[:filetimeout])
   end
 
   it "should use the default environment if no name is provided while initializing an environment" do
     Puppet.settings.expects(:value).with(:environment).returns("one")
     Puppet::Node::Environment.new.name.should == :one
   end
 
   it "should treat environment instances as singletons" do
     Puppet::Node::Environment.new("one").should equal(Puppet::Node::Environment.new("one"))
   end
 
   it "should treat an environment specified as names or strings as equivalent" do
     Puppet::Node::Environment.new(:one).should equal(Puppet::Node::Environment.new("one"))
   end
 
   it "should return its name when converted to a string" do
     Puppet::Node::Environment.new(:one).to_s.should == "one"
   end
 
   it "should just return any provided environment if an environment is provided as the name" do
     one = Puppet::Node::Environment.new(:one)
     Puppet::Node::Environment.new(one).should equal(one)
   end
 
   describe "when managing known resource types" do
     before do
       @collection = Puppet::Resource::TypeCollection.new(env)
       env.stubs(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
       Thread.current[:known_resource_types] = nil
     end
 
     it "should create a resource type collection if none exists" do
       Puppet::Resource::TypeCollection.expects(:new).with(env).returns @collection
       env.known_resource_types.should equal(@collection)
     end
 
     it "should reuse any existing resource type collection" do
       env.known_resource_types.should equal(env.known_resource_types)
     end
 
     it "should perform the initial import when creating a new collection" do
       env.expects(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
       env.known_resource_types
     end
 
     it "should return the same collection even if stale if it's the same thread" do
       Puppet::Resource::TypeCollection.stubs(:new).returns @collection
       env.known_resource_types.stubs(:stale?).returns true
 
       env.known_resource_types.should equal(@collection)
     end
 
     it "should return the current thread associated collection if there is one" do
       Thread.current[:known_resource_types] = @collection
 
       env.known_resource_types.should equal(@collection)
     end
 
     it "should give to all threads using the same environment the same collection if the collection isn't stale" do
       original_thread_type_collection = Puppet::Resource::TypeCollection.new(env)
       Puppet::Resource::TypeCollection.expects(:new).with(env).returns original_thread_type_collection
       env.known_resource_types.should equal(original_thread_type_collection)
 
       original_thread_type_collection.expects(:require_reparse?).returns(false)
       Puppet::Resource::TypeCollection.stubs(:new).with(env).returns @collection
 
       t = Thread.new {
         env.known_resource_types.should equal(original_thread_type_collection)
       }
       t.join
     end
 
     it "should generate a new TypeCollection if the current one requires reparsing" do
       old_type_collection = env.known_resource_types
       old_type_collection.stubs(:require_reparse?).returns true
       Thread.current[:known_resource_types] = nil
       new_type_collection = env.known_resource_types
 
       new_type_collection.should be_a Puppet::Resource::TypeCollection
       new_type_collection.should_not equal(old_type_collection)
     end
   end
 
   it "should validate the modulepath directories" do
     real_file = tmpdir('moduledir')
     path = %W[/one /two #{real_file}].join(File::PATH_SEPARATOR)
 
     Puppet[:modulepath] = path
 
     env.modulepath.should == [real_file]
   end
 
   it "should prefix the value of the 'PUPPETLIB' environment variable to the module path if present" do
     Puppet::Util.withenv("PUPPETLIB" => %w{/l1 /l2}.join(File::PATH_SEPARATOR)) do
       module_path = %w{/one /two}.join(File::PATH_SEPARATOR)
       env.expects(:validate_dirs).with(%w{/l1 /l2 /one /two}).returns %w{/l1 /l2 /one /two}
       env.expects(:[]).with(:modulepath).returns module_path
 
       env.modulepath.should == %w{/l1 /l2 /one /two}
     end
   end
 
   describe "when validating modulepath or manifestdir directories" do
     before :each do
       @path_one = tmpdir("path_one")
       @path_two = tmpdir("path_one")
       sep = File::PATH_SEPARATOR
       Puppet[:modulepath] = "#{@path_one}#{sep}#{@path_two}"
     end
 
     it "should not return non-directories" do
       FileTest.expects(:directory?).with(@path_one).returns true
       FileTest.expects(:directory?).with(@path_two).returns false
 
       env.validate_dirs([@path_one, @path_two]).should == [@path_one]
     end
 
     it "should use the current working directory to fully-qualify unqualified paths" do
       FileTest.stubs(:directory?).returns true
 
       two = File.expand_path(File.join(Dir.getwd, "two"))
       env.validate_dirs([@path_one, 'two']).should == [@path_one, two]
     end
   end
 
   describe "when modeling a specific environment" do
     it "should have a method for returning the environment name" do
       Puppet::Node::Environment.new("testing").name.should == :testing
     end
 
     it "should provide an array-like accessor method for returning any environment-specific setting" do
       env.should respond_to(:[])
     end
 
     it "should ask the Puppet settings instance for the setting qualified with the environment name" do
       Puppet.settings.expects(:value).with("myvar", :testing).returns("myval")
       env["myvar"].should == "myval"
     end
 
     it "should be able to return an individual module that exists in its module path" do
+      env.stubs(:modules).returns [Puppet::Module.new('one'), Puppet::Module.new('two'), Puppet::Module.new('three')]
 
-      mod = mock 'module'
-      Puppet::Module.expects(:new).with("one", :environment => env).returns mod
-      mod.expects(:exist?).returns true
+      mod = env.module('one')
+      mod.should be_a(Puppet::Module)
+      mod.name.should == 'one'
+    end
+
+    it "should not return a module if the module doesn't exist" do
+      env.stubs(:modules).returns [Puppet::Module.new('one'), Puppet::Module.new('two'), Puppet::Module.new('three')]
 
-      env.module("one").should equal(mod)
+      env.module('four').should be_nil
     end
 
     it "should return nil if asked for a module that does not exist in its path" do
       modpath = tmpdir('modpath')
       env.modulepath = [modpath]
 
       env.module("one").should be_nil
     end
 
     describe "module data" do
       before do
         dir = tmpdir("deep_path")
 
         @first = File.join(dir, "first")
         @second = File.join(dir, "second")
         Puppet[:modulepath] = "#{@first}#{File::PATH_SEPARATOR}#{@second}"
 
         FileUtils.mkdir_p(@first)
         FileUtils.mkdir_p(@second)
       end
 
       describe "#modules_by_path" do
         it "should return an empty list if there are no modules" do
           env.modules_by_path.should == {
             @first  => [],
             @second => []
           }
         end
 
         it "should include modules even if they exist in multiple dirs in the modulepath" do
           modpath1 = File.join(@first, "foo")
           FileUtils.mkdir_p(modpath1)
           modpath2 = File.join(@second, "foo")
           FileUtils.mkdir_p(modpath2)
 
           env.modules_by_path.should == {
             @first  => [Puppet::Module.new('foo', :environment => env, :path => modpath1)],
             @second => [Puppet::Module.new('foo', :environment => env, :path => modpath2)]
           }
         end
 
         it "should ignore modules with invalid names" do
           FileUtils.mkdir_p(File.join(@first, 'foo'))
           FileUtils.mkdir_p(File.join(@first, 'foo2'))
           FileUtils.mkdir_p(File.join(@first, 'foo-bar'))
           FileUtils.mkdir_p(File.join(@first, 'foo_bar'))
           FileUtils.mkdir_p(File.join(@first, 'foo=bar'))
           FileUtils.mkdir_p(File.join(@first, 'foo bar'))
           FileUtils.mkdir_p(File.join(@first, 'foo.bar'))
           FileUtils.mkdir_p(File.join(@first, '-foo'))
           FileUtils.mkdir_p(File.join(@first, 'foo-'))
           FileUtils.mkdir_p(File.join(@first, 'foo--bar'))
 
           env.modules_by_path[@first].collect{|mod| mod.name}.sort.should == %w{foo foo-bar foo2 foo_bar}
         end
 
       end
 
       describe "#module_requirements" do
         it "should return a list of what modules depend on other modules" do
           PuppetSpec::Modules.create(
             'foo',
             @first,
             :metadata => {
               :author       => 'puppetlabs',
               :dependencies => [{ 'name' => 'puppetlabs/bar', "version_requirement" => ">= 1.0.0" }]
             }
           )
           PuppetSpec::Modules.create(
             'bar',
             @second,
             :metadata => {
               :author       => 'puppetlabs',
               :dependencies => [{ 'name' => 'puppetlabs/foo', "version_requirement" => "<= 2.0.0" }]
             }
           )
           PuppetSpec::Modules.create(
             'baz',
             @first,
             :metadata => {
               :author       => 'puppetlabs',
               :dependencies => [{ 'name' => 'puppetlabs/bar', "version_requirement" => "3.0.0" }]
             }
           )
           PuppetSpec::Modules.create(
             'alpha',
             @first,
             :metadata => {
               :author       => 'puppetlabs',
               :dependencies => [{ 'name' => 'puppetlabs/bar', "version_requirement" => "~3.0.0" }]
             }
           )
 
           env.module_requirements.should == {
             'puppetlabs/alpha' => [],
             'puppetlabs/foo' => [
               {
                 "name"    => "puppetlabs/bar",
                 "version" => "9.9.9",
                 "version_requirement" => "<= 2.0.0"
               }
             ],
             'puppetlabs/bar' => [
               {
                 "name"    => "puppetlabs/alpha",
                 "version" => "9.9.9",
                 "version_requirement" => "~3.0.0"
               },
               {
                 "name"    => "puppetlabs/baz",
                 "version" => "9.9.9",
                 "version_requirement" => "3.0.0"
               },
               {
                 "name"    => "puppetlabs/foo",
                 "version" => "9.9.9",
                 "version_requirement" => ">= 1.0.0"
               }
             ],
             'puppetlabs/baz' => []
           }
         end
       end
 
       describe ".module_by_forge_name" do
         it "should find modules by forge_name" do
           mod = PuppetSpec::Modules.create(
             'baz',
             @first,
             :metadata => {:author => 'puppetlabs'},
             :environment => env
           )
           env.module_by_forge_name('puppetlabs/baz').should == mod
         end
 
         it "should not find modules with same name by the wrong author" do
           mod = PuppetSpec::Modules.create(
             'baz',
             @first,
             :metadata => {:author => 'sneakylabs'},
             :environment => env
           )
           env.module_by_forge_name('puppetlabs/baz').should == nil
         end
 
         it "should return nil when the module can't be found" do
           env.module_by_forge_name('ima/nothere').should be_nil
         end
       end
 
       describe ".modules" do
         it "should return an empty list if there are no modules" do
           env.modules.should == []
         end
 
         it "should return a module named for every directory in each module path" do
           %w{foo bar}.each do |mod_name|
             FileUtils.mkdir_p(File.join(@first, mod_name))
           end
           %w{bee baz}.each do |mod_name|
             FileUtils.mkdir_p(File.join(@second, mod_name))
           end
           env.modules.collect{|mod| mod.name}.sort.should == %w{foo bar bee baz}.sort
         end
 
         it "should remove duplicates" do
           FileUtils.mkdir_p(File.join(@first,  'foo'))
           FileUtils.mkdir_p(File.join(@second, 'foo'))
 
           env.modules.collect{|mod| mod.name}.sort.should == %w{foo}
         end
 
         it "should ignore modules with invalid names" do
           FileUtils.mkdir_p(File.join(@first, 'foo'))
           FileUtils.mkdir_p(File.join(@first, 'foo2'))
           FileUtils.mkdir_p(File.join(@first, 'foo-bar'))
           FileUtils.mkdir_p(File.join(@first, 'foo_bar'))
           FileUtils.mkdir_p(File.join(@first, 'foo=bar'))
           FileUtils.mkdir_p(File.join(@first, 'foo bar'))
 
           env.modules.collect{|mod| mod.name}.sort.should == %w{foo foo-bar foo2 foo_bar}
         end
 
         it "should create modules with the correct environment" do
           FileUtils.mkdir_p(File.join(@first, 'foo'))
           env.modules.each {|mod| mod.environment.should == env }
         end
 
       end
     end
 
     it "should cache the module list" do
       env.modulepath = %w{/a}
       Dir.expects(:entries).once.with("/a").returns %w{foo}
 
       env.modules
       env.modules
     end
   end
 
   describe Puppet::Node::Environment::Helper do
     before do
       @helper = Object.new
       @helper.extend(Puppet::Node::Environment::Helper)
     end
 
     it "should be able to set and retrieve the environment as a symbol" do
       @helper.environment = :foo
       @helper.environment.name.should == :foo
     end
 
     it "should accept an environment directly" do
       @helper.environment = Puppet::Node::Environment.new(:foo)
       @helper.environment.name.should == :foo
     end
 
     it "should accept an environment as a string" do
       @helper.environment = 'foo'
       @helper.environment.name.should == :foo
     end
   end
 
   describe "when performing initial import" do
     before do
       @parser = Puppet::Parser::Parser.new("test")
       Puppet::Parser::Parser.stubs(:new).returns @parser
     end
 
     it "should set the parser's string to the 'code' setting and parse if code is available" do
       Puppet.settings[:code] = "my code"
       @parser.expects(:string=).with "my code"
       @parser.expects(:parse)
       env.instance_eval { perform_initial_import }
     end
 
     it "should set the parser's file to the 'manifest' setting and parse if no code is available and the manifest is available" do
       filename = tmpfile('myfile')
       File.open(filename, 'w'){|f| }
       Puppet.settings[:manifest] = filename
       @parser.expects(:file=).with filename
       @parser.expects(:parse)
       env.instance_eval { perform_initial_import }
     end
 
     it "should pass the manifest file to the parser even if it does not exist on disk" do
       filename = tmpfile('myfile')
       Puppet.settings[:code] = ""
       Puppet.settings[:manifest] = filename
       @parser.expects(:file=).with(filename).once
       @parser.expects(:parse).once
       env.instance_eval { perform_initial_import }
     end
 
     it "should fail helpfully if there is an error importing" do
       File.stubs(:exist?).returns true
       env.stubs(:known_resource_types).returns Puppet::Resource::TypeCollection.new(env)
       @parser.expects(:file=).once
       @parser.expects(:parse).raises ArgumentError
       lambda { env.instance_eval { perform_initial_import } }.should raise_error(Puppet::Error)
     end
 
     it "should not do anything if the ignore_import settings is set" do
       Puppet.settings[:ignoreimport] = true
       @parser.expects(:string=).never
       @parser.expects(:file=).never
       @parser.expects(:parse).never
       env.instance_eval { perform_initial_import }
     end
 
     it "should mark the type collection as needing a reparse when there is an error parsing" do
       @parser.expects(:parse).raises Puppet::ParseError.new("Syntax error at ...")
       env.stubs(:known_resource_types).returns Puppet::Resource::TypeCollection.new(env)
 
       lambda { env.instance_eval { perform_initial_import } }.should raise_error(Puppet::Error, /Syntax error at .../)
       env.known_resource_types.require_reparse?.should be_true
     end
   end
 end
diff --git a/spec/unit/parser/lexer_spec.rb b/spec/unit/parser/lexer_spec.rb
index f1a49111f..d1a2938ba 100755
--- a/spec/unit/parser/lexer_spec.rb
+++ b/spec/unit/parser/lexer_spec.rb
@@ -1,700 +1,743 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/parser/lexer'
 
 # This is a special matcher to match easily lexer output
 RSpec::Matchers.define :be_like do |*expected|
   match do |actual|
     expected.zip(actual).all? { |e,a| !e or a[0] == e or (e.is_a? Array and a[0] == e[0] and (a[1] == e[1] or (a[1].is_a?(Hash) and a[1][:value] == e[1]))) }
   end
 end
 __ = nil
 
 describe Puppet::Parser::Lexer do
   describe "when reading strings" do
     before { @lexer = Puppet::Parser::Lexer.new }
     it "should increment the line count for every carriage return in the string" do
       @lexer.line = 10
       @lexer.string = "this\nis\natest'"
       @lexer.slurpstring("'")
 
       @lexer.line.should == 12
     end
 
     it "should not increment the line count for escapes in the string" do
       @lexer.line = 10
       @lexer.string = "this\\nis\\natest'"
       @lexer.slurpstring("'")
 
       @lexer.line.should == 10
     end
 
     it "should not think the terminator is escaped, when preceeded by an even number of backslashes" do
       @lexer.line = 10
       @lexer.string = "here\nis\nthe\nstring\\\\'with\nextra\njunk"
       @lexer.slurpstring("'")
 
       @lexer.line.should == 13
     end
   end
 end
 
 describe Puppet::Parser::Lexer::Token do
   before do
     @token = Puppet::Parser::Lexer::Token.new(%r{something}, :NAME)
   end
 
   [:regex, :name, :string, :skip, :incr_line, :skip_text, :accumulate].each do |param|
     it "should have a #{param.to_s} reader" do
       @token.should be_respond_to(param)
     end
 
     it "should have a #{param.to_s} writer" do
       @token.should be_respond_to(param.to_s + "=")
     end
   end
 end
 
 describe Puppet::Parser::Lexer::Token, "when initializing" do
   it "should create a regex if the first argument is a string" do
     Puppet::Parser::Lexer::Token.new("something", :NAME).regex.should == %r{something}
   end
 
   it "should set the string if the first argument is one" do
     Puppet::Parser::Lexer::Token.new("something", :NAME).string.should == "something"
   end
 
   it "should set the regex if the first argument is one" do
     Puppet::Parser::Lexer::Token.new(%r{something}, :NAME).regex.should == %r{something}
   end
 end
 
 describe Puppet::Parser::Lexer::TokenList do
   before do
     @list = Puppet::Parser::Lexer::TokenList.new
   end
 
   it "should have a method for retrieving tokens by the name" do
     token = @list.add_token :name, "whatever"
     @list[:name].should equal(token)
   end
 
   it "should have a method for retrieving string tokens by the string" do
     token = @list.add_token :name, "whatever"
     @list.lookup("whatever").should equal(token)
   end
 
   it "should add tokens to the list when directed" do
     token = @list.add_token :name, "whatever"
     @list[:name].should equal(token)
   end
 
   it "should have a method for adding multiple tokens at once" do
     @list.add_tokens "whatever" => :name, "foo" => :bar
     @list[:name].should_not be_nil
     @list[:bar].should_not be_nil
   end
 
   it "should fail to add tokens sharing a name with an existing token" do
     @list.add_token :name, "whatever"
     lambda { @list.add_token :name, "whatever" }.should raise_error(ArgumentError)
   end
 
   it "should set provided options on tokens being added" do
     token = @list.add_token :name, "whatever", :skip_text => true
     token.skip_text.should == true
   end
 
   it "should define any provided blocks as a :convert method" do
     token = @list.add_token(:name, "whatever")  do "foo" end
     token.convert.should == "foo"
   end
 
   it "should store all string tokens in the :string_tokens list" do
     one = @list.add_token(:name, "1")
     @list.string_tokens.should be_include(one)
   end
 
   it "should store all regex tokens in the :regex_tokens list" do
     one = @list.add_token(:name, %r{one})
     @list.regex_tokens.should be_include(one)
   end
 
   it "should not store string tokens in the :regex_tokens list" do
     one = @list.add_token(:name, "1")
     @list.regex_tokens.should_not be_include(one)
   end
 
   it "should not store regex tokens in the :string_tokens list" do
     one = @list.add_token(:name, %r{one})
     @list.string_tokens.should_not be_include(one)
   end
 
   it "should sort the string tokens inversely by length when asked" do
     one = @list.add_token(:name, "1")
     two = @list.add_token(:other, "12")
     @list.sort_tokens
     @list.string_tokens.should == [two, one]
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS do
   before do
     @lexer = Puppet::Parser::Lexer.new
   end
 
   {
     :LBRACK => '[',
     :RBRACK => ']',
     :LBRACE => '{',
     :RBRACE => '}',
     :LPAREN => '(',
     :RPAREN => ')',
     :EQUALS => '=',
     :ISEQUAL => '==',
     :GREATEREQUAL => '>=',
     :GREATERTHAN => '>',
     :LESSTHAN => '<',
     :LESSEQUAL => '<=',
     :NOTEQUAL => '!=',
     :NOT => '!',
     :COMMA => ',',
     :DOT => '.',
     :COLON => ':',
     :AT => '@',
     :LLCOLLECT => '<<|',
     :RRCOLLECT => '|>>',
     :LCOLLECT => '<|',
     :RCOLLECT => '|>',
     :SEMIC => ';',
     :QMARK => '?',
     :BACKSLASH => '\\',
     :FARROW => '=>',
     :PARROW => '+>',
     :APPENDS => '+=',
     :PLUS => '+',
     :MINUS => '-',
     :DIV => '/',
     :TIMES => '*',
     :LSHIFT => '<<',
     :RSHIFT => '>>',
     :MATCH => '=~',
     :NOMATCH => '!~',
     :IN_EDGE => '->',
     :OUT_EDGE => '<-',
     :IN_EDGE_SUB => '~>',
     :OUT_EDGE_SUB => '<~',
   }.each do |name, string|
     it "should have a token named #{name.to_s}" do
       Puppet::Parser::Lexer::TOKENS[name].should_not be_nil
     end
 
     it "should match '#{string}' for the token #{name.to_s}" do
       Puppet::Parser::Lexer::TOKENS[name].string.should == string
     end
   end
 
   {
     "case" => :CASE,
     "class" => :CLASS,
     "default" => :DEFAULT,
     "define" => :DEFINE,
     "import" => :IMPORT,
     "if" => :IF,
     "elsif" => :ELSIF,
     "else" => :ELSE,
     "inherits" => :INHERITS,
     "node" => :NODE,
     "and"  => :AND,
     "or"   => :OR,
     "undef"   => :UNDEF,
     "false" => :FALSE,
     "true" => :TRUE,
     "in" => :IN,
     "unless" => :UNLESS,
   }.each do |string, name|
     it "should have a keyword named #{name.to_s}" do
       Puppet::Parser::Lexer::KEYWORDS[name].should_not be_nil
     end
 
     it "should have the keyword for #{name.to_s} set to #{string}" do
       Puppet::Parser::Lexer::KEYWORDS[name].string.should == string
     end
   end
 
   # These tokens' strings don't matter, just that the tokens exist.
   [:STRING, :DQPRE, :DQMID, :DQPOST, :BOOLEAN, :NAME, :NUMBER, :COMMENT, :MLCOMMENT, :RETURN, :SQUOTE, :DQUOTE, :VARIABLE].each do |name|
     it "should have a token named #{name.to_s}" do
       Puppet::Parser::Lexer::TOKENS[name].should_not be_nil
     end
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:CLASSREF] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:CLASSREF] }
 
   it "should match against single upper-case alpha-numeric terms" do
     @token.regex.should =~ "One"
   end
 
   it "should match against upper-case alpha-numeric terms separated by double colons" do
     @token.regex.should =~ "One::Two"
   end
 
   it "should match against many upper-case alpha-numeric terms separated by double colons" do
     @token.regex.should =~ "One::Two::Three::Four::Five"
   end
 
   it "should match against upper-case alpha-numeric terms prefixed by double colons" do
     @token.regex.should =~ "::One"
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:NAME] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:NAME] }
 
   it "should match against lower-case alpha-numeric terms" do
     @token.regex.should =~ "one-two"
   end
 
   it "should return itself and the value if the matched term is not a keyword" do
     Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(nil)
     @token.convert(stub("lexer"), "myval").should == [Puppet::Parser::Lexer::TOKENS[:NAME], "myval"]
   end
 
   it "should return the keyword token and the value if the matched term is a keyword" do
     keyword = stub 'keyword', :name => :testing
     Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(keyword)
     @token.convert(stub("lexer"), "myval").should == [keyword, "myval"]
   end
 
   it "should return the BOOLEAN token and 'true' if the matched term is the string 'true'" do
     keyword = stub 'keyword', :name => :TRUE
     Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(keyword)
     @token.convert(stub('lexer'), "true").should == [Puppet::Parser::Lexer::TOKENS[:BOOLEAN], true]
   end
 
   it "should return the BOOLEAN token and 'false' if the matched term is the string 'false'" do
     keyword = stub 'keyword', :name => :FALSE
     Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(keyword)
     @token.convert(stub('lexer'), "false").should == [Puppet::Parser::Lexer::TOKENS[:BOOLEAN], false]
   end
 
   it "should match against lower-case alpha-numeric terms separated by double colons" do
     @token.regex.should =~ "one::two"
   end
 
   it "should match against many lower-case alpha-numeric terms separated by double colons" do
     @token.regex.should =~ "one::two::three::four::five"
   end
 
   it "should match against lower-case alpha-numeric terms prefixed by double colons" do
     @token.regex.should =~ "::one"
   end
 
   it "should match against nested terms starting with numbers" do
     @token.regex.should =~ "::1one::2two::3three"
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:NUMBER] do
   before do
     @token = Puppet::Parser::Lexer::TOKENS[:NUMBER]
     @regex = @token.regex
   end
 
   it "should match against numeric terms" do
     @regex.should =~ "2982383139"
   end
 
   it "should match against float terms" do
     @regex.should =~ "29823.235"
   end
 
   it "should match against hexadecimal terms" do
     @regex.should =~ "0xBEEF0023"
   end
 
   it "should match against float with exponent terms" do
     @regex.should =~ "10e23"
   end
 
   it "should match against float terms with negative exponents" do
     @regex.should =~ "10e-23"
   end
 
   it "should match against float terms with fractional parts and exponent" do
     @regex.should =~ "1.234e23"
   end
 
   it "should return the NAME token and the value" do
     @token.convert(stub("lexer"), "myval").should == [Puppet::Parser::Lexer::TOKENS[:NAME], "myval"]
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:COMMENT] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:COMMENT] }
 
   it "should match against lines starting with '#'" do
     @token.regex.should =~ "# this is a comment"
   end
 
   it "should be marked to get skipped" do
     @token.skip?.should be_true
   end
 
   it "should be marked to accumulate" do
     @token.accumulate?.should be_true
   end
 
   it "'s block should return the comment without the #" do
     @token.convert(@lexer,"# this is a comment")[1].should == "this is a comment"
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:MLCOMMENT] do
   before do
     @token = Puppet::Parser::Lexer::TOKENS[:MLCOMMENT]
     @lexer = stub 'lexer', :line => 0
   end
 
   it "should match against lines enclosed with '/*' and '*/'" do
     @token.regex.should =~ "/* this is a comment */"
   end
 
   it "should match multiple lines enclosed with '/*' and '*/'" do
     @token.regex.should =~ """/*
       this is a comment
       */"""
   end
 
   it "should increase the lexer current line number by the amount of lines spanned by the comment" do
     @lexer.expects(:line=).with(2)
     @token.convert(@lexer, "1\n2\n3")
   end
 
   it "should not greedily match comments" do
     match = @token.regex.match("/* first */ word /* second */")
     match[1].should == " first "
   end
 
   it "should be marked to accumulate" do
     @token.accumulate?.should be_true
   end
 
   it "'s block should return the comment without the comment marks" do
     @lexer.stubs(:line=).with(0)
 
     @token.convert(@lexer,"/* this is a comment */")[1].should == "this is a comment"
   end
 
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:RETURN] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:RETURN] }
 
   it "should match against carriage returns" do
     @token.regex.should =~ "\n"
   end
 
   it "should be marked to initiate text skipping" do
     @token.skip_text.should be_true
   end
 
   it "should be marked to increment the line" do
     @token.incr_line.should be_true
   end
 end
 
+shared_examples_for "variable names in the lexer" do |prefix|
+  # Watch out - a regex might match a *prefix* on these, not just the whole
+  # word, so make sure you don't have false positive or negative results based
+  # on that.
+  legal   = %w{f foo f::b foo::b f::bar foo::bar 3 foo3 3foo}
+  illegal = %w{f- f-o -f f::-o f::o- f::o-o}
+
+  ["", "::"].each do |global_scope|
+    legal.each do |name|
+      var = prefix + global_scope + name
+      it "should accept #{var.inspect} as a valid variable name" do
+        (subject.regex.match(var) || [])[0].should == var
+      end
+    end
+
+    illegal.each do |name|
+      var = prefix + global_scope + name
+      it "should NOT accept #{var.inspect} as a valid variable name" do
+        (subject.regex.match(var) || [])[0].should_not == var
+      end
+    end
+  end
+end
+
+describe Puppet::Parser::Lexer::TOKENS[:DOLLAR_VAR] do
+  its(:skip_text) { should be_false }
+  its(:incr_line) { should be_false }
+
+  it_should_behave_like "variable names in the lexer", '$'
+end
+
+describe Puppet::Parser::Lexer::TOKENS[:VARIABLE] do
+  its(:skip_text) { should be_false }
+  its(:incr_line) { should be_false }
+
+  it_should_behave_like "variable names in the lexer", ''
+end
+
 def tokens_scanned_from(s)
   lexer = Puppet::Parser::Lexer.new
   lexer.string = s
   lexer.fullscan[0..-2]
 end
 
 describe Puppet::Parser::Lexer,"when lexing strings" do
   {
     %q{'single quoted string')}                                     => [[:STRING,'single quoted string']],
     %q{"double quoted string"}                                      => [[:STRING,'double quoted string']],
     %q{'single quoted string with an escaped "\\'"'}                => [[:STRING,'single quoted string with an escaped "\'"']],
     %q{'single quoted string with an escaped "\$"'}                 => [[:STRING,'single quoted string with an escaped "\$"']],
     %q{'single quoted string with an escaped "\."'}                 => [[:STRING,'single quoted string with an escaped "\."']],
     %q{'single quoted string with an escaped "\n"'}                 => [[:STRING,'single quoted string with an escaped "\n"']],
     %q{'single quoted string with an escaped "\\\\"'}               => [[:STRING,'single quoted string with an escaped "\\\\"']],
     %q{"string with an escaped '\\"'"}                              => [[:STRING,"string with an escaped '\"'"]],
     %q{"string with an escaped '\\$'"}                              => [[:STRING,"string with an escaped '$'"]],
     %Q{"string with a line ending with a backslash: \\\nfoo"}       => [[:STRING,"string with a line ending with a backslash: foo"]],
     %q{"string with $v (but no braces)"}                            => [[:DQPRE,"string with "],[:VARIABLE,'v'],[:DQPOST,' (but no braces)']],
     %q["string with ${v} in braces"]                                => [[:DQPRE,"string with "],[:VARIABLE,'v'],[:DQPOST,' in braces']],
     %q["string with ${qualified::var} in braces"]                   => [[:DQPRE,"string with "],[:VARIABLE,'qualified::var'],[:DQPOST,' in braces']],
     %q{"string with $v and $v (but no braces)"}                     => [[:DQPRE,"string with "],[:VARIABLE,"v"],[:DQMID," and "],[:VARIABLE,"v"],[:DQPOST," (but no braces)"]],
     %q["string with ${v} and ${v} in braces"]                       => [[:DQPRE,"string with "],[:VARIABLE,"v"],[:DQMID," and "],[:VARIABLE,"v"],[:DQPOST," in braces"]],
     %q["string with ${'a nested single quoted string'} inside it."] => [[:DQPRE,"string with "],[:STRING,'a nested single quoted string'],[:DQPOST,' inside it.']],
     %q["string with ${['an array ',$v2]} in it."]                   => [[:DQPRE,"string with "],:LBRACK,[:STRING,"an array "],:COMMA,[:VARIABLE,"v2"],:RBRACK,[:DQPOST," in it."]],
     %q{a simple "scanner" test}                                     => [[:NAME,"a"],[:NAME,"simple"], [:STRING,"scanner"],[:NAME,"test"]],
     %q{a simple 'single quote scanner' test}                        => [[:NAME,"a"],[:NAME,"simple"], [:STRING,"single quote scanner"],[:NAME,"test"]],
     %q{a harder 'a $b \c"'}                                         => [[:NAME,"a"],[:NAME,"harder"], [:STRING,'a $b \c"']],
     %q{a harder "scanner test"}                                     => [[:NAME,"a"],[:NAME,"harder"], [:STRING,"scanner test"]],
     %q{a hardest "scanner \"test\""}                                => [[:NAME,"a"],[:NAME,"hardest"],[:STRING,'scanner "test"']],
     %Q{a hardestest "scanner \\"test\\"\n"}                         => [[:NAME,"a"],[:NAME,"hardestest"],[:STRING,%Q{scanner "test"\n}]],
     %q{function("call")}                                            => [[:NAME,"function"],[:LPAREN,"("],[:STRING,'call'],[:RPAREN,")"]],
     %q["string with ${(3+5)/4} nested math."]                       => [[:DQPRE,"string with "],:LPAREN,[:NAME,"3"],:PLUS,[:NAME,"5"],:RPAREN,:DIV,[:NAME,"4"],[:DQPOST," nested math."]],
     %q["$$$$"]                                                      => [[:STRING,"$$$$"]],
     %q["$variable"]                                                 => [[:DQPRE,""],[:VARIABLE,"variable"],[:DQPOST,""]],
     %q["$var$other"]                                                => [[:DQPRE,""],[:VARIABLE,"var"],[:DQMID,""],[:VARIABLE,"other"],[:DQPOST,""]],
     %q["foo$bar$"]                                                  => [[:DQPRE,"foo"],[:VARIABLE,"bar"],[:DQPOST,"$"]],
     %q["foo$$bar"]                                                  => [[:DQPRE,"foo$"],[:VARIABLE,"bar"],[:DQPOST,""]],
     %q[""]                                                          => [[:STRING,""]],
     %q["123 456 789 0"]                                             => [[:STRING,"123 456 789 0"]],
     %q["${123} 456 $0"]                                             => [[:DQPRE,""],[:VARIABLE,"123"],[:DQMID," 456 "],[:VARIABLE,"0"],[:DQPOST,""]],
     %q["$foo::::bar"]                                               => [[:DQPRE,""],[:VARIABLE,"foo"],[:DQPOST,"::::bar"]]
   }.each { |src,expected_result|
     it "should handle #{src} correctly" do
       tokens_scanned_from(src).should be_like(*expected_result)
     end
   }
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:DOLLAR_VAR] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:DOLLAR_VAR] }
 
   it "should match against alpha words prefixed with '$'" do
     @token.regex.should =~ '$this_var'
   end
 
   it "should return the VARIABLE token and the variable name stripped of the '$'" do
     @token.convert(stub("lexer"), "$myval").should == [Puppet::Parser::Lexer::TOKENS[:VARIABLE], "myval"]
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:REGEX] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:REGEX] }
 
   it "should match against any expression enclosed in //" do
     @token.regex.should =~ '/this is a regex/'
   end
 
   it 'should not match if there is \n in the regex' do
     @token.regex.should_not =~ "/this is \n a regex/"
   end
 
   describe "when scanning" do
     it "should not consider escaped slashes to be the end of a regex" do
       tokens_scanned_from("$x =~ /this \\/ foo/").should be_like(__,__,[:REGEX,%r{this / foo}])
     end
 
     it "should not lex chained division as a regex" do
       tokens_scanned_from("$x = $a/$b/$c").collect { |name, data| name }.should_not be_include( :REGEX )
     end
 
     it "should accept a regular expression after NODE" do
       tokens_scanned_from("node /www.*\.mysite\.org/").should be_like(__,[:REGEX,Regexp.new("www.*\.mysite\.org")])
     end
 
     it "should accept regular expressions in a CASE" do
       s = %q{case $variable {
         "something": {$othervar = 4096 / 2}
         /regex/: {notice("this notably sucks")}
         }
       }
       tokens_scanned_from(s).should be_like(
         :CASE,:VARIABLE,:LBRACE,:STRING,:COLON,:LBRACE,:VARIABLE,:EQUALS,:NAME,:DIV,:NAME,:RBRACE,[:REGEX,/regex/],:COLON,:LBRACE,:NAME,:LPAREN,:STRING,:RPAREN,:RBRACE,:RBRACE
       )
     end
 
   end
 
 
   it "should return the REGEX token and a Regexp" do
     @token.convert(stub("lexer"), "/myregex/").should == [Puppet::Parser::Lexer::TOKENS[:REGEX], Regexp.new(/myregex/)]
   end
 end
 
 describe Puppet::Parser::Lexer, "when lexing comments" do
   before { @lexer = Puppet::Parser::Lexer.new }
 
   it "should accumulate token in munge_token" do
     token = stub 'token', :skip => true, :accumulate? => true, :incr_line => nil, :skip_text => false
 
     token.stubs(:convert).with(@lexer, "# this is a comment").returns([token, " this is a comment"])
     @lexer.munge_token(token, "# this is a comment")
     @lexer.munge_token(token, "# this is a comment")
 
     @lexer.getcomment.should == " this is a comment\n this is a comment\n"
   end
 
   it "should add a new comment stack level on LBRACE" do
     @lexer.string = "{"
 
     @lexer.expects(:commentpush)
 
     @lexer.fullscan
   end
 
   it "should add a new comment stack level on LPAREN" do
     @lexer.string = "("
 
     @lexer.expects(:commentpush)
 
     @lexer.fullscan
   end
 
   it "should pop the current comment on RPAREN" do
     @lexer.string = ")"
 
     @lexer.expects(:commentpop)
 
     @lexer.fullscan
   end
 
   it "should return the current comments on getcomment" do
     @lexer.string = "# comment"
     @lexer.fullscan
 
     @lexer.getcomment.should == "comment\n"
   end
 
   it "should discard the previous comments on blank line" do
     @lexer.string = "# 1\n\n# 2"
     @lexer.fullscan
 
     @lexer.getcomment.should == "2\n"
   end
 
   it "should skip whitespace before lexing the next token after a non-token" do
     tokens_scanned_from("/* 1\n\n */ \ntest").should be_like([:NAME, "test"])
   end
 
   it "should not return comments seen after the current line" do
     @lexer.string = "# 1\n\n# 2"
     @lexer.fullscan
 
     @lexer.getcomment(1).should == ""
   end
 
   it "should return a comment seen before the current line" do
     @lexer.string = "# 1\n# 2"
     @lexer.fullscan
 
     @lexer.getcomment(2).should == "1\n2\n"
   end
 end
 
 # FIXME: We need to rewrite all of these tests, but I just don't want to take the time right now.
 describe "Puppet::Parser::Lexer in the old tests" do
   before { @lexer = Puppet::Parser::Lexer.new }
 
   it "should do simple lexing" do
     {
       %q{\\}                      => [[:BACKSLASH,"\\"]],
       %q{simplest scanner test}   => [[:NAME,"simplest"],[:NAME,"scanner"],[:NAME,"test"]],
       %Q{returned scanner test\n} => [[:NAME,"returned"],[:NAME,"scanner"],[:NAME,"test"]]
     }.each { |source,expected|
       tokens_scanned_from(source).should be_like(*expected)
     }
   end
 
   it "should fail usefully" do
     lambda { tokens_scanned_from('^') }.should raise_error(RuntimeError)
   end
 
   it "should fail if the string is not set" do
     lambda { @lexer.fullscan }.should raise_error(Puppet::LexError)
   end
 
   it "should correctly identify keywords" do
     tokens_scanned_from("case").should be_like([:CASE, "case"])
   end
 
   it "should correctly parse class references" do
     %w{Many Different Words A Word}.each { |t| tokens_scanned_from(t).should be_like([:CLASSREF,t])}
   end
 
   # #774
   it "should correctly parse namespaced class refernces token" do
     %w{Foo ::Foo Foo::Bar ::Foo::Bar}.each { |t| tokens_scanned_from(t).should be_like([:CLASSREF, t]) }
   end
 
   it "should correctly parse names" do
     %w{this is a bunch of names}.each { |t| tokens_scanned_from(t).should be_like([:NAME,t]) }
   end
 
   it "should correctly parse names with numerals" do
     %w{1name name1 11names names11}.each { |t| tokens_scanned_from(t).should be_like([:NAME,t]) }
   end
 
   it "should correctly parse empty strings" do
     lambda { tokens_scanned_from('$var = ""') }.should_not raise_error
   end
 
   it "should correctly parse virtual resources" do
     tokens_scanned_from("@type {").should be_like([:AT, "@"], [:NAME, "type"], [:LBRACE, "{"])
   end
 
   it "should correctly deal with namespaces" do
     @lexer.string = %{class myclass}
     @lexer.fullscan
     @lexer.namespace.should == "myclass"
 
     @lexer.namepop
     @lexer.namespace.should == ""
 
     @lexer.string = "class base { class sub { class more"
     @lexer.fullscan
     @lexer.namespace.should == "base::sub::more"
 
     @lexer.namepop
     @lexer.namespace.should == "base::sub"
   end
 
   it "should not put class instantiation on the namespace" do
     @lexer.string = "class base { class sub { class { mode"
     @lexer.fullscan
     @lexer.namespace.should == "base::sub"
   end
 
   it "should correctly handle fully qualified names" do
     @lexer.string = "class base { class sub::more {"
     @lexer.fullscan
     @lexer.namespace.should == "base::sub::more"
 
     @lexer.namepop
     @lexer.namespace.should == "base"
   end
 
   it "should correctly lex variables" do
-    ["$variable", "$::variable", "$qualified::variable", "$further::qualified::variable", "$hyphenated-variable", "$-variable-with-leading-dash"].each do |string|
+    ["$variable", "$::variable", "$qualified::variable", "$further::qualified::variable"].each do |string|
       tokens_scanned_from(string).should be_like([:VARIABLE,string.sub(/^\$/,'')])
     end
   end
 
+  it "should end variables at `-`" do
+    tokens_scanned_from('$hyphenated-variable').
+      should be_like [:VARIABLE, "hyphenated"], [:MINUS, '-'], [:NAME, 'variable']
+  end
+
   it "should not include whitespace in a variable" do
     tokens_scanned_from("$foo bar").should_not be_like([:VARIABLE, "foo bar"])
   end
   it "should not include excess colons in a variable" do
     tokens_scanned_from("$foo::::bar").should_not be_like([:VARIABLE, "foo::::bar"])
   end
 end
 
 describe "Puppet::Parser::Lexer in the old tests when lexing example files" do
   my_fixtures('*.pp') do |file|
     it "should correctly lex #{file}" do
       lexer = Puppet::Parser::Lexer.new
       lexer.file = file
-      lambda { lexer.fullscan }.should_not raise_error
+      expect { lexer.fullscan }.should_not raise_error
     end
   end
 end
 
 describe "when trying to lex an non-existent file" do
   include PuppetSpec::Files
 
   it "should return an empty list of tokens" do
     lexer = Puppet::Parser::Lexer.new
     lexer.file = nofile = tmpfile('lexer')
     File.exists?(nofile).should == false
 
     lexer.fullscan.should == [[false,false]]
   end
 end
diff --git a/tasks/rake/manpages.rake b/tasks/rake/manpages.rake
index 3fb48da73..460521cc5 100644
--- a/tasks/rake/manpages.rake
+++ b/tasks/rake/manpages.rake
@@ -1,69 +1,77 @@
 # require 'fileutils'
 
 desc "Build Puppet manpages"
 task :gen_manpages do
   require 'puppet/face'
   require 'fileutils'
 
   helpface = Puppet::Face[:help, '0.0.1']
   manface  = Puppet::Face[:man, '0.0.1']
+
+  # TODO: This line is terrible.  The reason we need this here is because we
+  #  handle state initialization differently when we run via command line
+  #  (application.rb) than we do when we try to use Faces as library code.
+  #  This is bad, we need to come up with an official stance on what our
+  #  API is and what the entry points, so that we can make sure that
+  #  state initialization is consistent.  See:
+  # http://projects.puppetlabs.com/issues/14441
+  Puppet::Util::Instrumentation.init()
+
   sbins = Dir.glob(%w{sbin/*})
   bins  = Dir.glob(%w{bin/*})
   non_face_applications = helpface.legacy_applications
   faces = Puppet::Face.faces
   ronn_args = '--manual="Puppet manual" --organization="Puppet Labs, LLC" -r'
 
   # Locate ronn
   ronn = %x{which ronn}.chomp
   unless File.executable?(ronn) then fail("Ronn does not appear to be installed.") end
 
 #   def write_manpage(text, filename)
 #     IO.popen("#{ronn} #{ronn_args} -r > #{filename}") do |fh| fh.write text end
 #   end
 
   # Create puppet.conf.5 man page
 #   IO.popen("#{ronn} #{ronn_args} > ./man/man5/puppet.conf.5", 'w') do |fh|
 #     fh.write %x{RUBYLIB=./lib:$RUBYLIB bin/puppetdoc --reference configuration}
 #   end
   %x{RUBYLIB=./lib:$RUBYLIB bin/puppetdoc --reference configuration > ./man/man5/puppetconf.5.ronn}
   %x{#{ronn} #{ronn_args} ./man/man5/puppetconf.5.ronn}
   FileUtils.mv("./man/man5/puppetconf.5", "./man/man5/puppet.conf.5")
   FileUtils.rm("./man/man5/puppetconf.5.ronn")
 
   # Create LEGACY binary man pages (i.e. delete me for 2.8.0)
   binary = bins + sbins
   binary.each do |bin|
     b = bin.gsub( /^s?bin\//, "")
     %x{RUBYLIB=./lib:$RUBYLIB #{bin} --help > ./man/man8/#{b}.8.ronn}
     %x{#{ronn} #{ronn_args} ./man/man8/#{b}.8.ronn}
     FileUtils.rm("./man/man8/#{b}.8.ronn")
   end
 
   # Create regular non-face man pages
   non_face_applications.each do |app|
     %x{RUBYLIB=./lib:$RUBYLIB bin/puppet #{app} --help > ./man/man8/puppet-#{app}.8.ronn}
     %x{#{ronn} #{ronn_args} ./man/man8/puppet-#{app}.8.ronn}
     FileUtils.rm("./man/man8/puppet-#{app}.8.ronn")
   end
 
   # Create face man pages
   faces.each do |face|
     File.open("./man/man8/puppet-#{face}.8.ronn", 'w') do |fh|
-      # For some reason no one understands at the moment, it duplicates termini,
-      # so we have to remove the dupes with a gsub.
-      fh.write manface.man("#{face}", {:render_as => :s}).gsub(/^(\* `[^`]+`)\n\1/, '\1')
+      fh.write manface.man("#{face}")
     end
 
     %x{#{ronn} #{ronn_args} ./man/man8/puppet-#{face}.8.ronn}
     FileUtils.rm("./man/man8/puppet-#{face}.8.ronn")
   end
 
   # Vile hack: create puppet resource man page
   # Currently, the useless resource face wins against puppet resource in puppet
   # man. (And actually, it even gets removed from the list of legacy
   # applications.) So we overwrite it with the correct man page at the end.
   %x{RUBYLIB=./lib:$RUBYLIB bin/puppet resource --help > ./man/man8/puppet-resource.8.ronn}
   %x{#{ronn} #{ronn_args} ./man/man8/puppet-resource.8.ronn}
   FileUtils.rm("./man/man8/puppet-resource.8.ronn")
 
 end