puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/interface/face_collection.rb

@@ -0,0 +1,128 @@
+require 'puppet/interface'
+
+module Puppet::Interface::FaceCollection
+  @faces = Hash.new { |hash, key| hash[key] = {} }
+
+  def self.faces
+    unless @loaded
+      @loaded = true
+      $LOAD_PATH.each do |dir|
+        Dir.glob("#{dir}/puppet/face/*.rb").
+          collect {|f| File.basename(f, '.rb') }.
+          each {|name| self[name, :current] }
+      end
+    end
+    @faces.keys.select {|name| @faces[name].length > 0 }
+  end
+
+  def self.[](name, version)
+    name = underscorize(name)
+    get_face(name, version) or load_face(name, version)
+  end
+
+  def self.get_action_for_face(name, action_name, version)
+    name = underscorize(name)
+
+    # If the version they request specifically doesn't exist, don't search
+    # elsewhere.  Usually this will start from :current and all...
+    return nil unless face = self[name, version]
+    unless action = face.get_action(action_name)
+      # ...we need to search for it bound to an o{lder,ther} version.  Since
+      # we load all actions when the face is first references, this will be in
+      # memory in the known set of versions of the face.
+      (@faces[name].keys - [ :current ]).sort.reverse.each do |version|
+        break if action = @faces[name][version].get_action(action_name)
+      end
+    end
+
+    return action
+  end
+
+  # get face from memory, without loading.
+  def self.get_face(name, pattern)
+    return nil unless @faces.has_key? name
+    return @faces[name][:current] if pattern == :current
+
+    versions = @faces[name].keys - [ :current ]
+    found    = SemVer.find_matching(pattern, versions)
+    return @faces[name][found]
+  end
+
+  # try to load the face, and return it.
+  def self.load_face(name, version)
+    # We always load the current version file; the common case is that we have
+    # the expected version and any compatibility versions in the same file,
+    # the default.  Which means that this is almost always the case.
+    #
+    # We use require to avoid executing the code multiple times, like any
+    # other Ruby library that we might want to use.  --daniel 2011-04-06
+    if safely_require name then
+      # If we wanted :current, we need to index to find that; direct version
+      # requests just work™ as they go. --daniel 2011-04-06
+      if version == :current then
+        # We need to find current out of this.  This is the largest version
+        # number that doesn't have a dedicated on-disk file present; those
+        # represent "experimental" versions of faces, which we don't fully
+        # support yet.
+        #
+        # We walk the versions from highest to lowest and take the first version
+        # that is not defined in an explicitly versioned file on disk as the
+        # current version.
+        #
+        # This constrains us to only ship experimental versions with *one*
+        # version in the file, not multiple, but given you can't reliably load
+        # them except by side-effect when you ignore that rule this seems safe
+        # enough...
+        #
+        # Given those constraints, and that we are not going to ship a versioned
+        # interface that is not :current in this release, we are going to leave
+        # these thoughts in place, and just punt on the actual versioning.
+        #
+        # When we upgrade the core to support multiple versions we can solve the
+        # problems then; as lazy as possible.
+        #
+        # We do support multiple versions in the same file, though, so we sort
+        # versions here and return the last item in that set.
+        #
+        # --daniel 2011-04-06
+        latest_ver = @faces[name].keys.sort.last
+        @faces[name][:current] = @faces[name][latest_ver]
+      end
+    end
+
+    unless version == :current or get_face(name, version)
+      # Try an obsolete version of the face, if needed, to see if that helps?
+      safely_require name, version
+    end
+
+    return get_face(name, version)
+  end
+
+  def self.safely_require(name, version = nil)
+    path = File.join 'puppet' ,'face', version.to_s, name.to_s
+    require path
+    true
+
+  rescue LoadError => e
+    raise unless e.message =~ %r{-- #{path}$}
+    # ...guess we didn't find the file; return a much better problem.
+    nil
+  rescue SyntaxError => e
+    raise unless e.message =~ %r{#{path}\.rb:\d+: }
+    Puppet.err "Failed to load face #{name}:\n#{e}"
+    # ...but we just carry on after complaining.
+    nil
+  end
+
+  def self.register(face)
+    @faces[underscorize(face.name)][face.version] = face
+  end
+
+  def self.underscorize(name)
+    unless name.to_s =~ /^[-_a-z]+$/i then
+      raise ArgumentError, "#{name.inspect} (#{name.class}) is not a valid face name"
+    end
+
+    name.to_s.downcase.split(/[-_]/).join('_').to_sym
+  end
+end

data/lib/vendor/puppet/interface/option.rb

@@ -0,0 +1,127 @@
+require 'puppet/interface'
+
+class Puppet::Interface::Option
+  include Puppet::Interface::TinyDocs
+
+  def initialize(parent, *declaration, &block)
+    @parent   = parent
+    @optparse = []
+    @default  = nil
+
+    # Collect and sort the arguments in the declaration.
+    dups = {}
+    declaration.each do |item|
+      if item.is_a? String and item.to_s =~ /^-/ then
+        unless item =~ /^-[a-z]\b/ or item =~ /^--[^-]/ then
+          raise ArgumentError, "#{item.inspect}: long options need two dashes (--)"
+        end
+        @optparse << item
+
+        # Duplicate checking...
+        name = optparse_to_name(item)
+        if dup = dups[name] then
+          raise ArgumentError, "#{item.inspect}: duplicates existing alias #{dup.inspect} in #{@parent}"
+        else
+          dups[name] = item
+        end
+      else
+        raise ArgumentError, "#{item.inspect} is not valid for an option argument"
+      end
+    end
+
+    if @optparse.empty? then
+      raise ArgumentError, "No option declarations found while building"
+    end
+
+    # Now, infer the name from the options; we prefer the first long option as
+    # the name, rather than just the first option.
+    @name = optparse_to_name(@optparse.find do |a| a =~ /^--/ end || @optparse.first)
+    @aliases = @optparse.map { |o| optparse_to_name(o) }
+
+    # Do we take an argument?  If so, are we consistent about it, because
+    # incoherence here makes our life super-difficult, and we can more easily
+    # relax this rule later if we find a valid use case for it. --daniel 2011-03-30
+    @argument = @optparse.any? { |o| o =~ /[ =]/ }
+    if @argument and not @optparse.all? { |o| o =~ /[ =]/ } then
+      raise ArgumentError, "Option #{@name} is inconsistent about taking an argument"
+    end
+
+    # Is our argument optional?  The rules about consistency apply here, also,
+    # just like they do to taking arguments at all. --daniel 2011-03-30
+    @optional_argument = @optparse.any? { |o| o=~/[ =]\[/ }
+    @optional_argument and raise ArgumentError, "Options with optional arguments are not supported"
+    if @optional_argument and not @optparse.all? { |o| o=~/[ =]\[/ } then
+      raise ArgumentError, "Option #{@name} is inconsistent about the argument being optional"
+    end
+  end
+
+  # to_s and optparse_to_name are roughly mirrored, because they are used to
+  # transform options to name symbols, and vice-versa.  This isn't a full
+  # bidirectional transformation though. --daniel 2011-04-07
+  def to_s
+    @name.to_s.tr('_', '-')
+  end
+
+  def optparse_to_name(declaration)
+    unless found = declaration.match(/^-+(?:\[no-\])?([^ =]+)/) then
+      raise ArgumentError, "Can't find a name in the declaration #{declaration.inspect}"
+    end
+    name = found.captures.first.tr('-', '_')
+    raise "#{name.inspect} is an invalid option name" unless name.to_s =~ /^[a-z]\w*$/
+    name.to_sym
+  end
+
+
+  def takes_argument?
+    !!@argument
+  end
+  def optional_argument?
+    !!@optional_argument
+  end
+  def required?
+    !!@required
+  end
+
+  def has_default?
+    !!@default
+  end
+
+  def default=(proc)
+    required and raise ArgumentError, "#{self} can't be optional and have a default value"
+    proc.is_a? Proc or raise ArgumentError, "default value for #{self} is a #{proc.class.name.inspect}, not a proc"
+    @default = proc
+  end
+
+  def default
+    @default and @default.call
+  end
+
+  attr_reader   :parent, :name, :aliases, :optparse
+  attr_accessor :required
+  def required=(value)
+    has_default? and raise ArgumentError, "#{self} can't be optional and have a default value"
+    @required = value
+  end
+
+  attr_accessor :before_action
+  def before_action=(proc)
+    proc.is_a? Proc or raise ArgumentError, "before action hook for #{self} is a #{proc.class.name.inspect}, not a proc"
+    @before_action =
+      @parent.__send__(:__add_method, __decoration_name(:before), proc)
+  end
+
+  attr_accessor :after_action
+  def after_action=(proc)
+    proc.is_a? Proc or raise ArgumentError, "after action hook for #{self} is a #{proc.class.name.inspect}, not a proc"
+    @after_action =
+      @parent.__send__(:__add_method, __decoration_name(:after), proc)
+  end
+
+  def __decoration_name(type)
+    if @parent.is_a? Puppet::Interface::Action then
+      :"option #{name} from #{parent.name} #{type} decoration"
+    else
+      :"option #{name} #{type} decoration"
+    end
+  end
+end

data/lib/vendor/puppet/interface/option_builder.rb

@@ -0,0 +1,67 @@
+require 'puppet/interface/option'
+
+class Puppet::Interface::OptionBuilder
+  attr_reader :option
+
+  def self.build(face, *declaration, &block)
+    new(face, *declaration, &block).option
+  end
+
+  private
+  def initialize(face, *declaration, &block)
+    @face   = face
+    @option = Puppet::Interface::Option.new(face, *declaration)
+    instance_eval(&block) if block_given?
+    @option
+  end
+
+  # Metaprogram the simple DSL from the option class.
+  Puppet::Interface::Option.instance_methods.grep(/=$/).each do |setter|
+    next if setter =~ /^=/
+    dsl = setter.to_s.chomp('=')
+
+    unless private_method_defined? dsl
+      define_method(dsl) do |value| @option.send(setter, value) end
+    end
+  end
+
+  # Override some methods that deal in blocks, not objects.
+  def before_action(&block)
+    block or raise ArgumentError, "#{@option} before_action requires a block"
+    if @option.before_action
+      raise ArgumentError, "#{@option} already has a before_action set"
+    end
+    unless block.arity == 3 then
+      raise ArgumentError, "before_action takes three arguments, action, args, and options"
+    end
+    @option.before_action = block
+  end
+
+  def after_action(&block)
+    block or raise ArgumentError, "#{@option} after_action requires a block"
+    if @option.after_action
+      raise ArgumentError, "#{@option} already has a after_action set"
+    end
+    unless block.arity == 3 then
+      raise ArgumentError, "after_action takes three arguments, action, args, and options"
+    end
+    @option.after_action = block
+  end
+
+  def required(value = true)
+    @option.required = value
+  end
+
+  def default_to(&block)
+    block or raise ArgumentError, "#{@option} default_to requires a block"
+    if @option.has_default?
+      raise ArgumentError, "#{@option} already has a default value"
+    end
+    # Ruby 1.8 treats a block without arguments as accepting any number; 1.9
+    # gets this right, so we work around it for now... --daniel 2011-07-20
+    unless block.arity == 0 or (RUBY_VERSION =~ /^1\.8/ and block.arity == -1)
+      raise ArgumentError, "#{@option} default_to block should not take any arguments"
+    end
+    @option.default = block
+  end
+end

data/lib/vendor/puppet/interface/option_manager.rb

@@ -0,0 +1,68 @@
+require 'puppet/interface/option_builder'
+
+module Puppet::Interface::OptionManager
+  # Declare that this app can take a specific option, and provide
+  # the code to do so.
+  def option(*declaration, &block)
+    add_option Puppet::Interface::OptionBuilder.build(self, *declaration, &block)
+  end
+
+  def add_option(option)
+    # @options collects the added options in the order they're declared.
+    # @options_hash collects the options keyed by alias for quick lookups.
+    @options      ||= []
+    @options_hash ||= {}
+
+    option.aliases.each do |name|
+      if conflict = get_option(name) then
+        raise ArgumentError, "Option #{option} conflicts with existing option #{conflict}"
+      end
+
+      actions.each do |action|
+        action = get_action(action)
+        if conflict = action.get_option(name) then
+          raise ArgumentError, "Option #{option} conflicts with existing option #{conflict} on #{action}"
+        end
+      end
+    end
+
+    @options << option.name
+
+    option.aliases.each do |name|
+      @options_hash[name] = option
+    end
+
+    return option
+  end
+
+  def options
+    result = (@options ||= [])
+
+    if self.is_a?(Class) and superclass.respond_to?(:options)
+      result = superclass.options + result
+    elsif self.class.respond_to?(:options)
+      result = self.class.options + result
+    end
+
+    return result
+  end
+
+  def get_option(name, with_inherited_options = true)
+    @options_hash ||= {}
+
+    result = @options_hash[name.to_sym]
+    if result.nil? and with_inherited_options then
+      if self.is_a?(Class) and superclass.respond_to?(:get_option)
+        result = superclass.get_option(name)
+      elsif self.class.respond_to?(:get_option)
+        result = self.class.get_option(name)
+      end
+    end
+
+    return result
+  end
+
+  def option?(name)
+    options.include? name.to_sym
+  end
+end

data/lib/vendor/puppet/interface.rb

@@ -0,0 +1,161 @@
+require 'puppet'
+require 'puppet/util/autoload'
+require 'puppet/interface/documentation'
+require 'prettyprint'
+require 'semver'
+
+class Puppet::Interface
+  include FullDocs
+
+  require 'puppet/interface/face_collection'
+
+  require 'puppet/interface/action_manager'
+  include Puppet::Interface::ActionManager
+  extend Puppet::Interface::ActionManager
+
+  require 'puppet/interface/option_manager'
+  include Puppet::Interface::OptionManager
+  extend Puppet::Interface::OptionManager
+
+  include Puppet::Util
+
+  class << self
+    # This is just so we can search for actions.  We only use its
+    # list of directories to search.
+    # Can't we utilize an external autoloader, or simply use the $LOAD_PATH? -pvb
+    def autoloader
+      @autoloader ||= Puppet::Util::Autoload.new(:application, "puppet/face")
+    end
+
+    def faces
+      Puppet::Interface::FaceCollection.faces
+    end
+
+    def register(instance)
+      Puppet::Interface::FaceCollection.register(instance)
+    end
+
+    def define(name, version, &block)
+      face = Puppet::Interface::FaceCollection[name, version]
+      if face.nil? then
+        face = self.new(name, version)
+        Puppet::Interface::FaceCollection.register(face)
+        # REVISIT: Shouldn't this be delayed until *after* we evaluate the
+        # current block, not done before? --daniel 2011-04-07
+        face.load_actions
+      end
+
+      face.instance_eval(&block) if block_given?
+
+      return face
+    end
+
+    def face?(name, version)
+      Puppet::Interface::FaceCollection[name, version]
+    end
+
+    def [](name, version)
+      unless face = Puppet::Interface::FaceCollection[name, version]
+        if current = Puppet::Interface::FaceCollection[name, :current]
+          raise Puppet::Error, "Could not find version #{version} of #{name}"
+        else
+          raise Puppet::Error, "Could not find Puppet Face #{name.inspect}"
+        end
+      end
+      face
+    end
+
+    def find_action(name, action, version = :current)
+      Puppet::Interface::FaceCollection.get_action_for_face(name, action, version)
+    end
+  end
+
+  def set_default_format(format)
+    Puppet.warning("set_default_format is deprecated (and ineffective); use render_as on your actions instead.")
+  end
+
+
+  ########################################################################
+  # Documentation.  We currently have to rewrite both getters because we share
+  # the same instance between build-time and the runtime instance.  When that
+  # splits out this should merge into a module that both the action and face
+  # include. --daniel 2011-04-17
+  def synopsis
+    build_synopsis self.name, '<action>'
+  end
+
+
+  ########################################################################
+  attr_reader :name, :version
+
+  def initialize(name, version, &block)
+    unless SemVer.valid?(version)
+      raise ArgumentError, "Cannot create face #{name.inspect} with invalid version number '#{version}'!"
+    end
+
+    @name    = Puppet::Interface::FaceCollection.underscorize(name)
+    @version = SemVer.new(version)
+
+    # The few bits of documentation we actually demand.  The default license
+    # is a favour to our end users; if you happen to get that in a core face
+    # report it as a bug, please. --daniel 2011-04-26
+    @authors  = []
+    @license  = 'All Rights Reserved'
+
+    instance_eval(&block) if block_given?
+  end
+
+  # Try to find actions defined in other files.
+  def load_actions
+    Puppet::Interface.autoloader.search_directories.each do |dir|
+      Dir.glob(File.join(dir, "puppet/face/#{name}", "*.rb")).each do |file|
+        action = file.sub(dir, '').sub(/^[\\\/]/, '').sub(/\.rb/, '')
+        Puppet.debug "Loading action '#{action}' for '#{name}' from '#{dir}/#{action}.rb'"
+        require(action)
+      end
+    end
+  end
+
+  def to_s
+    "Puppet::Face[#{name.inspect}, #{version.inspect}]"
+  end
+
+  ########################################################################
+  # Action decoration, whee!  You are not expected to care about this code,
+  # which exists to support face building and construction.  I marked these
+  # private because the implementation is crude and ugly, and I don't yet know
+  # enough to work out how to make it clean.
+  #
+  # Once we have established that these methods will likely change radically,
+  # to be unrecognizable in the final outcome.  At which point we will throw
+  # all this away, replace it with something nice, and work out if we should
+  # be making this visible to the outside world... --daniel 2011-04-14
+  private
+  def __invoke_decorations(type, action, passed_args = [], passed_options = {})
+    [:before, :after].member?(type) or fail "unknown decoration type #{type}"
+
+    # Collect the decoration methods matching our pass.
+    methods = action.options.select do |name|
+      passed_options.has_key? name
+    end.map do |name|
+      action.get_option(name).__decoration_name(type)
+    end
+
+    methods.reverse! if type == :after
+
+    # Exceptions here should propagate up; this implements a hook we can use
+    # reasonably for option validation.
+    methods.each do |hook|
+      respond_to? hook and self.__send__(hook, action, passed_args, passed_options)
+    end
+  end
+
+  def __add_method(name, proc)
+    meta_def(name, &proc)
+    method(name).unbind
+  end
+  def self.__add_method(name, proc)
+    define_method(name, proc)
+    instance_method(name)
+  end
+end

data/lib/vendor/puppet/metatype/manager.rb

@@ -0,0 +1,141 @@
+require 'puppet'
+require 'puppet/util/classgen'
+
+# Methods dealing with Type management.  This module gets included into the
+# Puppet::Type class, it's just split out here for clarity.
+module Puppet::MetaType
+module Manager
+  include Puppet::Util::ClassGen
+
+  # remove all type instances; this is mostly only useful for testing
+  def allclear
+    @types.each { |name, type|
+      type.clear
+    }
+  end
+
+  # iterate across all of the subclasses of Type
+  def eachtype
+    @types.each do |name, type|
+      # Only consider types that have names
+      #if ! type.parameters.empty? or ! type.validproperties.empty?
+        yield type
+      #end
+    end
+  end
+
+  # Load all types.  Only currently used for documentation.
+  def loadall
+    typeloader.loadall
+  end
+
+  # Define a new type.
+  def newtype(name, options = {}, &block)
+    # Handle backward compatibility
+    unless options.is_a?(Hash)
+      Puppet.warning "Puppet::Type.newtype(#{name}) now expects a hash as the second argument, not #{options.inspect}"
+      options = {:parent => options}
+    end
+
+    # First make sure we don't have a method sitting around
+    name = name.intern
+    newmethod = "new#{name}"
+
+    # Used for method manipulation.
+    selfobj = singleton_class
+
+    @types ||= {}
+
+    if @types.include?(name)
+      if self.respond_to?(newmethod)
+        # Remove the old newmethod
+        selfobj.send(:remove_method,newmethod)
+      end
+    end
+
+    options = symbolize_options(options)
+
+    if parent = options[:parent]
+      options.delete(:parent)
+    end
+
+    # Then create the class.
+
+    klass = genclass(
+      name,
+      :parent => (parent || Puppet::Type),
+      :overwrite => true,
+      :hash => @types,
+      :attributes => options,
+      &block
+    )
+
+    # Now define a "new<type>" method for convenience.
+    if self.respond_to? newmethod
+      # Refuse to overwrite existing methods like 'newparam' or 'newtype'.
+      Puppet.warning "'new#{name.to_s}' method already exists; skipping"
+    else
+      selfobj.send(:define_method, newmethod) do |*args|
+        klass.new(*args)
+      end
+    end
+
+    # If they've got all the necessary methods defined and they haven't
+    # already added the property, then do so now.
+    klass.ensurable if klass.ensurable? and ! klass.validproperty?(:ensure)
+
+    # Now set up autoload any providers that might exist for this type.
+
+    klass.providerloader = Puppet::Util::Autoload.new(klass, "puppet/provider/#{klass.name.to_s}")
+
+    # We have to load everything so that we can figure out the default provider.
+    klass.providerloader.loadall
+    klass.providify unless klass.providers.empty?
+
+    klass
+  end
+
+  # Remove an existing defined type.  Largely used for testing.
+  def rmtype(name)
+    # Then create the class.
+
+    klass = rmclass(name, :hash => @types)
+
+    singleton_class.send(:remove_method, "new#{name}") if respond_to?("new#{name}")
+  end
+
+  # Return a Type instance by name.
+  def type(name)
+    @types ||= {}
+
+    # We are overwhelmingly symbols here, which usually match, so it is worth
+    # having this special-case to return quickly.  Like, 25K to 300 symbols to
+    # strings in this method. --daniel 2012-07-17
+    return @types[name] if @types[name]
+
+    # Try mangling the name, if it is a string.
+    if name.is_a? String
+      name = name.downcase.intern
+      return @types[name] if @types[name]
+    end
+
+    # Try loading the type.
+    if typeloader.load(name, Puppet::Node::Environment.current)
+      Puppet.warning "Loaded puppet/type/#{name} but no class was created" unless @types.include? name
+    end
+
+    # ...and I guess that is that, eh.
+    return @types[name]
+  end
+
+  # Create a loader for Puppet types.
+  def typeloader
+    unless defined?(@typeloader)
+      @typeloader = Puppet::Util::Autoload.new(self, "puppet/type", :wrap => false)
+    end
+
+    @typeloader
+  end
+end
+end
+