puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/util/checksums.rb

@@ -0,0 +1,143 @@
+require 'digest/md5'
+require 'digest/sha1'
+
+# A stand-alone module for calculating checksums
+# in a generic way.
+module Puppet::Util::Checksums
+  class FakeChecksum
+    def <<(*args)
+      self
+    end
+  end
+
+  # Is the provided string a checksum?
+  def checksum?(string)
+    string =~ /^\{(\w{3,5})\}\S+/
+  end
+
+  # Strip the checksum type from an existing checksum
+  def sumdata(checksum)
+    checksum =~ /^\{(\w+)\}(.+)/ ? $2 : nil
+  end
+
+  # Strip the checksum type from an existing checksum
+  def sumtype(checksum)
+    checksum =~ /^\{(\w+)\}/ ? $1 : nil
+  end
+
+  # Calculate a checksum using Digest::MD5.
+  def md5(content)
+    Digest::MD5.hexdigest(content)
+  end
+
+  # Calculate a checksum of the first 500 chars of the content using Digest::MD5.
+  def md5lite(content)
+    md5(content[0..511])
+  end
+
+  # Calculate a checksum of a file's content using Digest::MD5.
+  def md5_file(filename, lite = false)
+    digest = Digest::MD5.new
+    checksum_file(digest, filename,  lite)
+  end
+
+  # Calculate a checksum of the first 500 chars of a file's content using Digest::MD5.
+  def md5lite_file(filename)
+    md5_file(filename, true)
+  end
+
+  def md5_stream(&block)
+    digest = Digest::MD5.new
+    yield digest
+    digest.hexdigest
+  end
+
+  alias :md5lite_stream :md5_stream
+
+  # Return the :mtime timestamp of a file.
+  def mtime_file(filename)
+    File.stat(filename).send(:mtime)
+  end
+
+  # by definition this doesn't exist
+  # but we still need to execute the block given
+  def mtime_stream
+    noop_digest = FakeChecksum.new
+    yield noop_digest
+    nil
+  end
+
+  def mtime(content)
+    ""
+  end
+
+  # Calculate a checksum using Digest::SHA1.
+  def sha1(content)
+    Digest::SHA1.hexdigest(content)
+  end
+
+  # Calculate a checksum of the first 500 chars of the content using Digest::SHA1.
+  def sha1lite(content)
+    sha1(content[0..511])
+  end
+
+  # Calculate a checksum of a file's content using Digest::SHA1.
+  def sha1_file(filename, lite = false)
+    digest = Digest::SHA1.new
+    checksum_file(digest, filename, lite)
+  end
+
+  # Calculate a checksum of the first 500 chars of a file's content using Digest::SHA1.
+  def sha1lite_file(filename)
+    sha1_file(filename, true)
+  end
+
+  def sha1_stream
+    digest = Digest::SHA1.new
+    yield digest
+    digest.hexdigest
+  end
+
+  alias :sha1lite_stream :sha1_stream
+
+  # Return the :ctime of a file.
+  def ctime_file(filename)
+    File.stat(filename).send(:ctime)
+  end
+
+  alias :ctime_stream :mtime_stream
+
+  def ctime(content)
+    ""
+  end
+
+  # Return a "no checksum"
+  def none_file(filename)
+    ""
+  end
+
+  def none_stream
+    noop_digest = FakeChecksum.new
+    yield noop_digest
+    ""
+  end
+
+  def none(content)
+    ""
+  end
+
+  private
+
+  # Perform an incremental checksum on a file.
+  def checksum_file(digest, filename, lite = false)
+    buffer = lite ? 512 : 4096
+    File.open(filename, 'rb') do |file|
+      while content = file.read(buffer)
+        digest << content
+        break if lite
+      end
+    end
+
+    digest.hexdigest
+  end
+end

data/lib/vendor/puppet/util/classgen.rb

@@ -0,0 +1,209 @@
+module Puppet
+  class ConstantAlreadyDefined < Error; end
+  class SubclassAlreadyDefined < Error; end
+end
+
+module Puppet::Util::ClassGen
+  include Puppet::Util::MethodHelper
+  include Puppet::Util
+
+  # Create a new subclass.  Valid options are:
+  # * <tt>:array</tt>: An array of existing classes.  If specified, the new
+  #   class is added to this array.
+  # * <tt>:attributes</tt>: A hash of attributes to set before the block is
+  #   evaluated.
+  # * <tt>:block</tt>: The block to evaluate in the context of the class.
+  #   You can also just pass the block normally, but it will still be evaluated
+  #   with <tt>class_eval</tt>.
+  # * <tt>:constant</tt>: What to set the constant as.  Defaults to the
+  #   capitalized name.
+  # * <tt>:hash</tt>: A hash of existing classes.  If specified, the new
+  #   class is added to this hash, and it is also used for overwrite tests.
+  # * <tt>:overwrite</tt>: Whether to overwrite an existing class.
+  # * <tt>:parent</tt>: The parent class for the generated class.  Defaults to
+  #   self.
+  # * <tt>:prefix</tt>: The constant prefix.  Default to nothing; if specified,
+  #   the capitalized name is appended and the result is set as the constant.
+  def genclass(name, options = {}, &block)
+    genthing(name, Class, options, block)
+  end
+
+  # Create a new module.  Valid options are:
+  # * <tt>:array</tt>: An array of existing classes.  If specified, the new
+  #   class is added to this array.
+  # * <tt>:attributes</tt>: A hash of attributes to set before the block is
+  #   evaluated.
+  # * <tt>:block</tt>: The block to evaluate in the context of the class.
+  #   You can also just pass the block normally, but it will still be evaluated
+  #   with <tt>class_eval</tt>.
+  # * <tt>:constant</tt>: What to set the constant as.  Defaults to the
+  #   capitalized name.
+  # * <tt>:hash</tt>: A hash of existing classes.  If specified, the new
+  #   class is added to this hash, and it is also used for overwrite tests.
+  # * <tt>:overwrite</tt>: Whether to overwrite an existing class.
+  # * <tt>:prefix</tt>: The constant prefix.  Default to nothing; if specified,
+  #   the capitalized name is appended and the result is set as the constant.
+  def genmodule(name, options = {}, &block)
+    genthing(name, Module, options, block)
+  end
+
+  # Remove an existing class
+  def rmclass(name, options)
+    options = symbolize_options(options)
+    const = genconst_string(name, options)
+    retval = false
+    if const_defined?(const)
+      remove_const(const)
+      retval = true
+    end
+
+    if hash = options[:hash] and hash.include? name
+      hash.delete(name)
+      retval = true
+    end
+
+    # Let them know whether we did actually delete a subclass.
+    retval
+  end
+
+  private
+
+  # Generate the constant to create or remove.
+  def genconst_string(name, options)
+    unless const = options[:constant]
+      prefix = options[:prefix] || ""
+      const = prefix + name2const(name)
+    end
+
+    const
+  end
+
+  # This does the actual work of creating our class or module.  It's just a
+  # slightly abstract version of genclass.
+  def genthing(name, type, options, block)
+    options = symbolize_options(options)
+
+    name = name.to_s.downcase.intern
+
+    if type == Module
+      #evalmethod = :module_eval
+      evalmethod = :class_eval
+      # Create the class, with the correct name.
+      klass = Module.new do
+        class << self
+          attr_reader :name
+        end
+        @name = name
+      end
+    else
+      options[:parent] ||= self
+      evalmethod = :class_eval
+      # Create the class, with the correct name.
+      klass = Class.new(options[:parent]) do
+        @name = name
+      end
+    end
+
+    # Create the constant as appropriation.
+    handleclassconst(klass, name, options)
+
+    # Initialize any necessary variables.
+    initclass(klass, options)
+
+    block ||= options[:block]
+
+    # Evaluate the passed block if there is one.  This should usually
+    # define all of the work.
+    klass.send(evalmethod, &block) if block
+
+    klass.postinit if klass.respond_to? :postinit
+
+    # Store the class in hashes or arrays or whatever.
+    storeclass(klass, name, options)
+
+    klass
+  end
+
+  # const_defined? in Ruby 1.9 behaves differently in terms
+  # of which class hierarchy it polls for nested namespaces
+  #
+  # See http://redmine.ruby-lang.org/issues/show/1915
+  def is_constant_defined?(const)
+    if ::RUBY_VERSION =~ /1.9/
+      const_defined?(const, false)
+    else
+      const_defined?(const)
+    end
+  end
+
+  # Handle the setting and/or removing of the associated constant.
+  def handleclassconst(klass, name, options)
+    const = genconst_string(name, options)
+
+    if is_constant_defined?(const)
+      if options[:overwrite]
+        Puppet.info "Redefining #{name} in #{self}"
+        remove_const(const)
+      else
+        raise Puppet::ConstantAlreadyDefined,
+          "Class #{const} is already defined in #{self}"
+      end
+    end
+    const_set(const, klass)
+
+    const
+  end
+
+  # Perform the initializations on the class.
+  def initclass(klass, options)
+    klass.initvars if klass.respond_to? :initvars
+
+    if attrs = options[:attributes]
+      attrs.each do |param, value|
+        method = param.to_s + "="
+        klass.send(method, value) if klass.respond_to? method
+      end
+    end
+
+    [:include, :extend].each do |method|
+      if set = options[method]
+        set = [set] unless set.is_a?(Array)
+        set.each do |mod|
+          klass.send(method, mod)
+        end
+      end
+    end
+
+    klass.preinit if klass.respond_to? :preinit
+  end
+
+  # Convert our name to a constant.
+  def name2const(name)
+    name.to_s.capitalize
+  end
+
+  # Store the class in the appropriate places.
+  def storeclass(klass, klassname, options)
+    if hash = options[:hash]
+      if hash.include? klassname and ! options[:overwrite]
+        raise Puppet::SubclassAlreadyDefined,
+          "Already a generated class named #{klassname}"
+      end
+
+      hash[klassname] = klass
+    end
+
+    # If we were told to stick it in a hash, then do so
+    if array = options[:array]
+      if (klass.respond_to? :name and
+              array.find { |c| c.name == klassname } and
+              ! options[:overwrite])
+        raise Puppet::SubclassAlreadyDefined,
+          "Already a generated class named #{klassname}"
+      end
+
+      array << klass
+    end
+  end
+end
+

data/lib/vendor/puppet/util/colors.rb

@@ -0,0 +1,128 @@
+require 'puppet/util/platform'
+
+module Puppet::Util::Colors
+  BLACK       = {:console => "\e[0;30m", :html => "color: #FFA0A0"     }
+  RED         = {:console => "\e[0;31m", :html => "color: #FFA0A0"     }
+  GREEN       = {:console => "\e[0;32m", :html => "color: #00CD00"     }
+  YELLOW      = {:console => "\e[0;33m", :html => "color: #FFFF60"     }
+  BLUE        = {:console => "\e[0;34m", :html => "color: #80A0FF"     }
+  MAGENTA     = {:console => "\e[0;35m", :html => "color: #FFA500"     }
+  CYAN        = {:console => "\e[0;36m", :html => "color: #40FFFF"     }
+  WHITE       = {:console => "\e[0;37m", :html => "color: #FFFFFF"     }
+  HBLACK      = {:console => "\e[1;30m", :html => "color: #FFA0A0"     }
+  HRED        = {:console => "\e[1;31m", :html => "color: #FFA0A0"     }
+  HGREEN      = {:console => "\e[1;32m", :html => "color: #00CD00"     }
+  HYELLOW     = {:console => "\e[1;33m", :html => "color: #FFFF60"     }
+  HBLUE       = {:console => "\e[1;34m", :html => "color: #80A0FF"     }
+  HMAGENTA    = {:console => "\e[1;35m", :html => "color: #FFA500"     }
+  HCYAN       = {:console => "\e[1;36m", :html => "color: #40FFFF"     }
+  HWHITE      = {:console => "\e[1;37m", :html => "color: #FFFFFF"     }
+  BG_RED      = {:console => "\e[0;41m", :html => "background: #FFA0A0"}
+  BG_GREEN    = {:console => "\e[0;42m", :html => "background: #00CD00"}
+  BG_YELLOW   = {:console => "\e[0;43m", :html => "background: #FFFF60"}
+  BG_BLUE     = {:console => "\e[0;44m", :html => "background: #80A0FF"}
+  BG_MAGENTA  = {:console => "\e[0;45m", :html => "background: #FFA500"}
+  BG_CYAN     = {:console => "\e[0;46m", :html => "background: #40FFFF"}
+  BG_WHITE    = {:console => "\e[0;47m", :html => "background: #FFFFFF"}
+  BG_HRED     = {:console => "\e[1;41m", :html => "background: #FFA0A0"}
+  BG_HGREEN   = {:console => "\e[1;42m", :html => "background: #00CD00"}
+  BG_HYELLOW  = {:console => "\e[1;43m", :html => "background: #FFFF60"}
+  BG_HBLUE    = {:console => "\e[1;44m", :html => "background: #80A0FF"}
+  BG_HMAGENTA = {:console => "\e[1;45m", :html => "background: #FFA500"}
+  BG_HCYAN    = {:console => "\e[1;46m", :html => "background: #40FFFF"}
+  BG_HWHITE   = {:console => "\e[1;47m", :html => "background: #FFFFFF"}
+  RESET       = {:console => "\e[0m",    :html => ""                   }
+
+  Colormap = {
+    :debug => WHITE,
+    :info => GREEN,
+    :notice => CYAN,
+    :warning => YELLOW,
+    :err => HMAGENTA,
+    :alert => RED,
+    :emerg => HRED,
+    :crit => HRED,
+
+    :black       => BLACK,
+    :red         => RED,
+    :green       => GREEN,
+    :yellow      => YELLOW,
+    :blue        => BLUE,
+    :magenta     => MAGENTA,
+    :cyan        => CYAN,
+    :white       => WHITE,
+    :hblack      => HBLACK,
+    :hred        => HRED,
+    :hgreen      => HGREEN,
+    :hyellow     => HYELLOW,
+    :hblue       => HBLUE,
+    :hmagenta    => HMAGENTA,
+    :hcyan       => HCYAN,
+    :hwhite      => HWHITE,
+    :bg_red      => BG_RED,
+    :bg_green    => BG_GREEN,
+    :bg_yellow   => BG_YELLOW,
+    :bg_blue     => BG_BLUE,
+    :bg_magenta  => BG_MAGENTA,
+    :bg_cyan     => BG_CYAN,
+    :bg_white    => BG_WHITE,
+    :bg_hred     => BG_HRED,
+    :bg_hgreen   => BG_HGREEN,
+    :bg_hyellow  => BG_HYELLOW,
+    :bg_hblue    => BG_HBLUE,
+    :bg_hmagenta => BG_HMAGENTA,
+    :bg_hcyan    => BG_HCYAN,
+    :bg_hwhite   => BG_HWHITE,
+    :reset       => { :console => "\e[m", :html => "" }
+  }
+
+  # We define console_has_color? at load time since it's checking the
+  # underlying platform which will not change, and we don't want to perform
+  # the check every time we use logging
+  if Puppet::Util::Platform.windows?
+    # We're on windows, need win32console for color to work
+    begin
+      require 'rubygems'
+      require 'win32console'
+    rescue LoadError
+      def console_has_color?
+        false
+      end
+    else
+      def console_has_color?
+        true
+      end
+    end
+  else
+    # On a posix system we can just enable it
+    def console_has_color?
+      true
+    end
+  end
+
+  def colorize(color, str)
+    case Puppet[:color]
+    when true, :ansi, "ansi", "yes"
+      if console_has_color?
+        console_color(color, str)
+      else
+        str
+      end
+    when :html, "html"
+      html_color(color, str)
+    else
+      str
+    end
+  end
+
+  def console_color(color, str)
+    Colormap[color][:console] +
+    str.gsub(RESET[:console], Colormap[color][:console]) +
+    RESET[:console]
+  end
+
+  def html_color(color, str)
+    span = '<span style="%s">' % Colormap[color][:html]
+    "#{span}%s</span>" % str.gsub(/<span .*?<\/span>/, "</span>\\0#{span}")
+  end
+end

data/lib/vendor/puppet/util/command_line.rb

@@ -0,0 +1,185 @@
+require "puppet/util/plugins"
+
+module Puppet
+  module Util
+    class CommandLine
+
+      LegacyName = Hash.new{|h,k| k}.update(
+        'agent'      => 'puppetd',
+        'cert'       => 'puppetca',
+        'doc'        => 'puppetdoc',
+        'filebucket' => 'filebucket',
+        'apply'      => 'puppet',
+        'describe'   => 'pi',
+        'queue'      => 'puppetqd',
+        'resource'   => 'ralsh',
+        'kick'       => 'puppetrun',
+        'master'     => 'puppetmasterd',
+        'device'     => 'puppetdevice'
+      )
+
+      def initialize(zero = $0, argv = ARGV, stdin = STDIN)
+        @zero  = zero
+        @argv  = argv.dup
+        @stdin = stdin
+
+        @subcommand_name, @args = subcommand_and_args(@zero, @argv, @stdin)
+        Puppet::Plugins.on_commandline_initialization(:command_line_object => self)
+      end
+
+      attr :subcommand_name
+      attr :args
+
+      def appdir
+        File.join('puppet', 'application')
+      end
+
+      def self.available_subcommands
+        absolute_appdirs = $LOAD_PATH.collect do |x|
+          File.join(x,'puppet','application')
+        end.select{ |x| File.directory?(x) }
+        absolute_appdirs.inject([]) do |commands, dir|
+          commands + Dir[File.join(dir, '*.rb')].map{|fn| File.basename(fn, '.rb')}
+        end.uniq
+      end
+      # available_subcommands was previously an instance method, not a class
+      # method, and we have an unknown number of user-implemented applications
+      # that depend on that behaviour.  Forwarding allows us to preserve a
+      # backward compatible API. --daniel 2011-04-11
+      def available_subcommands
+        self.class.available_subcommands
+      end
+
+      def require_application(application)
+        require File.join(appdir, application)
+      end
+
+      def execute
+        if subcommand_name and available_subcommands.include?(subcommand_name) then
+          require_application subcommand_name
+          app = Puppet::Application.find(subcommand_name).new(self)
+          Puppet::Plugins.on_application_initialization(:appliation_object => self)
+
+          # See the note in 'warn_later' down below. --daniel 2011-06-01
+          if $delayed_deprecation_warning_for_p_u_cl.is_a? String then
+            Puppet.deprecation_warning($delayed_deprecation_warning_for_p_u_cl)
+            $delayed_deprecation_warning_for_p_u_cl = true
+          end
+
+          app.run
+        elsif ! execute_external_subcommand then
+          unless subcommand_name.nil? then
+            puts "Error: Unknown Puppet subcommand '#{subcommand_name}'"
+          end
+          puts "See 'puppet help' for help on available puppet subcommands"
+        end
+      end
+
+      def execute_external_subcommand
+        external_command = "puppet-#{subcommand_name}"
+
+        require 'puppet/util'
+        path_to_subcommand = Puppet::Util.which(external_command)
+        return false unless path_to_subcommand
+
+        exec(path_to_subcommand, *args)
+      end
+
+      def legacy_executable_name
+        LegacyName[ subcommand_name ]
+      end
+
+      private
+
+      def subcommand_and_args(zero, argv, stdin)
+        zero = File.basename(zero, '.rb')
+
+        if zero == 'puppet'
+          case argv.first
+          when nil then
+            if stdin.tty? then
+              [nil, argv]       # ttys get usage info
+            else
+              # Killed for 2.7.0 --daniel 2011-06-01
+              warn_later <<EOM
+Implicit invocation of 'puppet apply' by redirection into 'puppet' is deprecated,
+and will be removed in the 2.8 series. Please invoke 'puppet apply' directly
+in the future.
+EOM
+              ["apply", argv]
+            end
+          when "--help", "-h" then
+            # help should give you usage, not the help for `puppet apply`
+            [nil, argv]
+          when /^-|\.pp$|\.rb$/ then
+            # Killed for 2.7.0 --daniel 2011-06-01
+            warn_later <<EOM
+Implicit invocation of 'puppet apply' by passing files (or flags) directly
+to 'puppet' is deprecated, and will be removed in the 2.8 series.  Please
+invoke 'puppet apply' directly in the future.
+EOM
+            ["apply", argv]
+          else
+            [argv.first, argv[1..-1]]
+          end
+        else
+          [zero, argv]
+        end
+      end
+
+      # So, this is more than a little bit of a horror.  You see, the process
+      # of bootstrapping Puppet is ... complex.  This file, like many of our
+      # early initialization files, has an incestuous relationship between the
+      # order of files loaded, code executed at load time, and code executed
+      # in other files at runtime.
+      #
+      # When we construct this object we have not yet actually loaded the
+      # global puppet object, so we can't use any methods in it.  That
+      # includes all the logging stuff, which is used by the deprecation
+      # warning subsystem.
+      #
+      # On the other hand, we can't just load the logging system, because that
+      # depends on the top level Puppet module being bootstrapped.  It doesn't
+      # actually load the stuff it uses, though, for hysterical raisins.
+      #
+      # Finally, we can't actually just load the top level Puppet module.
+      # This one is precious: it turns out that some of the code loaded in the
+      # top level Puppet module has a dependency on the run mode values.
+      #
+      # Run mode is set correctly *only* when the application is loaded, and
+      # if it is wrong when the top level code is brought in we end up with
+      # the wrong settings scattered through some of the defaults.
+      #
+      # Which means that we have a dependency cycle that runs:
+      # 1. The binary creates an instance of P::U::CL.
+      # 2. That identifies the application to load.
+      # 3. It does, then instantiates the application.
+      #    4. That sets the run-mode.
+      #    5. That then loads the top level Puppet module.
+      # 6. Finally, we get to where we can use the top level stuff
+      #
+      # So, essentially, we see a dependency between runtime code in this
+      # file, run-time code in the application, and load-time code in the top
+      # level module.
+      #
+      # Which leads me to our current horrible hack: we stash away the message
+      # we wanted to log about deprecation, then send it to our logging system
+      # once we have done enough bootstrapping that it will, y'know, actually
+      # work.
+      #
+      # I would have liked to fix this, but that is going to be a whole pile
+      # of work digging through and decrufting all the global state from the
+      # local state, and working out what depends on what else in the product.
+      #
+      # Oh, and we use a global because we have *two* instances of a P::U::CL
+      # object during the startup sequence.  I don't know why.
+      #
+      # Maybe, one day, when I am not behind a deadline to ship code.
+      # --daniel 2011-06-01
+      def warn_later(text)
+        return if $delayed_deprecation_warning_for_p_u_cl
+        $delayed_deprecation_warning_for_p_u_cl = text
+      end
+    end
+  end
+end

data/lib/vendor/puppet/util/constant_inflector.rb

@@ -0,0 +1,15 @@
+# Created on 2008-02-12
+# Copyright Luke Kanies
+
+# A common module for converting between constants and
+# file names.
+module Puppet::Util::ConstantInflector
+  def file2constant(file)
+    # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
+    x = file.split("/").collect { |name| name.capitalize }.join("::").gsub(/_+(.)/) { |term| $1.capitalize }
+  end
+
+  def constant2file(constant)
+    constant.to_s.gsub(/([a-z])([A-Z])/) { |term| $1 + "_#{$2}" }.gsub("::", "/").downcase
+  end
+end