puppet-retrospec 0.12.2 → 1.0.0

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

@@ -1,101 +0,0 @@
-# This class is not actually public API, but the method
-# {Puppet::Interface::ActionManager#action action} 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::ActionManager
-  # Declare that this app can take a specific action, and provide
-  # the code to do so.
-
-  # Defines a new action. This takes a block to build the action using
-  # the methods on {Puppet::Interface::ActionBuilder}.
-  # @param name [Symbol] The name that will be used to invoke the
-  #   action
-  # @overload action(name, {|| block})
-  # @return [void]
-  # @api public
-  # @dsl Faces
-  def action(name, &block)
-    @actions ||= {}
-    Puppet.warning "Redefining action #{name} for #{self}" if action?(name)
-
-    action = Puppet::Interface::ActionBuilder.build(self, name, &block)
-
-    # REVISIT: (#18042) doesn't this mean we can't redefine the default action? -- josh
-    if action.default and current = get_default_action
-      raise "Actions #{current.name} and #{name} cannot both be default"
-    end
-
-    @actions[action.name] = action
-  end
-
-  # Defines an action without using ActionBuilder. The block given is
-  # the code that will be executed when the action is invoked.
-  # @api public
-  # @deprecated
-  def script(name, &block)
-    @actions ||= {}
-    Puppet.warning "Redefining action #{name} for #{self}" if action?(name)
-
-    # REVISIT: (#18048) it's possible to create multiple default actions
-    @actions[name] = Puppet::Interface::Action.new(self, name, :when_invoked => block)
-  end
-
-  # Returns the list of available actions for this face.
-  # @return [Array<Symbol>] The names of the actions for this face
-  # @api private
-  def actions
-    @actions ||= {}
-    result = @actions.keys
-
-    if self.is_a?(Class) and superclass.respond_to?(:actions)
-      result += superclass.actions
-    elsif self.class.respond_to?(:actions)
-      result += self.class.actions
-    end
-    # We need to uniq the result, because we duplicate actions when they are
-    # fetched to ensure that they have the correct bindings; they shadow the
-    # parent, and uniq implements that. --daniel 2011-06-01
-    result.uniq.sort
-  end
-
-  # Retrieves a named action
-  # @param name [Symbol] The name of the action
-  # @return [Puppet::Interface::Action] The action object
-  # @api private
-  def get_action(name)
-    @actions ||= {}
-    result = @actions[name.to_sym]
-    if result.nil?
-      if self.is_a?(Class) and superclass.respond_to?(:get_action)
-        found = superclass.get_action(name)
-      elsif self.class.respond_to?(:get_action)
-        found = self.class.get_action(name)
-      end
-
-      if found then
-        # This is not the nicest way to make action equivalent to the Ruby
-        # Method object, rather than UnboundMethod, but it will do for now,
-        # and we only have to make this change in *one* place. --daniel 2011-04-12
-        result = @actions[name.to_sym] = found.__dup_and_rebind_to(self)
-      end
-    end
-    return result
-  end
-
-  # Retrieves the default action for the face
-  # @return [Puppet::Interface::Action]
-  # @api private
-  def get_default_action
-    default = actions.map {|x| get_action(x) }.select {|x| x.default }
-    if default.length > 1
-      raise "The actions #{default.map(&:name).join(", ")} cannot all be default"
-    end
-    default.first
-  end
-
-  # @api private
-  def action?(name)
-    actions.include?(name.to_sym)
-  end
-end

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

@@ -1,125 +0,0 @@
-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_builder.rb

@@ -1,93 +0,0 @@
-# @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/loaders.rb

@@ -1,19 +0,0 @@
-module Puppet
-  module Pops
-    require 'puppet/pops/loaders'
-
-    module Loader
-      require 'puppet/pops/loader/loader'
-      require 'puppet/pops/loader/base_loader'
-      require 'puppet/pops/loader/gem_support'
-      require 'puppet/pops/loader/module_loaders'
-      require 'puppet/pops/loader/dependency_loader'
-      require 'puppet/pops/loader/null_loader'
-      require 'puppet/pops/loader/static_loader'
-      require 'puppet/pops/loader/ruby_function_instantiator'
-      require 'puppet/pops/loader/loader_paths'
-      require 'puppet/pops/loader/simple_environment_loader'
-    end
-  end
-
-end

data/vendor/gems/puppet-3.7.3/lib/puppet/metatype/manager.rb

@@ -1,184 +0,0 @@
-require 'puppet'
-require 'puppet/util/classgen'
-require 'puppet/node/environment'
-
-# This module defines methods dealing with Type management.
-# This module gets included into the Puppet::Type class, it's just split out here for clarity.
-# @api public
-#
-module Puppet::MetaType
-module Manager
-  include Puppet::Util::ClassGen
-
-  # An implementation specific method that removes all type instances during testing.
-  # @note Only use this method for testing purposes.
-  # @api private
-  #
-  def allclear
-    @types.each { |name, type|
-      type.clear
-    }
-  end
-
-  # Iterates over all already loaded Type subclasses.
-  # @yield [t] a block receiving each type
-  # @yieldparam t [Puppet::Type] each defined type
-  # @yieldreturn [Object] the last returned object is also returned from this method
-  # @return [Object] the last returned value from the block.
-  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
-
-  # Loads all types.
-  # @note Should only be used for purposes such as generating documentation as this is potentially a very
-  #  expensive operation.
-  # @return [void]
-  #
-  def loadall
-    typeloader.loadall
-  end
-
-  # Defines a new type or redefines an existing type with the given name.
-  # A convenience method on the form `new<name>` where name is the name of the type is also created.
-  # (If this generated method happens to clash with an existing method, a warning is issued and the original
-  # method is kept).
-  #
-  # @param name [String] the name of the type to create or redefine.
-  # @param options [Hash] options passed on to {Puppet::Util::ClassGen#genclass} as the option `:attributes`.
-  # @option options [Puppet::Type]
-  #   Puppet::Type. This option is not passed on as an attribute to genclass.
-  # @yield [ ] a block evaluated in the context of the created class, thus allowing further detailing of
-  #   that class.
-  # @return [Class<inherits Puppet::Type>] the created subclass
-  # @see Puppet::Util::ClassGen.genclass
-  #
-  # @dsl type
-  # @api public
-  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}"
-    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 options.include?(:parent) 
-      Puppet.deprecation_warning "option :parent is deprecated. It has no effect"
-      options.delete(:parent)
-    end
-
-    # Then create the class.
-
-    klass = genclass(
-      name,
-      :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
-
-  # Removes an existing type.
-  # @note Only use this for testing.
-  # @api private
-  def rmtype(name)
-    # Then create the class.
-
-    rmclass(name, :hash => @types)
-
-    singleton_class.send(:remove_method, "new#{name}") if respond_to?("new#{name}")
-  end
-
-  # Returns a Type instance by name.
-  # This will load the type if not already defined.
-  # @param [String, Symbol] name of the wanted Type
-  # @return [Puppet::Type, nil] the type or nil if the type was not defined and could not be loaded
-  #
-  def type(name)
-    # Avoid loading if name obviously is not a type name
-    if name.to_s.include?(':')
-      return nil
-    end
-
-    @types ||= {}
-
-    # We are overwhelmingly symbols here, which usually match, so it is worth
-    # having this special-case to return quickly.  Like, 25K symbols vs. 300
-    # 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.lookup(:current_environment))
-      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
-
-  # Creates a loader for Puppet types.
-  # Defaults to an instance of {Puppet::Util::Autoload} if no other auto loader has been set.
-  # @return [Puppet::Util::Autoload] the loader to use.
-  # @api private
-  def typeloader
-    unless defined?(@typeloader)
-      @typeloader = Puppet::Util::Autoload.new(self, "puppet/type", :wrap => false)
-    end
-
-    @typeloader
-  end
-end
-end
-