class WADL::CLI

Constants

ARRAY_SUFFIX_RE
HASH_SUFFIX_RE
OPTION_RE
QUERY_SEPARATOR_RE
RESOURCE_PATH_RE

Attributes

query[R]
resource_path[R]

Public Class Methods

defaults() click to toggle source
Calls superclass method
# File lib/wadl/cli.rb, line 51
def defaults
  super.merge(
    config:            'config.yaml',
    method:            HTTPRequest::DEFAULT_METHOD.upcase,
    user:              ENV['USER'] || '',
    request_token_url: '%s/oauth/request_token',
    access_token_url:  '%s/oauth/access_token',
    authorize_url:     '%s/oauth/authorize'
  )
end
usage(*) click to toggle source
# File lib/wadl/cli.rb, line 47
def usage(*)
  "#{super} <resource-path> [-- arguments]"
end

Public Instance Methods

api() click to toggle source
# File lib/wadl/cli.rb, line 91
def api
  @api ||= Application.from_wadl(open(options[:wadl]))
end
auth_resource() click to toggle source
# File lib/wadl/cli.rb, line 105
def auth_resource
  @auth_resource ||= options[:skip_auth] ? resource            :
                     options[:oauth]     ? oauth_resource      :
                     options[:basic]     ? basic_auth_resource :
                                           resource
end
reset(stdin = STDIN, stdout = STDOUT, stderr = STDERR) click to toggle source
Calls superclass method
# File lib/wadl/cli.rb, line 112
def reset(stdin = STDIN, stdout = STDOUT, stderr = STDERR)
  super
  @api = @resource = @auth_resource = nil
end
resource() click to toggle source
# File lib/wadl/cli.rb, line 95
def resource
  @resource ||= begin
    path = [options[:api_base], *resource_path].compact.join('/')
    path = path.sub(/\A\//, '').split(RESOURCE_PATH_RE)

    path.inject(api) { |m, n| m.send(:find_resource_by_path, n) or
      quit "Resource not found: #{path.join('/')}: #{n}" }
  end
end
run(arguments) click to toggle source
# File lib/wadl/cli.rb, line 66
def run(arguments)
  if options.delete(:dump_config)
    stdout.puts(YAML.dump(options))
    exit
  end

  parse_arguments(arguments)
  quit if resource_path.empty?

  quit "WADL location is required! (Specify with '--wadl' or see '--help')" unless options[:wadl]
  options[:wadl] = options[:base_url] if options[:base_url]

  if debug = options[:debug]
    debug = 1 unless debug.is_a?(Integer)

    stderr.puts api.paths if debug >= 1
    stderr.puts api       if debug >= 2
  end

  response = auth_resource.send(options[:method].downcase, query: query)

  stderr.puts response.code.join(' ')
  stdout.puts response.representation unless response.code.first =~ /\A[45]/
end

Private Instance Methods

add_param(params, key, value) click to toggle source
# File lib/wadl/cli.rb, line 160
def add_param(params, key, value)
  case key
    when HASH_SUFFIX_RE
      sub = $1

      if (param = params[key]).is_a?(Hash)
        param[sub] = value
        return
      else
        value = { sub => value }
      end
    when ARRAY_SUFFIX_RE
      if (param = params[key]).is_a?(Array)
        param << value
        return
      else
        value = [value]
      end
  end

  params[key] = value
end
basic_auth_resource() click to toggle source
# File lib/wadl/cli.rb, line 183
def basic_auth_resource
  user, pass = options.values_at(:user, :password)
  pass ||= askpass("Password for user #{user}: ")

  quit 'USER and PASSWORD required' unless user && pass

  resource.with_basic_auth(user, pass)
end
generic_opts(opts) click to toggle source
Calls superclass method
# File lib/wadl/cli.rb, line 300
def generic_opts(opts)
  opts.option(:debug__LEVEL?, Integer, 'Enable debugging output') { |level|
    options[:debug] = level || true
  }

  opts.switch(:dump_config, :D, 'Dump config and exit')

  opts.separator

  super
end
oauth_resource() click to toggle source
# File lib/wadl/cli.rb, line 192
def oauth_resource
  consumer_key, consumer_secret = options.values_at(:consumer_key, :consumer_secret)
  access_token, token_secret    = options.values_at(:token, :secret)

  quit "CONSUMER KEY and SECRET required" unless consumer_key && consumer_secret

  unless access_token && token_secret
    access_token, token_secret = oauthorize(consumer_key, consumer_secret)
    quit 'Authorization failed!?' unless access_token && token_secret
  end

  resource.with_oauth(consumer_key, consumer_secret, access_token, token_secret)
end
oauthorize(consumer_key, consumer_secret) click to toggle source
Calls superclass method
# File lib/wadl/cli.rb, line 206
def oauthorize(consumer_key, consumer_secret)
  strio, stdout = StringIO.new, self.stdout

  (class << strio; self; end).send(:define_method, :puts) { |*args|
    stdout.puts(*args)
    super
  }

  base_url = options[:base_url] || File.dirname(options[:wadl])

  OAuth::CLI.execute(strio, stdin, stderr, [
    '--consumer-key',      consumer_key,
    '--consumer-secret',   consumer_secret,
    '--request-token-url', options[:request_token_url] % base_url,
    '--access-token-url',  options[:access_token_url]  % base_url,
    '--authorize-url',     options[:authorize_url]     % base_url,
    '--callback-url',      'oob',
    'authorize'
  ])

  result = strio.string
  access_token = result[/^\s+oauth_token:\s+(.*)$/, 1]
  token_secret = result[/^\s+oauth_token_secret:\s+(.*)$/, 1]

  return unless access_token && token_secret

  if File.writable?(options[:config])
    config[:token]  = access_token
    config[:secret] = token_secret

    File.open(options[:config], 'w') { |f| YAML.dump(config, f) }
  end

  [access_token, token_secret]
end
opts(opts) click to toggle source
# File lib/wadl/cli.rb, line 242
def opts(opts)
  opts.option(:wadl__FILE_OR_URL,
              'Path or URL to WADL file [Required]')

  opts.option(:method__METHOD,
              "Request method [Default: #{defaults[:method]}]",
              &:upcase!)

  opts.option(:api_base__PATH, 'Base path for API')

  opts.option(:query__QUERY, 'Query string to pass to request')

  opts.separator

  opts.switch('skip_auth', 'Skip any authentication')

  opts.separator
  opts.separator 'Basic Auth options:'

  opts.switch(:basic, :B, 'Perform Basic Auth')

  opts.separator

  opts.option('user__USER', 'User name')

  opts.option('password__PASSWORD', 'Password for user')

  opts.separator
  opts.separator 'OAuth options:'

  opts.switch(:oauth, :O, 'Perform OAuth')

  opts.separator

  opts.option('consumer_key__KEY', 'Consumer key to use')

  opts.option('consumer_secret__SECRET', 'Consumer secret to use')

  opts.separator

  opts.option('token__TOKEN', 'Access token to use')

  opts.option('secret__SECRET', 'Token secret to use')

  opts.separator

  opts.option(:base_url__URL, 'Base URL [Default: "dirname" of WADL]')

  opts.option('request_token_url__URL',
              "Request token URL [Default: #{defaults[:request_token_url] % 'BASE_URL'}]")

  opts.option('access_token_url__URL',
              "Access token URL [Default: #{defaults[:access_token_url] % 'BASE_URL'}]")

  opts.option('authorize_url__URL',
              "Authorize URL [Default: #{defaults[:authorize_url] % 'BASE_URL'}]")
end
parse_arguments(arguments) click to toggle source
# File lib/wadl/cli.rb, line 124
def parse_arguments(arguments)
  @resource_path, @query, skip_next = [], {}, false

  parse_query

  arguments.each_with_index { |arg, index|
    if skip_next
      skip_next = false
      next
    end

    if arg =~ OPTION_RE
      key, value, next_arg = $1, $2, arguments[index + 1]

      value ||= if next_arg.nil? || next_arg =~ OPTION_RE
        '1'  # "true"
      else
        skip_next = true
        next_arg
      end

      add_param(query, key, value)
    else
      resource_path << arg
    end
  }
end
parse_options(arguments) click to toggle source
Calls superclass method
# File lib/wadl/cli.rb, line 119
def parse_options(arguments)
  quit if arguments.empty?
  super
end
parse_query() click to toggle source
# File lib/wadl/cli.rb, line 152
def parse_query
  return unless query_string = options[:query]

  query_string.split(QUERY_SEPARATOR_RE).each { |pair|
    add_param(query, *pair.split('=', 2).map { |v| CGI.unescape(v) })
  }
end
post_opts(opts) click to toggle source
# File lib/wadl/cli.rb, line 312
def post_opts(opts)
  opts.separator
  opts.separator "PATH may be separated by any of #{RESOURCE_PATH_RE.source}."
end