3rdparty/modules/aviator/lib/puppet/feature/aviator/core/cli/describer.rb

   1 module Aviator
   2
   3   class Describer
   4
   5     class InvalidProviderNameError < StandardError
   6       def initialize(name)
   7         super "Provider '#{ name }' does not exist."
   8       end
   9     end
  10
  11
  12     def self.describe_aviator
  13       str = "Available providers:\n"
  14
  15       provider_names.each do |provider_name|
  16         str << "  #{ provider_name }\n"
  17       end
  18
  19       str
  20     end
  21
  22
  23     def self.describe_provider(provider_name)
  24       str = "Available services for #{ provider_name }:\n"
  25
  26       service_names(provider_name).each do |service_name|
  27         str << "  #{ service_name }\n"
  28       end
  29
  30       str
  31     end
  32
  33
  34     def self.describe_request(provider_name, service_name, api_version, endpoint_type, request_name)
  35       service = Aviator::Service.new :provider => provider_name, :service => service_name
  36       request_class = "Aviator::#{ provider_name.camelize }::#{ service_name.camelize }::Requests::"\
  37                       "#{ api_version.camelize }::#{ endpoint_type.camelize }::#{ request_name.camelize }".constantize
  38
  39       display = "Request: #{ request_name }\n"
  40
  41
  42       # Build the parameters
  43       params = request_class.optional_params.map{|p| [p, false]} +
  44                request_class.required_params.map{|p| [p, true]}
  45
  46       aliases = request_class.param_aliases
  47
  48       if params.length > 0
  49         display << "\n"
  50
  51         headings = ['NAME', 'REQUIRED?']
  52
  53         headings << 'ALIAS' if aliases.length > 0
  54
  55         rows = []
  56         params.sort{|a,b| a[0].to_s <=> b[0].to_s }.each do |param|
  57           row = [ param[0], param[1] ? 'Y' : 'N' ]
  58
  59           if aliases.length > 0
  60             row << (aliases.find{|a,p| p == param[0] } || [''])[0]
  61           end
  62
  63           rows << row
  64         end
  65
  66         widths = [
  67           rows.map{|row| row[0].to_s.length }.max,
  68           rows.map{|row| row[1].to_s.length }.max
  69         ]
  70
  71         widths << rows.map{|row| row[2].to_s.length }.max if aliases.length > 0
  72
  73         table = Terminal::Table.new(:headings => headings, :rows => rows)
  74
  75         table.align_column(1, :center)
  76
  77         display << "Parameters:\n"
  78         display << " " + table.to_s.split("\n").join("\n ")
  79         display << "\n"
  80       end
  81
  82
  83       # Build the sample code
  84       display << "\nSample Code:\n"
  85
  86       display << "  session.request(:#{ service_name }_service, :#{ request_name })"
  87
  88       if params && params.length > 0
  89         display << " do |params|\n"
  90         params.each do |pair|
  91           display << "    params.#{ (aliases.find{|a,p| p == pair[0] } || pair)[0] } = value\n"
  92         end
  93         display << "  end"
  94       end
  95
  96       display << "\n"
  97
  98
  99       # Build the links
 100       if request_class.links && request_class.links.length > 0
 101         display << "\nLinks:\n"
 102
 103         request_class.links.each do |link|
 104           display << "  #{ link[:rel] }:\n"
 105           display << "    #{ link[:href] }\n"
 106         end
 107       end
 108
 109       display
 110     end
 111
 112
 113     def self.describe_service(provider_name, service_name)
 114       requests = request_classes(provider_name, service_name)
 115
 116       if requests.empty?
 117         str = "No requests found for #{ provider_name } #{ service_name }_service."
 118       else
 119         str = "Available requests for #{ provider_name } #{ service_name }_service:\n"
 120
 121         requests.each do |klass|
 122           str << "  #{ klass.api_version } #{ klass.endpoint_type } #{ klass.name.split('::').last.underscore }\n"
 123         end
 124
 125         str
 126       end
 127     end
 128
 129
 130     class <<self
 131       private
 132
 133       def provider_names
 134         Pathname.new(__FILE__) \
 135           .join('..', '..', '..') \
 136           .children \
 137           .select{|c| c.directory? && c.basename.to_s != 'core' } \
 138           .map{|c| c.basename.to_s }
 139       end
 140
 141
 142       def request_classes(provider_name, service_name)
 143         service = Aviator::Service.new(:provider => provider_name, :service => service_name)
 144         service.request_classes
 145       end
 146
 147
 148       def service_names(name)
 149         provider = Pathname.new(__FILE__).join('..', '..', '..', name)
 150
 151         raise InvalidProviderNameError.new(name) unless provider.exist?
 152
 153         provider.children \
 154                 .select{|c| c.directory? } \
 155                 .map{|c| c.basename.to_s }
 156       end
 157     end
 158
 159   end
 160
 161 end