oauth 1.0.1 → 1.1.1

data/lib/oauth/cli/base_command.rb

@@ -1,214 +0,0 @@
-# frozen_string_literal: true
-
-module OAuth
-  class CLI
-    class BaseCommand
-      def initialize(stdout, stdin, stderr, arguments)
-        @stdout = stdout
-        @stdin = stdin
-        @stderr = stderr
-
-        @options = {}
-        option_parser.parse!(arguments)
-      end
-
-      def run
-        missing = required_options - options.keys
-        if missing.empty?
-          _run
-        else
-          show_missing(missing)
-          puts option_parser.help
-        end
-      end
-
-      def required_options
-        []
-      end
-
-      protected
-
-      attr_reader :options
-
-      def show_missing(array)
-        array = array.map { |s| "--#{s}" }.join(" ")
-        OAuth::CLI.puts_red "Options missing to OAuth CLI: #{array}"
-      end
-
-      def xmpp?
-        options[:xmpp]
-      end
-
-      def verbose?
-        options[:verbose]
-      end
-
-      def puts(string = nil)
-        @stdout.puts(string)
-      end
-
-      def alert(string = nil)
-        @stderr.puts(string)
-      end
-
-      def parameters
-        @parameters ||= begin
-          escaped_pairs = options[:params].collect do |pair|
-            if /:/.match?(pair)
-              Hash[*pair.split(":", 2)].collect do |k, v|
-                [CGI.escape(k.strip), CGI.escape(v.strip)].join("=")
-              end
-            else
-              pair
-            end
-          end
-
-          querystring = escaped_pairs * "&"
-          cli_params = CGI.parse(querystring)
-
-          {
-            "oauth_consumer_key" => options[:oauth_consumer_key],
-            "oauth_nonce" => options[:oauth_nonce],
-            "oauth_timestamp" => options[:oauth_timestamp],
-            "oauth_token" => options[:oauth_token],
-            "oauth_signature_method" => options[:oauth_signature_method],
-            "oauth_version" => options[:oauth_version]
-          }.reject { |_k, v| v.nil? || v == "" }.merge(cli_params)
-        end
-      end
-
-      def option_parser
-        @option_parser ||= OptionParser.new do |opts|
-          opts.banner = "Usage: oauth <command> [ARGS]"
-
-          _option_parser_defaults
-          _option_parser_common(opts)
-          _option_parser_sign_and_query(opts)
-          _option_parser_authorization(opts)
-        end
-      end
-
-      def _option_parser_defaults
-        options[:oauth_nonce] = OAuth::Helper.generate_key
-        options[:oauth_signature_method] = "HMAC-SHA1"
-        options[:oauth_timestamp] = OAuth::Helper.generate_timestamp
-        options[:oauth_version] = "1.0"
-        options[:method] = :post
-        options[:params] = []
-        options[:scheme] = :header
-        options[:version] = "1.0"
-      end
-
-      def _option_parser_common(opts)
-        ## Common Options
-
-        opts.on("-B", "--body", "Use the request body for OAuth parameters.") do
-          options[:scheme] = :body
-        end
-
-        opts.on("--consumer-key KEY", "Specifies the consumer key to use.") do |v|
-          options[:oauth_consumer_key] = v
-        end
-
-        opts.on("--consumer-secret SECRET", "Specifies the consumer secret to use.") do |v|
-          options[:oauth_consumer_secret] = v
-        end
-
-        opts.on("-H", "--header", "Use the 'Authorization' header for OAuth parameters (default).") do
-          options[:scheme] = :header
-        end
-
-        opts.on("-Q", "--query-string", "Use the query string for OAuth parameters.") do
-          options[:scheme] = :query_string
-        end
-
-        opts.on("-O", "--options FILE", "Read options from a file") do |v|
-          arguments = open(v).readlines.map { |l| l.chomp.split }.flatten
-          options2 = parse_options(arguments)
-          options.merge!(options2)
-        end
-      end
-
-      def _option_parser_sign_and_query(opts)
-        opts.separator("\n  options for signing and querying")
-
-        opts.on("--method METHOD", "Specifies the method (e.g. GET) to use when signing.") do |v|
-          options[:method] = v
-        end
-
-        opts.on("--nonce NONCE", "Specifies the nonce to use.") do |v|
-          options[:oauth_nonce] = v
-        end
-
-        opts.on("--parameters PARAMS", "Specifies the parameters to use when signing.") do |v|
-          options[:params] << v
-        end
-
-        opts.on("--signature-method METHOD", "Specifies the signature method to use; defaults to HMAC-SHA1.") do |v|
-          options[:oauth_signature_method] = v
-        end
-
-        opts.on("--token TOKEN", "Specifies the token to use.") do |v|
-          options[:oauth_token] = v
-        end
-
-        opts.on("--secret SECRET", "Specifies the token secret to use.") do |v|
-          options[:oauth_token_secret] = v
-        end
-
-        opts.on("--timestamp TIMESTAMP", "Specifies the timestamp to use.") do |v|
-          options[:oauth_timestamp] = v
-        end
-
-        opts.on("--realm REALM", "Specifies the realm to use.") do |v|
-          options[:realm] = v
-        end
-
-        opts.on("--uri URI", "Specifies the URI to use when signing.") do |v|
-          options[:uri] = v
-        end
-
-        opts.on("--version [VERSION]", "Specifies the OAuth version to use.") do |v|
-          options[:oauth_version] = v
-        end
-
-        opts.on("--no-version", "Omit oauth_version.") do
-          options[:oauth_version] = nil
-        end
-
-        opts.on("--xmpp", "Generate XMPP stanzas.") do
-          options[:xmpp] = true
-          options[:method] ||= "iq"
-        end
-
-        opts.on("-v", "--verbose", "Be verbose.") do
-          options[:verbose] = true
-        end
-      end
-
-      def _option_parser_authorization(opts)
-        opts.separator("\n  options for authorization")
-
-        opts.on("--access-token-url URL", "Specifies the access token URL.") do |v|
-          options[:access_token_url] = v
-        end
-
-        opts.on("--authorize-url URL", "Specifies the authorization URL.") do |v|
-          options[:authorize_url] = v
-        end
-
-        opts.on("--callback-url URL", "Specifies a callback URL.") do |v|
-          options[:oauth_callback] = v
-        end
-
-        opts.on("--request-token-url URL", "Specifies the request token URL.") do |v|
-          options[:request_token_url] = v
-        end
-
-        opts.on("--scope SCOPE", "Specifies the scope (Google-specific).") do |v|
-          options[:scope] = v
-        end
-      end
-    end
-  end
-end

data/lib/oauth/cli/help_command.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module OAuth
-  class CLI
-    class HelpCommand < BaseCommand
-      def run
-        puts <<-EOT
-  Usage: oauth COMMAND [ARGS]
-
-  Available oauth commands are:
-    a, authorize  Obtain an access token and secret for a user
-    q, query      Query a protected resource
-    s, sign       Generate an OAuth signature
-
-  In addition to those, there are:
-    v, version    Displays the current version of the library (or --version, -v)
-    h, help       Displays this help (or --help, -h)
-
-  Tip: All commands can be run without args for specific help.
-
-
-        EOT
-      end
-    end
-  end
-end

data/lib/oauth/cli/query_command.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module OAuth
-  class CLI
-    class QueryCommand < BaseCommand
-      extend OAuth::Helper
-
-      def required_options
-        %i[oauth_consumer_key oauth_consumer_secret oauth_token oauth_token_secret]
-      end
-
-      def _run
-        consumer = OAuth::Consumer.new(options[:oauth_consumer_key], options[:oauth_consumer_secret],
-                                       scheme: options[:scheme])
-
-        access_token = OAuth::AccessToken.new(consumer, options[:oauth_token], options[:oauth_token_secret])
-
-        # append params to the URL
-        uri = URI.parse(options[:uri])
-        params = parameters.map do |k, v|
-          Array(v).map do |v2|
-            "#{OAuth::Helper.escape(k)}=#{OAuth::Helper.escape(v2)}"
-          end * "&"
-        end
-        uri.query = [uri.query, *params].compact * "&"
-        puts uri.to_s
-
-        response = access_token.request(options[:method].to_s.downcase.to_sym, uri.to_s)
-        puts "#{response.code} #{response.message}"
-        puts response.body
-      end
-    end
-  end
-end

data/lib/oauth/cli/sign_command.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module OAuth
-  class CLI
-    class SignCommand < BaseCommand
-      def required_options
-        %i[oauth_consumer_key oauth_consumer_secret oauth_token oauth_token_secret]
-      end
-
-      def _run
-        request = OAuth::RequestProxy.proxy \
-          "method" => options[:method],
-          "uri" => options[:uri],
-          "parameters" => parameters
-
-        puts_verbose_parameters(request) if verbose?
-
-        request.sign! \
-          consumer_secret: options[:oauth_consumer_secret],
-          token_secret: options[:oauth_token_secret]
-
-        if verbose?
-          puts_verbose_request(request)
-        else
-          puts request.oauth_signature
-        end
-      end
-
-      def puts_verbose_parameters(request)
-        puts "OAuth parameters:"
-        request.oauth_parameters.each do |k, v|
-          puts "  #{[k, v].join(": ")}"
-        end
-        puts
-
-        if request.non_oauth_parameters.any?
-          puts "Parameters:"
-          request.non_oauth_parameters.each do |k, v|
-            puts "  #{[k, v].join(": ")}"
-          end
-          puts
-        end
-      end
-
-      def puts_verbose_request(request)
-        puts "Method: #{request.method}"
-        puts "URI: #{request.uri}"
-        puts "Normalized params: #{request.normalized_parameters}" unless options[:xmpp]
-        puts "Signature base string: #{request.signature_base_string}"
-
-        if xmpp?
-          puts
-          puts "XMPP Stanza:"
-          puts xmpp_output(request)
-          puts
-          puts "Note: You may want to use bare JIDs in your URI."
-          puts
-        else
-          puts "OAuth Request URI: #{request.signed_uri}"
-          puts "Request URI: #{request.signed_uri(with_oauth: false)}"
-          puts "Authorization header: #{request.oauth_header(realm: options[:realm])}"
-        end
-        puts "Signature:         #{request.oauth_signature}"
-        puts "Escaped signature: #{OAuth::Helper.escape(request.oauth_signature)}"
-      end
-
-      def xmpp_output(request)
-        <<-EOS
-  <oauth xmlns='urn:xmpp:oauth:0'>
-    <oauth_consumer_key>#{request.oauth_consumer_key}</oauth_consumer_key>
-    <oauth_token>#{request.oauth_token}</oauth_token>
-    <oauth_signature_method>#{request.oauth_signature_method}</oauth_signature_method>
-    <oauth_signature>#{request.oauth_signature}</oauth_signature>
-    <oauth_timestamp>#{request.oauth_timestamp}</oauth_timestamp>
-    <oauth_nonce>#{request.oauth_nonce}</oauth_nonce>
-    <oauth_version>#{request.oauth_version}</oauth_version>
-  </oauth>
-        EOS
-      end
-    end
-  end
-end

data/lib/oauth/cli/version_command.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module OAuth
-  class CLI
-    class VersionCommand < BaseCommand
-      def run
-        puts "OAuth Gem #{OAuth::Version::VERSION}"
-      end
-    end
-  end
-end

data/lib/oauth/cli.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require "optparse"
-require "oauth/cli/base_command"
-require "oauth/cli/help_command"
-require "oauth/cli/query_command"
-require "oauth/cli/authorize_command"
-require "oauth/cli/sign_command"
-require "oauth/cli/version_command"
-require "active_support/core_ext/string/inflections"
-
-module OAuth
-  class CLI
-    def self.puts_red(string)
-      puts "\033[0;91m#{string}\033[0m"
-    end
-
-    ALIASES = {
-      "h" => "help",
-      "v" => "version",
-      "q" => "query",
-      "a" => "authorize",
-      "s" => "sign"
-    }.freeze
-
-    def initialize(stdout, stdin, stderr, command, arguments)
-      klass = get_command_class(parse_command(command))
-      @command = klass.new(stdout, stdin, stderr, arguments)
-      @help_command = HelpCommand.new(stdout, stdin, stderr, [])
-    end
-
-    def run
-      @command.run
-    end
-
-    private
-
-    def get_command_class(command)
-      Object.const_get("OAuth::CLI::#{command.camelize}Command")
-    end
-
-    def parse_command(command)
-      case command = command.to_s.downcase
-      when "--version", "-v"
-        "version"
-      when "--help", "-h", nil, ""
-        "help"
-      when *ALIASES.keys
-        ALIASES[command]
-      when *ALIASES.values
-        command
-      else
-        OAuth::CLI.puts_red "Command '#{command}' not found"
-        "help"
-      end
-    end
-  end
-end