puppet 2.6.18 → 2.7.1

data/lib/puppet/interface/action_builder.rb

@@ -0,0 +1,74 @@
+require 'puppet/interface'
+require 'puppet/interface/action'
+
+class Puppet::Interface::ActionBuilder
+  attr_reader :action
+
+  def self.build(face, name, &block)
+    raise "Action #{name.inspect} must specify a block" unless block
+    new(face, name, &block).action
+  end
+
+  # Ideally the method we're defining here would be added to the action, and a
+  # method on the face would defer to it, but we can't get scope correct, so
+  # we stick with this. --daniel 2011-03-24
+  def when_invoked(&block)
+    @action.when_invoked = block
+  end
+
+  def when_rendering(type = nil, &block)
+    if type.nil? then           # the default error message sucks --daniel 2011-04-18
+      raise ArgumentError, 'You must give a rendering format to when_rendering'
+    end
+    if block.nil? then
+      raise ArgumentError, 'You must give a block to when_rendering'
+    end
+    @action.set_rendering_method_for(type, block)
+  end
+
+  def option(*declaration, &block)
+    option = Puppet::Interface::OptionBuilder.build(@action, *declaration, &block)
+    @action.add_option(option)
+  end
+
+  def default(value = true)
+    @action.default = !!value
+  end
+
+  def render_as(value = nil)
+    value.nil? and raise ArgumentError, "You must give a rendering format to render_as"
+
+    formats = Puppet::Network::FormatHandler.formats
+    unless formats.include? value
+      raise ArgumentError, "#{value.inspect} is not a valid rendering format: #{formats.sort.join(", ")}"
+    end
+
+    @action.render_as = value
+  end
+
+  # Metaprogram the simple DSL from the target class.
+  Puppet::Interface::Action.instance_methods.grep(/=$/).each do |setter|
+    next if setter =~ /^=/
+    property = setter.to_s.chomp('=')
+
+    unless method_defined? property
+      # Using eval because the argument handling semantics are less awful than
+      # when we use the define_method/block version.  The later warns on older
+      # Ruby versions if you pass the wrong number of arguments, but carries
+      # on, which is totally not what we want. --daniel 2011-04-18
+      eval <<-METHOD
+        def #{property}(value)
+          @action.#{property} = value
+        end
+      METHOD
+    end
+  end
+
+  private
+  def initialize(face, name, &block)
+    @face   = face
+    @action = Puppet::Interface::Action.new(face, name)
+    instance_eval(&block)
+    @action.when_invoked or raise ArgumentError, "actions need to know what to do when_invoked; please add the block"
+  end
+end

data/lib/puppet/interface/action_manager.rb

@@ -0,0 +1,70 @@
+require 'puppet/interface/action'
+
+module Puppet::Interface::ActionManager
+  # Declare that this app can take a specific action, and provide
+  # the code to do so.
+  def action(name, &block)
+    require 'puppet/interface/action_builder'
+
+    @actions ||= {}
+    @default_action ||= nil
+    raise "Action #{name} already defined for #{self}" if action?(name)
+    action = Puppet::Interface::ActionBuilder.build(self, name, &block)
+    if action.default
+      raise "Actions #{@default_action.name} and #{name} cannot both be default" if @default_action
+      @default_action = action
+    end
+    @actions[action.name] = action
+  end
+
+  # This is the short-form of an action definition; it doesn't use the
+  # builder, just creates the action directly from the block.
+  def script(name, &block)
+    @actions ||= {}
+    raise "Action #{name} already defined for #{self}" if action?(name)
+    @actions[name] = Puppet::Interface::Action.new(self, name, :when_invoked => block)
+  end
+
+  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
+
+  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
+
+  def get_default_action
+    @default_action
+  end
+
+  def action?(name)
+    actions.include?(name.to_sym)
+  end
+end

data/lib/puppet/interface/documentation.rb

@@ -0,0 +1,230 @@
+# This isn't usable outside Puppet::Interface; don't load it alone.
+class Puppet::Interface
+  module DocGen
+    def self.strip_whitespace(text)
+      text.gsub!(/[ \t\f]+$/, '')
+
+      # We need to identify an indent: the minimum number of whitespace
+      # characters at the start of any line in the text.
+      #
+      # Using split rather than each_line is because the later only takes a
+      # block on Ruby 1.8.5 / Centos, and we support that. --daniel 2011-05-03
+      indent = text.split(/\n/).map {|x| x.index(/[^\s]/) }.compact.min
+
+      if indent > 0 then
+        text.gsub!(/^[ \t\f]{0,#{indent}}/, '')
+      end
+
+      return text
+    end
+
+    # The documentation attributes all have some common behaviours; previously
+    # we open-coded them across the set of six things, but that seemed
+    # wasteful - especially given that they were literally the same, and had
+    # the same bug hidden in them.
+    #
+    # This feels a bit like overkill, but at least the common code is common
+    # now. --daniel 2011-04-29
+    def attr_doc(name, &validate)
+      # Now, which form of the setter do we want, validated or not?
+      get_arg = "value.to_s"
+      if validate
+        define_method(:"_validate_#{name}", validate)
+        get_arg = "_validate_#{name}(#{get_arg})"
+      end
+
+      # We use module_eval, which I don't like much, because we can't have an
+      # argument to a block with a default value in Ruby 1.8, and I don't like
+      # the side-effects (eg: no argument count validation) of using blocks
+      # without as metheds.  When we are 1.9 only (hah!) you can totally
+      # replace this with some up-and-up define_method. --daniel 2011-04-29
+      module_eval(<<-EOT, __FILE__, __LINE__ + 1)
+        def #{name}(value = nil)
+          self.#{name} = value unless value.nil?
+          @#{name}
+        end
+
+        def #{name}=(value)
+          @#{name} = Puppet::Interface::DocGen.strip_whitespace(#{get_arg})
+        end
+      EOT
+    end
+  end
+
+  module TinyDocs
+    extend Puppet::Interface::DocGen
+
+    attr_doc :summary do |value|
+      value =~ /\n/ and
+        raise ArgumentError, "Face summary should be a single line; put the long text in 'description' instead."
+      value
+    end
+
+    attr_doc :description
+
+    def build_synopsis(face, action = nil, arguments = nil)
+      output = PrettyPrint.format do |s|
+        s.text("puppet #{face}")
+        s.text(" #{action}") unless action.nil?
+        s.text(" ")
+
+        options.each do |option|
+          option = get_option(option)
+          wrap = option.required? ? %w{ < > } : %w{ [ ] }
+
+          s.group(0, *wrap) do
+            option.optparse.each do |item|
+              unless s.current_group.first?
+                s.breakable
+                s.text '|'
+                s.breakable
+              end
+              s.text item
+            end
+          end
+
+          s.breakable
+        end
+
+        if arguments then
+          s.text arguments.to_s
+        end
+      end
+    end
+
+  end
+
+  module FullDocs
+    extend Puppet::Interface::DocGen
+    include TinyDocs
+
+    attr_doc :examples
+    attr_doc :notes
+    attr_doc :license
+
+    attr_doc :short_description
+    def short_description(value = nil)
+      self.short_description = value unless value.nil?
+      if @short_description.nil? then
+        return nil if @description.nil?
+        lines = @description.split("\n")
+        first_paragraph_break = lines.index('') || 5
+        grab  = [5, first_paragraph_break].min
+        @short_description = lines[0, grab].join("\n")
+        @short_description += ' [...]' if (grab < lines.length and first_paragraph_break >= 5)
+      end
+      @short_description
+    end
+
+    def author(value = nil)
+      unless value.nil? then
+        unless value.is_a? String
+          raise ArgumentError, 'author must be a string; use multiple statements for multiple authors'
+        end
+
+        if value =~ /\n/ then
+          raise ArgumentError, 'author should be a single line; use multiple statements for multiple authors'
+        end
+        @authors.push(Puppet::Interface::DocGen.strip_whitespace(value))
+      end
+      @authors.empty? ? nil : @authors.join("\n")
+    end
+    def authors
+      @authors
+    end
+    def author=(value)
+      if Array(value).any? {|x| x =~ /\n/ } then
+        raise ArgumentError, 'author should be a single line; use multiple statements'
+      end
+      @authors = Array(value).map{|x| Puppet::Interface::DocGen.strip_whitespace(x) }
+    end
+    alias :authors= :author=
+
+    def copyright(owner = nil, years = nil)
+      if years.nil? and not owner.nil? then
+        raise ArgumentError, 'copyright takes the owners names, then the years covered'
+      end
+      self.copyright_owner = owner unless owner.nil?
+      self.copyright_years = years unless years.nil?
+
+      if self.copyright_years or self.copyright_owner then
+        "Copyright #{self.copyright_years} by #{self.copyright_owner}"
+      else
+        "Unknown copyright owner and years."
+      end
+    end
+
+    attr_accessor :copyright_owner
+    def copyright_owner=(value)
+      case value
+      when String then @copyright_owner = value
+      when Array  then @copyright_owner = value.join(", ")
+      else
+        raise ArgumentError, "copyright owner must be a string or an array of strings"
+      end
+      @copyright_owner
+    end
+
+    attr_accessor :copyright_years
+    def copyright_years=(value)
+      years = munge_copyright_year value
+      years = (years.is_a?(Array) ? years : [years]).
+        sort_by do |x| x.is_a?(Range) ? x.first : x end
+
+      @copyright_years = years.map do |year|
+        if year.is_a? Range then
+          "#{year.first}-#{year.last}"
+        else
+          year
+        end
+      end.join(", ")
+    end
+
+    def munge_copyright_year(input)
+      case input
+      when Range then input
+      when Integer then
+        if input < 1970 then
+          fault = "before 1970"
+        elsif input > (future = Time.now.year + 2) then
+          fault = "after #{future}"
+        end
+        if fault then
+          raise ArgumentError, "copyright with a year #{fault} is very strange; did you accidentally add or subtract two years?"
+        end
+
+        input
+
+      when String then
+        input.strip.split(/,/).map do |part|
+          part = part.strip
+          if part =~ /^\d+$/ then
+            part.to_i
+          elsif found = part.split(/-/) then
+            unless found.length == 2 and found.all? {|x| x.strip =~ /^\d+$/ }
+              raise ArgumentError, "#{part.inspect} is not a good copyright year or range"
+            end
+            Range.new(found[0].to_i, found[1].to_i)
+          else
+            raise ArgumentError, "#{part.inspect} is not a good copyright year or range"
+          end
+        end
+
+      when Array then
+        result = []
+        input.each do |item|
+          item = munge_copyright_year item
+          if item.is_a? Array
+            result.concat item
+          else
+            result << item
+          end
+        end
+        result
+
+      else
+        raise ArgumentError, "#{input.inspect} is not a good copyright year, set, or range"
+      end
+    end
+  end
+end

data/lib/puppet/interface/face_collection.rb

@@ -0,0 +1,137 @@
+require 'puppet/interface'
+
+module Puppet::Interface::FaceCollection
+  SEMVER_VERSION = /^(\d+)\.(\d+)\.(\d+)([A-Za-z][0-9A-Za-z-]*|)$/
+
+  @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.validate_version(version)
+    !!(SEMVER_VERSION =~ version.to_s)
+  end
+
+  def self.semver_to_array(v)
+    parts = SEMVER_VERSION.match(v).to_a[1..4]
+    parts[0..2] = parts[0..2].map { |e| e.to_i }
+    parts
+  end
+
+  def self.cmp_semver(a, b)
+    a, b = [a, b].map do |x| semver_to_array(x) end
+
+    cmp = a[0..2] <=> b[0..2]
+    if cmp == 0
+      cmp = a[3] <=> b[3]
+      cmp = +1 if a[3].empty? && !b[3].empty?
+      cmp = -1 if b[3].empty? && !a[3].empty?
+    end
+    cmp
+  end
+
+  def self.prefix_match?(desired, target)
+    # Can't meaningfully do a prefix match with current on either side.
+    return false if desired == :current
+    return false if target  == :current
+
+    # REVISIT: Should probably fail if the matcher is not valid.
+    prefix = desired.split('.').map {|x| x =~ /^\d+$/ and x.to_i }
+    have   = semver_to_array(target)
+
+    while want = prefix.shift do
+      return false unless want == have.shift
+    end
+    return true
+  end
+
+  def self.[](name, version)
+    name = underscorize(name)
+    get_face(name, version) or load_face(name, version)
+  end
+
+  # get face from memory, without loading.
+  def self.get_face(name, desired_version)
+    return nil unless @faces.has_key? name
+
+    return @faces[name][:current] if desired_version == :current
+
+    found = @faces[name].keys.select {|v| prefix_match?(desired_version, v) }.sort.last
+    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
+    begin
+      require "puppet/face/#{name}"
+
+      # 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 {|a, b| cmp_semver(a, b) }.last
+        @faces[name][:current] = @faces[name][latest_ver]
+      end
+    rescue LoadError => e
+      raise unless e.message =~ %r{-- puppet/face/#{name}$}
+      # ...guess we didn't find the file; return a much better problem.
+    rescue SyntaxError => e
+      raise unless e.message =~ %r{puppet/face/#{name}\.rb:\d+: }
+      Puppet.err "Failed to load face #{name}:\n#{e}"
+      # ...but we just carry on after complaining.
+    end
+
+    return get_face(name, version)
+  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