puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/interface/face_collection.rb

@@ -0,0 +1,125 @@
+module Puppet::Interface::FaceCollection
+  @faces = Hash.new { |hash, key| hash[key] = {} }
+
+  @loader = Puppet::Util::Autoload.new(:application, 'puppet/face')
+
+  def self.faces
+    unless @loaded
+      @loaded = true
+      names = @loader.files_to_load.map {|fn| ::File.basename(fn, '.rb')}.uniq
+      names.each {|name| self[name, :current]}
+    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 = @loader.expand(version ? ::File.join(version.to_s, name.to_s) : name)
+    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][-_a-z0-9]*$/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/vendor/gems/puppet-3.7.3/lib/puppet/interface/option.rb

@@ -0,0 +1,150 @@
+# This represents an option on an action or face (to be globally applied
+# to its actions). Options should be constructed by calling
+# {Puppet::Interface::OptionManager#option}, which is available on
+# {Puppet::Interface}, and then calling methods of
+# {Puppet::Interface::OptionBuilder} in the supplied block.
+# @api public
+class Puppet::Interface::Option
+  include Puppet::Interface::TinyDocs
+
+  # @api private
+  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...
+        # for our duplicate checking purpose, we don't make a check with the
+        # translated '-' -> '_'. Right now, we do that on purpose because of
+        # a duplicated option made publicly available on certificate and ca
+        # faces for dns alt names. Puppet defines 'dns_alt_names', those
+        # faces include 'dns-alt-names'.  We can't get rid of 'dns-alt-names'
+        # yet, so we need to do our duplicate checking on the untranslated
+        # version of the option.
+        # jeffweiss 17 april 2012
+        name = optparse_to_optionname(item)
+        if Puppet.settings.include? name then
+          raise ArgumentError, "#{item.inspect}: already defined in puppet"
+        end
+        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
+
+  # @api private
+  def optparse_to_optionname(declaration)
+    unless found = declaration.match(/^-+(?:\[no-\])?([^ =]+)/) then
+      raise ArgumentError, "Can't find a name in the declaration #{declaration.inspect}"
+    end
+    found.captures.first
+  end
+
+  # @api private
+  def optparse_to_name(declaration)
+    name = optparse_to_optionname(declaration).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/vendor/gems/puppet-3.7.3/lib/puppet/interface/option_builder.rb

@@ -0,0 +1,93 @@
+# @api public
+class Puppet::Interface::OptionBuilder
+  # The option under construction
+  # @return [Puppet::Interface::Option]
+  # @api private
+  attr_reader :option
+
+  # Build an option
+  # @return [Puppet::Interface::Option]
+  # @api private
+  def self.build(face, *declaration, &block)
+    new(face, *declaration, &block).option
+  end
+
+  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.
+
+  # Sets a block to be executed when an action is invoked before the
+  # main action code. This is most commonly used to validate an option.
+  # @yieldparam action [Puppet::Interface::Action] The action being
+  #   invoked
+  # @yieldparam args [Array] The arguments given to the action
+  # @yieldparam options [Hash<Symbol=>Object>] Any options set
+  # @api public
+  # @dsl Faces
+  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
+
+  # Sets a block to be executed after an action is invoked.
+  # !(see before_action)
+  # @api public
+  # @dsl Faces
+  def after_action(&block)
+    block or raise ArgumentError, "#{@option} after_action requires a block"
+    if @option.after_action
+      raise ArgumentError, "#{@option} already has an 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
+
+  # Sets whether the option is required. If no argument is given it
+  # defaults to setting it as a required option.
+  # @api public
+  # @dsl Faces
+  def required(value = true)
+    @option.required = value
+  end
+
+  # Sets a block that will be used to compute the default value for this
+  # option. It will be evaluated when the action is invoked. The block
+  # should take no arguments.
+  # @api public
+  # @dsl Faces
+  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/vendor/gems/puppet-3.7.3/lib/puppet/interface/option_manager.rb

@@ -0,0 +1,99 @@
+# This class is not actually public API, but the method
+# {Puppet::Interface::OptionManager#option option} is public when used
+# as part of the Faces DSL (i.e. from within a
+# {Puppet::Interface.define define} block).
+# @api public
+module Puppet::Interface::OptionManager
+
+  # @api private
+  def display_global_options(*args)
+    @display_global_options ||= []
+    [args].flatten.each do |refopt|
+      raise ArgumentError, "Global option #{refopt} does not exist in Puppet.settings" unless Puppet.settings.include? refopt
+      @display_global_options << refopt if refopt
+    end
+    @display_global_options.uniq!
+    @display_global_options
+  end
+  alias :display_global_option :display_global_options
+
+  def all_display_global_options
+    walk_inheritance_tree(@display_global_options, :all_display_global_options)
+  end
+
+  # @api private
+  def walk_inheritance_tree(start, sym)
+    result = (start ||= [])
+    if self.is_a?(Class) and superclass.respond_to?(sym)
+      result = superclass.send(sym) + result
+    elsif self.class.respond_to?(sym)
+      result = self.class.send(sym) + result
+    end
+    return result
+  end
+
+  # Declare that this app can take a specific option, and provide the
+  # code to do so. See {Puppet::Interface::ActionBuilder#option} for
+  # details.
+  #
+  # @api public
+  # @dsl Faces
+  def option(*declaration, &block)
+    add_option Puppet::Interface::OptionBuilder.build(self, *declaration, &block)
+  end
+
+  # @api private
+  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
+
+  # @api private
+  def options
+    walk_inheritance_tree(@options, :options)
+  end
+
+  # @api private
+  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
+
+  # @api private
+  def option?(name)
+    options.include? name.to_sym
+  end
+end