schwab_rb 0.3.2 → 0.3.3

data/lib/schwab_rb/auth/auth_context.rb

@@ -1,23 +1,27 @@
+# frozen_string_literal: true
+
 require "oauth2"
 
-module SchwabRb::Auth
-  class AuthContext
-    class << self
-      def build(oauth_client, callback_url, authorization_url, state: nil)
-        auth_params = { redirect_uri: callback_url }
-        auth_params[:state] = state if state
-        authorization_url = oauth_client.auth_code.authorize_url(auth_params)
+module SchwabRb
+  module Auth
+    class AuthContext
+      class << self
+        def build(oauth_client, callback_url, authorization_url, state: nil)
+          auth_params = { redirect_uri: callback_url }
+          auth_params[:state] = state if state
+          authorization_url = oauth_client.auth_code.authorize_url(auth_params)
 
-        new(callback_url, authorization_url, state)
+          new(callback_url, authorization_url, state)
+        end
       end
-    end
 
-    def initialize(callback_url, authorization_url, state)
-      @callback_url = callback_url
-      @authorization_url = authorization_url
-      @state = state
-    end
+      def initialize(callback_url, authorization_url, state)
+        @callback_url = callback_url
+        @authorization_url = authorization_url
+        @state = state
+      end
 
-    attr_reader :callback_url, :authorization_url, :state
+      attr_reader :callback_url, :authorization_url, :state
+    end
   end
 end

data/lib/schwab_rb/auth/init_client_easy.rb

@@ -1,43 +1,47 @@
+# frozen_string_literal: true
+
 require "oauth2"
 require_relative "init_client_token_file"
 require_relative "init_client_login"
 
-module SchwabRb::Auth
-  def self.init_client_easy(
-    api_key,
-    app_secret,
-    callback_url,
-    token_path,
-    asyncio: false,
-    enforce_enums: false,
-    callback_timeout: 300.0,
-    interactive: true,
-    requested_browser: nil
-  )
-
-    raise OAuth2::Error.new("No token found") unless File.exist?(token_path)
-
-    client = SchwabRb::Auth.init_client_token_file(
-      api_key,
-      app_secret,
-      token_path,
-      enforce_enums: enforce_enums
-    )
-    client.refresh! if client.session.expired?
-    raise OAuth2::Error.new("Token expired") if client.session.expired?
-
-    client
-  rescue StandardError
-    SchwabRb::Auth.init_client_login(
+module SchwabRb
+  module Auth
+    def self.init_client_easy(
       api_key,
       app_secret,
       callback_url,
       token_path,
-      asyncio: asyncio,
-      enforce_enums: enforce_enums,
-      callback_timeout: callback_timeout,
-      interactive: interactive,
-      requested_browser: requested_browser
+      asyncio: false,
+      enforce_enums: false,
+      callback_timeout: 300.0,
+      interactive: true,
+      requested_browser: nil
     )
+
+      raise OAuth2::Error, "No token found" unless File.exist?(token_path)
+
+      client = SchwabRb::Auth.init_client_token_file(
+        api_key,
+        app_secret,
+        token_path,
+        enforce_enums: enforce_enums
+      )
+      client.refresh! if client.session.expired?
+      raise OAuth2::Error, "Token expired" if client.session.expired?
+
+      client
+    rescue StandardError
+      SchwabRb::Auth.init_client_login(
+        api_key,
+        app_secret,
+        callback_url,
+        token_path,
+        asyncio: asyncio,
+        enforce_enums: enforce_enums,
+        callback_timeout: callback_timeout,
+        interactive: interactive,
+        requested_browser: requested_browser
+      )
+    end
   end
 end

data/lib/schwab_rb/auth/init_client_login.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "openssl"
 require "uri"
 require "net/http"
@@ -5,200 +7,202 @@ require "json"
 require "oauth2"
 # require 'logger'
 
-module SchwabRb::Auth
-  class RedirectTimeoutError < StandardError
-    def initialize(msg = "Timed out waiting for a callback")
-      super
+module SchwabRb
+  module Auth
+    class RedirectTimeoutError < StandardError
+      def initialize(msg = "Timed out waiting for a callback")
+        super
+      end
     end
-  end
 
-  class RedirectServerExitedError < StandardError; end
-
-  # class TokenExchangeError < StandardError
-  #   def initialize(msg)
-  #     super(msg)
-  #   end
-  # end
-  class InvalidHostname < ArgumentError
-    def initialize(hostname)
-      msg = "Disallowed hostname #{hostname}. init_client_login only allows callback URLs with hostname 127.0.0.1."
-      super(msg)
+    class RedirectServerExitedError < StandardError; end
+
+    # class TokenExchangeError < StandardError
+    #   def initialize(msg)
+    #     super(msg)
+    #   end
+    # end
+    class InvalidHostname < ArgumentError
+      def initialize(hostname)
+        msg = "Disallowed hostname #{hostname}. init_client_login only allows callback URLs with hostname 127.0.0.1."
+        super(msg)
+      end
     end
-  end
 
-  def self.init_client_login(
-    api_key,
-    app_secret,
-    callback_url,
-    token_path,
-    asyncio: false,
-    enforce_enums: false,
-    callback_timeout: 300.0,
-    interactive: true,
-    requested_browser: nil
-  )
-
-    callback_timeout = if !callback_timeout
-                         0
-    elsif callback_timeout < 0
-      raise ArgumentError, "callback_timeout must be non-negative"
-    else
-      callback_timeout
-                       end
-
-    parsed = URI.parse(callback_url)
-    raise InvalidHostname.new(parsed.host) unless parsed.host == "127.0.0.1"
-
-    callback_port = parsed.port || 4567
-    callback_path = parsed.path.empty? ? "/" : parsed.path
-
-    cert_file, key_file = create_ssl_certificate
-
-    SchwabRb::Auth::LoginFlowServer.run_in_thread(
-      callback_port: callback_port,
-      callback_path: callback_path,
-      cert_file: cert_file,
-      key_file: key_file
+    def self.init_client_login(
+      api_key,
+      app_secret,
+      callback_url,
+      token_path,
+      asyncio: false,
+      enforce_enums: false,
+      callback_timeout: 300.0,
+      interactive: true,
+      requested_browser: nil
     )
 
-    begin
-      # NOTE: wait for server to start
-      start_time = Time.now
-      while true
-        begin
-          uri = URI("https://127.0.0.1:#{callback_port}/status")
-          http = Net::HTTP.new(uri.host, uri.port)
-          http.use_ssl = true
-          http.ca_file = cert_file.path
+      callback_timeout = if !callback_timeout
+                           0
+      elsif callback_timeout.negative?
+        raise ArgumentError, "callback_timeout must be non-negative"
+      else
+        callback_timeout
+                         end
 
-          http.set_debug_output($stdout)
+      parsed = URI.parse(callback_url)
+      raise InvalidHostname, parsed.host unless parsed.host == "127.0.0.1"
 
-          resp = http.get(uri.path)
+      callback_port = parsed.port || 4567
+      callback_path = parsed.path.empty? ? "/" : parsed.path
 
-          break if resp.is_a?(Net::HTTPSuccess)
-        rescue Errno::ECONNREFUSED
-          sleep 0.1
-        end
+      cert_file, key_file = create_ssl_certificate
 
-        raise RedirectServerExitedError if Time.now - start_time > 5
-      end
+      SchwabRb::Auth::LoginFlowServer.run_in_thread(
+        callback_port: callback_port,
+        callback_path: callback_path,
+        cert_file: cert_file,
+        key_file: key_file
+      )
 
-      auth_context = build_auth_context(api_key, callback_url)
+      begin
+        # NOTE: wait for server to start
+        start_time = Time.now
+        loop do
+          begin
+            uri = URI("https://127.0.0.1:#{callback_port}/status")
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = true
+            http.ca_file = cert_file.path
 
-      puts <<~MESSAGE
-        ***********************************************************************
-        Open this URL in your browser to log in:
-        #{auth_context.authorization_url}
-        ***********************************************************************
-      MESSAGE
+            http.set_debug_output($stdout)
 
-      if interactive
-        puts "Press ENTER to open the browser..."
-        gets
-      end
+            resp = http.get(uri.path)
 
-      `open "#{auth_context.authorization_url}}"`
+            break if resp.is_a?(Net::HTTPSuccess)
+          rescue Errno::ECONNREFUSED
+            sleep 0.1
+          end
 
-      timeout_time = Time.now + callback_timeout
-      received_url = nil
+          raise RedirectServerExitedError if Time.now - start_time > 5
+        end
 
-      while Time.now < timeout_time
-        unless LoginFlowServer.queue.empty?
-          received_url = LoginFlowServer.queue.pop
-          break
+        auth_context = build_auth_context(api_key, callback_url)
+
+        puts <<~MESSAGE
+          ***********************************************************************
+          Open this URL in your browser to log in:
+          #{auth_context.authorization_url}
+          ***********************************************************************
+        MESSAGE
+
+        if interactive
+          puts "Press ENTER to open the browser..."
+          gets
         end
-        sleep 0.1
-      end
 
-      raise RedirectTimeoutError.new unless received_url
+        `open "#{auth_context.authorization_url}}"`
 
-      client_from_received_url(
-        api_key,
-        app_secret,
-        auth_context,
-        received_url,
-        token_path
-      )
-    ensure
-      LoginFlowServer.stop
+        timeout_time = Time.now + callback_timeout
+        received_url = nil
+
+        while Time.now < timeout_time
+          unless LoginFlowServer.queue.empty?
+            received_url = LoginFlowServer.queue.pop
+            break
+          end
+          sleep 0.1
+        end
+
+        raise RedirectTimeoutError unless received_url
+
+        client_from_received_url(
+          api_key,
+          app_secret,
+          auth_context,
+          received_url,
+          token_path
+        )
+      ensure
+        LoginFlowServer.stop
+      end
     end
-  end
 
-  def self.create_ssl_certificate
-    key = OpenSSL::PKey::RSA.new(2048)
-    cert = OpenSSL::X509::Certificate.new
+    def self.create_ssl_certificate
+      key = OpenSSL::PKey::RSA.new(2048)
+      cert = OpenSSL::X509::Certificate.new
 
-    cert.subject = OpenSSL::X509::Name.parse("/CN=127.0.0.1")
-    cert.issuer = cert.subject
-    cert.public_key = key.public_key
-    cert.not_before = Time.now
-    cert.not_after = Time.now + (60 * 60 * 24) # 1 day
-    cert.serial = 0x0
-    cert.version = 2
-    cert.sign(key, OpenSSL::Digest.new("SHA256"))
+      cert.subject = OpenSSL::X509::Name.parse("/CN=127.0.0.1")
+      cert.issuer = cert.subject
+      cert.public_key = key.public_key
+      cert.not_before = Time.now
+      cert.not_after = Time.now + (60 * 60 * 24) # 1 day
+      cert.serial = 0x0
+      cert.version = 2
+      cert.sign(key, OpenSSL::Digest.new("SHA256"))
 
-    cert_file = Tempfile.new("cert.pem")
-    cert_file.write(cert.to_pem)
-    cert_file.close
+      cert_file = Tempfile.new("cert.pem")
+      cert_file.write(cert.to_pem)
+      cert_file.close
 
-    key_file = Tempfile.new("key.pem")
-    key_file.write(key.to_pem)
-    key_file.close
+      key_file = Tempfile.new("key.pem")
+      key_file.write(key.to_pem)
+      key_file.close
 
-    [cert_file, key_file]
-  end
+      [cert_file, key_file]
+    end
 
-  def self.build_auth_context(api_key, callback_url, state: nil)
-    oauth = OAuth2::Client.new(
-      api_key,
-      nil,
-      site: SchwabRb::Constants::SCHWAB_BASE_URL,
-      authorize_url: "/v1/oauth/authorize",
-      connection_opts: { ssl: { verify: false } }
-    )
+    def self.build_auth_context(api_key, callback_url, state: nil)
+      oauth = OAuth2::Client.new(
+        api_key,
+        nil,
+        site: SchwabRb::Constants::SCHWAB_BASE_URL,
+        authorize_url: "/v1/oauth/authorize",
+        connection_opts: { ssl: { verify: false } }
+      )
 
-    auth_params = { redirect_uri: callback_url }
-    auth_params[:state] = state if state
-    authorization_url = oauth.auth_code.authorize_url(auth_params)
+      auth_params = { redirect_uri: callback_url }
+      auth_params[:state] = state if state
+      authorization_url = oauth.auth_code.authorize_url(auth_params)
 
-    AuthContext.new(callback_url, authorization_url, state)
-  end
+      AuthContext.new(callback_url, authorization_url, state)
+    end
 
-  def self.client_from_received_url(
-    api_key, app_secret, auth_context, received_url, token_path, enforce_enums: true
-  )
-    oauth = OAuth2::Client.new(
-      api_key,
-      app_secret,
-      site: SchwabRb::Constants::SCHWAB_BASE_URL,
-      token_url: "/v1/oauth/token"
+    def self.client_from_received_url(
+      api_key, app_secret, auth_context, received_url, token_path, enforce_enums: true
     )
-    uri = URI.parse(received_url)
-    params = URI.decode_www_form(uri.query).to_h
-    authorization_code = params["code"]
+      oauth = OAuth2::Client.new(
+        api_key,
+        app_secret,
+        site: SchwabRb::Constants::SCHWAB_BASE_URL,
+        token_url: "/v1/oauth/token"
+      )
+      uri = URI.parse(received_url)
+      params = URI.decode_www_form(uri.query).to_h
+      authorization_code = params["code"]
 
-    token = oauth.auth_code.get_token(authorization_code, redirect_uri: auth_context.callback_url)
+      token = oauth.auth_code.get_token(authorization_code, redirect_uri: auth_context.callback_url)
 
-    metadata_manager = SchwabRb::Auth::TokenManager.from_oauth2_token(
-      token,
-      Time.now.to_i,
-      token_path: token_path
-    )
-    metadata_manager.to_file
+      metadata_manager = SchwabRb::Auth::TokenManager.from_oauth2_token(
+        token,
+        Time.now.to_i,
+        token_path: token_path
+      )
+      metadata_manager.to_file
 
-    session = OAuth2::AccessToken.new(
-      oauth,
-      token.token,
-      refresh_token: token.refresh_token,
-      expires_at: token.expires_at
-    )
+      session = OAuth2::AccessToken.new(
+        oauth,
+        token.token,
+        refresh_token: token.refresh_token,
+        expires_at: token.expires_at
+      )
 
-    SchwabRb::Client.new(
-      api_key,
-      app_secret,
-      session,
-      token_manager: metadata_manager,
-      enforce_enums: enforce_enums
-    )
+      SchwabRb::Client.new(
+        api_key,
+        app_secret,
+        session,
+        token_manager: metadata_manager,
+        enforce_enums: enforce_enums
+      )
+    end
   end
 end

data/lib/schwab_rb/auth/init_client_token_file.rb

@@ -1,30 +1,34 @@
+# frozen_string_literal: true
+
 require "oauth2"
 
-module SchwabRb::Auth
-  def self.init_client_token_file(api_key, app_secret, token_path, enforce_enums: true)
-    oauth = OAuth2::Client.new(
-      api_key,
-      app_secret,
-      site: SchwabRb::Constants::SCHWAB_BASE_URL,
-      token_url: "/v1/oauth/token"
-    )
+module SchwabRb
+  module Auth
+    def self.init_client_token_file(api_key, app_secret, token_path, enforce_enums: true)
+      oauth = OAuth2::Client.new(
+        api_key,
+        app_secret,
+        site: SchwabRb::Constants::SCHWAB_BASE_URL,
+        token_url: "/v1/oauth/token"
+      )
 
-    metadata_manager = SchwabRb::Auth::TokenManager.from_file(token_path)
-    token = metadata_manager.token
+      metadata_manager = SchwabRb::Auth::TokenManager.from_file(token_path)
+      token = metadata_manager.token
 
-    session = OAuth2::AccessToken.new(
-      oauth,
-      token.token,
-      refresh_token: token.refresh_token,
-      expires_at: token.expires_at
-    )
+      session = OAuth2::AccessToken.new(
+        oauth,
+        token.token,
+        refresh_token: token.refresh_token,
+        expires_at: token.expires_at
+      )
 
-    SchwabRb::Client.new(
-      api_key,
-      app_secret,
-      session,
-      token_manager: metadata_manager,
-      enforce_enums: enforce_enums
-    )
+      SchwabRb::Client.new(
+        api_key,
+        app_secret,
+        session,
+        token_manager: metadata_manager,
+        enforce_enums: enforce_enums
+      )
+    end
   end
 end

data/lib/schwab_rb/auth/login_flow_server.rb

@@ -1,55 +1,58 @@
+# frozen_string_literal: true
+
 require "sinatra"
 require "puma"
-require "thread"
 
-module SchwabRb::Auth
-  class LoginFlowServer < Sinatra::Base
-    class << self
-      attr_accessor :queue
-    end
+module SchwabRb
+  module Auth
+    class LoginFlowServer < Sinatra::Base
+      class << self
+        attr_accessor :queue
+      end
 
-    self.queue = Queue.new
+      self.queue = Queue.new
 
-    disable :logging
+      disable :logging
 
-    get "/status" do
-      "running"
-    end
+      get "/status" do
+        "running"
+      end
 
-    def self.create_routes(root_path)
-      get root_path do
-        self.class.queue.push(request.url)
-        "Callback received! You may now close this window/tab."
+      def self.create_routes(root_path)
+        get root_path do
+          self.class.queue.push(request.url)
+          "Callback received! You may now close this window/tab."
+        end
       end
-    end
 
-    def self.run_in_thread(callback_port: 4567, callback_path: "/", cert_file: nil, key_file: nil)
-      create_routes(callback_path)
+      def self.run_in_thread(callback_port: 4567, callback_path: "/", cert_file: nil, key_file: nil)
+        create_routes(callback_path)
 
-      thread = Thread.new do
-        set :server, "puma"
-        set :port, callback_port
-        set :bind, "127.0.0.1"
+        thread = Thread.new do
+          set :server, "puma"
+          set :port, callback_port
+          set :bind, "127.0.0.1"
 
-        ctx = Puma::MiniSSL::Context.new.tap do |ctx|
-          ctx.key = key_file.path
-          ctx.cert = cert_file.path
-          ctx.verify_mode = Puma::MiniSSL::VERIFY_NONE
-        end
+          ctx = Puma::MiniSSL::Context.new.tap do |ctx|
+            ctx.key = key_file.path
+            ctx.cert = cert_file.path
+            ctx.verify_mode = Puma::MiniSSL::VERIFY_NONE
+          end
 
-        puts ctx.inspect
+          puts ctx.inspect
 
-        Puma::Server.new(self).tap do |server|
-          server.add_ssl_listener("127.0.0.1", callback_port, ctx)
-          server.run
+          Puma::Server.new(self).tap do |server|
+            server.add_ssl_listener("127.0.0.1", callback_port, ctx)
+            server.run
+          end
         end
+        sleep 0.5
+        thread
       end
-      sleep 0.5
-      thread
-    end
 
-    def self.stop
-      Thread.list.each { |t| t.exit if t != Thread.main }
+      def self.stop
+        Thread.list.each { |t| t.exit if t != Thread.main }
+      end
     end
   end
 end