setsuzoku 0.11.9 → 0.12.54

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd0ca4436f63ee80c7411553690acc0600a3556842acda30c580767de4d5fefe
-  data.tar.gz: 9cdf81df738bc16aef812b6cc5f68cb7e26b5a3a1666dcbf214a79ac16e22f28
+  metadata.gz: 857309120b1ecb005579a95179f305d1417d77e182acc418728a64a919ba1f93
+  data.tar.gz: b7b1a9fba79dd2f32ac74bf983f162b3bd13bb1be4f9fc0643243b4ac56579d9
 SHA512:
-  metadata.gz: 888f8ee20d1bc364d6a0b9ddd54ab2cdeb8c9e54078ea5bc36ef5193fac5d75ee7310492c55493fa4e6dae2975103b31e087ca6f23557bca2d52f22622d5a700
-  data.tar.gz: a07a89413cae6b20f159eec21cd37f90e73e80d8ee8b1d0522f5186b71aa587483145c29deaff231337a805fb5291ba3c45e17a364cab37e0123890982ffd218
+  metadata.gz: 9c521ea84fa6d60a44b86122bdb0e73c877959f7d8bda535cf203225e15b87d38c84d81746b254237d7c808e5edf1deeb82dae1f6b98eca605bcdbf624bb8f75
+  data.tar.gz: 9029a6b9ffcbcc339bd9f98f483b22ecec5dfa13475222f59c497155da09d3ee4d78be006993958f0f8853ce7dc9fc704c9822e59d5c8263eaaba8d1ba621810

data/Gemfile.lock

@@ -1,10 +1,9 @@
 PATH
   remote: .
   specs:
-    setsuzoku (0.11.9)
+    setsuzoku (0.12.54)
       activesupport (~> 5.0)
       faraday (~> 0.11)
-      httparty (~> 0.16.4)
       nokogiri (~> 1.10)
       sorbet-runtime (~> 0.5)
 
@@ -18,26 +17,19 @@ GEM
       tzinfo (~> 1.1)
     addressable (2.7.0)
       public_suffix (>= 2.0.2, < 5.0)
-    concurrent-ruby (1.1.6)
+    concurrent-ruby (1.1.7)
     crack (0.4.3)
       safe_yaml (~> 1.0.0)
     diff-lcs (1.4.2)
     faraday (0.17.3)
       multipart-post (>= 1.2, < 3)
     hashdiff (1.0.1)
-    httparty (0.16.4)
-      mime-types (~> 3.0)
-      multi_xml (>= 0.5.2)
-    i18n (1.8.3)
+    i18n (1.8.5)
       concurrent-ruby (~> 1.0)
-    mime-types (3.3.1)
-      mime-types-data (~> 3.2015)
-    mime-types-data (3.2020.0512)
     mini_portile2 (2.4.0)
     minitest (5.14.1)
-    multi_xml (0.6.0)
     multipart-post (2.1.1)
-    nokogiri (1.10.9)
+    nokogiri (1.10.10)
       mini_portile2 (~> 2.4.0)
     public_suffix (4.0.5)
     rake (10.5.0)
@@ -57,7 +49,7 @@ GEM
     safe_yaml (1.0.5)
     sorbet (0.5.5675)
       sorbet-static (= 0.5.5675)
-    sorbet-runtime (0.5.5878)
+    sorbet-runtime (0.5.5881)
     sorbet-static (0.5.5675-universal-darwin-14)
     thread_safe (0.3.6)
     tzinfo (1.2.7)

data/lib/setsuzoku.rb

@@ -1,7 +1,6 @@
 # typed: true
 
 require 'faraday'
-require 'httparty'
 require 'nokogiri'
 require 'sorbet-runtime'
 require 'active_support'
@@ -10,6 +9,7 @@ require 'active_support'
 module Setsuzoku
 
   autoload :ApiResponse, 'setsuzoku/api_response'
+  autoload :HasConfigContext, 'setsuzoku/has_config_context'
   autoload :ApiStrategy, 'setsuzoku/api_strategy'
   autoload :AuthStrategy, 'setsuzoku/auth_strategy'
   autoload :Credential, 'setsuzoku/credential'
@@ -18,7 +18,6 @@ module Setsuzoku
   autoload :Pluggable, 'setsuzoku/pluggable'
   autoload :Service, 'setsuzoku/service' #needs to load before plugin
   autoload :Plugin, 'setsuzoku/plugin'
-  autoload :Utilities, 'setsuzoku/utilities'
   autoload :VERSION, 'setsuzoku/version'
 
   @@external_api_handler = ExternalApiHandler

data/lib/setsuzoku/api_strategy.rb

@@ -1,4 +1,4 @@
-# typed: false
+# typed: ignore
 # frozen_string_literal: true
 
 module Setsuzoku
@@ -7,10 +7,12 @@ module Setsuzoku
   #
   # Defines all necessary methods for handling interfacing with an external API/Service for any authentication strategy.
   module ApiStrategy
-
     extend Forwardable
     extend T::Sig
     extend T::Helpers
+
+    include HasConfigContext
+
     abstract!
 
     attr_accessor :current_action
@@ -35,8 +37,8 @@ module Setsuzoku
       ))
     end
     def initialize(service:, **args)
-      #TODO: here we need to assign credentials etc, I think.
       self.service = service
+      self.config_context = args
       self
     end
 
@@ -71,7 +73,7 @@ module Setsuzoku
       exception = T.let(nil, T.nilable(Setsuzoku::Exception))
       action_details = case strategy
                        when :auth
-                         { actions: self.plugin.auth_actions, url: self.plugin.auth_base_url }
+                         { actions: self.auth_strategy.credential.auth_actions, url: self.auth_strategy.credential.auth_base_url }
                        when :webhook
                          { actions: self.plugin.api_actions, url: self.plugin.webhook_base_url }
                        else

data/lib/setsuzoku/auth_strategy.rb

@@ -1,4 +1,4 @@
-# typed: false
+# typed: ignore
 # frozen_string_literal: true
 
 module Setsuzoku
@@ -7,21 +7,20 @@ module Setsuzoku
   #
   # Defines all necessary methods for handling authentication for any authentication strategy.
   module AuthStrategy
-
     extend Forwardable
     extend T::Sig
     extend T::Helpers
+
+    include HasConfigContext
+
     abstract!
 
     attr_accessor :service
     attr_accessor :credential
     def_delegators :@service, :plugin, :api_strategy, :external_api_handler
 
-    # Initialize the auth_strategy and provide reference to service.
-    #
-    # @param service [Service] the new instance of service with its correct strategies.
     #
-    # @return [AuthStrategy] the new instance of auth_strategy
+    # initialize
     sig(:final) do
       params(
           service: T.any(
@@ -31,19 +30,20 @@ module Setsuzoku
           args: T.untyped
       ).returns(T.any(
           Setsuzoku::Service::WebService::AuthStrategies::BasicAuthStrategy,
+          Setsuzoku::Service::WebService::AuthStrategies::CustomAuthStrategy,
           Setsuzoku::Service::WebService::AuthStrategies::OAuthStrategy,
           T.untyped
       ))
     end
-
+    # Initialize the auth_strategy and provide reference to service.
+    #
+    # @param service [Service] the new instance of service with its correct strategies.
+    #
+    # @return [AuthStrategy] the new instance of auth_strategy
     def initialize(service:, **args)
       self.service = service
-      credential = args[:credential]
-      self.credential = if self.plugin.registered_instance
-                          credential
-                        else
-                          self.class.credential_class.stub_credential
-                        end
+      self.set_credential!(self.class.credential_class.stub_credential) unless self.plugin.registered_instance
+      self.config_context = args
       self
     end
 
@@ -55,11 +55,25 @@ module Setsuzoku
       self.plugin.get_registered_instance_val(@credential)
     end
 
+    #
+    # set_credential!
+    sig { params(credential: T.untyped).void }
+    #
+    # Assign the credential to the auth_strategy.
+    #
+    # @return [void]
+    def set_credential!(credential)
+      if credential
+        self.credential = credential
+        credential.auth_strategy = self
+      end
+    end
+
     # Check if a credential is valid.
     # Additionally it should revalidate if invalid.
     #
     # @return [Boolean] true if the credential is valid.
-    sig { abstract.returns(T::Boolean) }
+    sig { returns(T::Boolean) }
     def auth_credential_valid?; end
 
     # Authorize a credential for a specific auth_strategy.

data/lib/setsuzoku/credential.rb

@@ -6,8 +6,18 @@ module Setsuzoku
   module Credential
     extend T::Sig
     extend T::Helpers
+    extend Forwardable
     interface!
 
+    attr_accessor :auth_strategy
+    def_delegators :@auth_strategy, :plugin
+
+    # All auth actions that are implemented.
+    #
+    # @return [Hash] all auth endpoint definitions for the API.
+    sig { abstract.returns(T::Hash[T.untyped, T.untyped]) }
+    def auth_actions; end
+
     # Create a stub implementation of the credential for testing purposes
     #
     # @return [Struct] a struct that implements stubbed version of a credential's required methods.

data/lib/setsuzoku/has_config_context.rb

@@ -0,0 +1,27 @@
+# typed: false
+# frozen_string_literal: true
+
+module Setsuzoku
+  # Set of methods/functionality for managing a classes config_context
+  module HasConfigContext
+    extend T::Sig
+    extend T::Helpers
+
+    attr_accessor :config_context
+
+    #
+    # get_from_context
+    sig { params(method: Symbol).returns(T.untyped) }
+    #
+    # Retrieve a value from config_context or call the default method implementation for the class.
+    #
+    # @return [Any] the value of the key in config_context, or return value of the method.
+    def get_from_context(method)
+      if self.config_context.key?(method)
+        self.get_registered_instance_val(method)
+      else
+        self.send(method) if self.respond_to?(method)
+      end
+    end
+  end
+end

data/lib/setsuzoku/pluggable.rb

@@ -64,10 +64,12 @@ module Setsuzoku
       sig(:final) { params(options: T.untyped).void }
       def register_plugin(**options)
         options[:plugin_class].config_context[:required_instance_methods].each do |req_method|
-
-          unless options[:required_instance_methods].key?(req_method)
-            raise Setsuzoku::Exception::UndefinedRequiredMethod.new(registering_instance: self, plugin_class: options[:plugin_class], method_name: req_method)
-          end
+          next if options[:required_instance_methods].key?(req_method)
+          raise Setsuzoku::Exception::UndefinedRequiredMethod.new(
+              registering_instance: self,
+              plugin_class: options[:plugin_class],
+              method_name: req_method
+          )
         end
 
         self.plugin_context = self.default_options.merge(options)

data/lib/setsuzoku/plugin.rb

@@ -18,7 +18,7 @@ module Setsuzoku
     attr_accessor :registered_instance
     attr_accessor :service
     attr_accessor :config_context
-    def_delegators :@service, :auth_strategy, :api_strategy, :exception_handler, :call_external_api, :request_class, :new_credential!
+    def_delegators :@service, :auth_strategy, :api_strategy, :exception_handler, :call_external_api, :request_class, :new_credential!, :set_credential!
 
     alias :plugin_service :service
     alias :plugin_request_class :request_class

data/lib/setsuzoku/rspec/dynamic_spec_helper.rb

@@ -1,4 +1,4 @@
-# typed: false
+# typed: ignore
 
 require 'active_support/core_ext/class/subclasses'
 require 'active_support/inflector/methods'
@@ -153,11 +153,12 @@ module Setsuzoku
           props.each do |propz|
             plugin.api_strategy.current_action = action_name
             default_headers = plugin.api_strategy.request_options(propz[:request_format])[:headers] || { 'Content-Type' => "application/#{propz[:request_format]}" }
+            auth_headers = plugin.auth_strategy.auth_headers || {}
             if plugin.auth_strategy.is_a?(Setsuzoku::Service::WebService::AuthStrategies::BasicAuthStrategy)
-              basic_auth = plugin.api_strategy.request_options(propz[:request_format])[:basic_auth]
+              basic_auth = auth_headers[:authorization][:basic_auth]
               auth_header = { 'Authorization' => "Basic #{Base64.encode64("#{basic_auth[:username]}:#{basic_auth[:password]}").gsub("\n", '')}" }
             elsif plugin.auth_strategy.is_a?(Setsuzoku::Service::WebService::AuthStrategies::OAuthStrategy)
-              auth_header = { 'Authorization' => "Bearer #{plugin.api_strategy.request_options(propz[:request_format])[:token]}" }
+              auth_header = { 'Authorization' => "Bearer #{auth_headers[:authorization][:token]}" }
             end
             default_headers.merge!(auth_header) if auth_header
             headers = propz[:headers] ? [propz[:headers]] : [default_headers]

data/lib/setsuzoku/service.rb

@@ -17,7 +17,7 @@ module Setsuzoku
     attr_accessor :auth_strategy
     attr_accessor :api_strategy
     attr_accessor :external_api_handler
-    def_delegators :@auth_strategy, :new_credential!
+    def_delegators :@auth_strategy, :new_credential!, :set_credential!
     def_delegators :@api_strategy, :call_external_api, :request_class
 
     def self.included(klass)

data/lib/setsuzoku/service/web_service.rb

@@ -6,10 +6,14 @@ require 'setsuzoku/service/web_service/auth_strategy'
 require 'setsuzoku/service/web_service/service'
 require 'setsuzoku/service/web_service/api_strategies/rest_strategy'
 require 'setsuzoku/service/web_service/api_strategies/rest_api_request'
-require 'setsuzoku/service/web_service/auth_strategies/o_auth_strategy'
+require 'setsuzoku/service/web_service/auth_strategies/strategy_can_use_tokens'
 require 'setsuzoku/service/web_service/auth_strategies/basic_auth_strategy'
-require 'setsuzoku/service/web_service/credentials/o_auth_credential'
+require 'setsuzoku/service/web_service/auth_strategies/custom_auth_strategy'
+require 'setsuzoku/service/web_service/auth_strategies/o_auth_strategy'
+require 'setsuzoku/service/web_service/credentials/uses_credential_token'
 require 'setsuzoku/service/web_service/credentials/basic_auth_credential'
+require 'setsuzoku/service/web_service/credentials/custom_auth_credential'
+require 'setsuzoku/service/web_service/credentials/o_auth_credential'
 
 module Setsuzoku
   module Service

data/lib/setsuzoku/service/web_service/api_strategies/rest_strategy.rb

@@ -1,4 +1,4 @@
-# typed: false
+# typed: ignore
 # frozen_string_literal: true
 
 require 'active_support/json'
@@ -31,35 +31,46 @@ module Setsuzoku
           # @param options [Any] additional options needed to pass to correctly perform the request.
           # options are:
           #   media_type - 'json'
+          #   attachment_url_key - 'Symbol' the form field to post the attachment in the form.
+          #   attachment_urls - 'Array<String>' List of attachment urls to be attached as form files.
           #
           # @return [Hash] the parsed response object.
           sig { override.params(request: RestAPIRequest, action_details: T::Hash[T.untyped, T.untyped], options: T.untyped).returns(Faraday::Response) }
           def perform_external_call(request:, action_details:, **options)
             request_properties = self.get_request_properties(action_name: request.action, action_details: action_details, req_params: request.body)
             request_options = self.request_options(request_properties[:request_format], action_details[:actions][request.action])
-
+            authorization = request_options.delete(:authorization)
             full_request = self.formulate_request(request_properties, request_options)
 
             @faraday = Faraday.new(url: request_properties[:formatted_full_url], request: { params_encoder: Faraday::FlatParamsEncoder }) do |faraday|
-              faraday.request(:multipart) if options[:attachments].present?
+              faraday.request(:multipart) if options[:attachment_urls].present?
               faraday.request(:url_encoded)
               #TODO: change these to faraday = self.auth_strategy.set_authorization!(request: faraday)
               unless request.without_headers
-                if request_options[:token]
-                  faraday.authorization(:Bearer, request_options[:token])
-                elsif request_options[:basic_auth]
-                  faraday.request(:basic_auth, request_options[:basic_auth][:username], request_options[:basic_auth][:password])
+                if authorization
+                  if authorization.key?(:token)
+                    faraday.authorization(:Bearer, authorization[:token])
+                  elsif authorization.key?(:basic_auth)
+                    faraday.request(:basic_auth, authorization[:basic_auth][:username], authorization[:basic_auth][:password])
+                  end
                 end
               end
               faraday.adapter Faraday.default_adapter
             end
 
-            if options[:attachments].present?
+            if options[:attachment_urls].present?
               resp = @faraday.post do |req|
-                io = StringIO.new(full_request)
                 payload = {}
-                payload[:json] = Faraday::UploadIO.new(io, 'application/json')
-                payload[:attachment] = options[:attachments].map{ |file| Faraday::UploadIO.new(file[0], file[1], file[2]) }
+                attachments = options[:attachment_urls].map do |url|
+                  image = open(url, 'rb')
+                  Faraday::UploadIO.new(image, T.must(image).content_type, File.basename(url))
+                end
+                payload[options[:attachment_url_key]] = attachments
+                if request_properties[:request_format] == :json
+                  payload[:json] = Faraday::UploadIO.new(StringIO.new(full_request), 'application/json')
+                else
+                  payload.merge!(full_request)
+                end
                 req.body = payload
               end
             else
@@ -110,26 +121,34 @@ module Setsuzoku
           # @return full_request [Hash/String] returns the request body in the format required
           def formulate_request(request_properties = {}, request_options = {})
             request_format = request_properties.dig(:request_format).to_s
+            params = request_properties[:req_params].merge(request_options.except(:headers))
 
             if request_properties[:request_method] == :get || request_properties[:req_params].empty?
-              request_properties[:req_params]
+              params
             else
               # if the header or request format include urlencoded return the body as a hash
               if request_format.include?('urlencoded')
-                request_properties[:req_params]
+                params
               else
                 # return either xml or json
                 if request_properties[:request_format] == :xml
-                  convert_hash_to_xml(request_properties[:req_params])
+                  convert_hash_to_xml(params)
                 else
-                  request_properties[:req_params].to_json
+                  params.to_json
                 end
               end
             end
           end
 
           def request_options(request_format = nil, action_details = {})
-            request_options = self.auth_strategy.auth_headers.merge(self.plugin.api_headers).merge(action_details[:request_options] || {})
+            request_options = {}
+            (request_options = {})[:headers] = {}
+            request_options[:headers]
+              .merge!(self.auth_strategy.get_from_context(:auth_headers).except(:authorization))
+              .merge!(self.get_from_context(:api_headers))
+              .merge!(action_details[:request_options] || {})
+            request_options[:authorization] = self.auth_strategy.get_from_context(:auth_headers)[:authorization]
+
             content_type = case request_format
                            when :json
                              'application/json'

data/lib/setsuzoku/service/web_service/api_strategy.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: ignore
 # frozen_string_literal: true
 
 module Setsuzoku
@@ -35,12 +35,6 @@ module Setsuzoku
           sig { abstract.returns(T::Hash[T.untyped, T.untyped]) }
           def api_actions; end
 
-          # Any api request headers that this service needs to set.
-          #
-          # @return [Hash]
-          sig { abstract.returns(T::Hash[Symbol, T.untyped]) }
-          def api_headers; end
-
           # All dynamic url parameters provided by the plugin.
           #
           # @return [Hash(String)] all parameters that need to be replaced dynamically for url requests.
@@ -48,6 +42,17 @@ module Setsuzoku
           def dynamic_url_params; end
         end
 
+        #
+        # api_headers
+        sig { overridable.returns(T::Hash[Symbol, T.untyped]) }
+        #
+        # Specific API headers an API strategy must have when making requests.
+        #
+        # @return [Hash] the additional required headers for a request.
+        def api_headers
+          {}
+        end
+
         # Perform the external call for the external API.
         # Each WebService::ApiStrategy must define how this works.
         #
@@ -68,7 +73,7 @@ module Setsuzoku
         # Parse the response from the API for the given request.
         # This should just convert JSON strings/XML/SQL rows to a formatted response Hash.
         #
-        # @param response [HTTParty::Response] the response from the HTTP request.
+        # @param response [Faraday::Response] the response from the HTTP request.
         # @param options [Hash] the parsing options. Generally the response_type. e.g. :xml, :json
         #
         # @return [Hash] the parsed hash of the response object.