RubyHttpClient: Add authorization by session_id

lib/src/test/resources/example-response-with-unit-type.txt

@@ -212,7 +212,8 @@ module Io
             Preconditions.assert_class('auth', auth, HttpClient::Authorization)
             Preconditions.check_state(@auth.nil?, "auth previously set")
 
-            if auth.scheme.name == AuthScheme::BASIC.name
+            case auth.scheme.name
+            when AuthScheme::BASIC.name, AuthScheme::SESSION.name
               @auth = auth
             else
               raise "Auth Scheme[#{auth.scheme.name}] not supported"
@@ -272,8 +273,8 @@ module Io
             Preconditions.assert_class('klass', klass, Class)
 
             uri = @full_uri.dup
-            if q = to_query(@params)
-              uri += "?%s" % q
+            if (q = to_query(@params))
+              uri += "?#{q}"
             end
 
             request = klass.send(:new, uri)
@@ -294,9 +295,14 @@ module Io
               # DEBUG curl << "-u \"%s:%s\"" % [@auth.username, @auth.password]
               Preconditions.check_state(!@header_keys_lower_case.include?("authorization"),
                                         "Cannot specify both an Authorization header and an auth instance")
-              user_pass = "%s:%s" % [@auth.username, @auth.password]
-              encoded = Base64.encode64(user_pass).to_s.split("\n").map(&:strip).join
-              request.add_field("Authorization", "Basic %s" % encoded)
+              session_id = @auth.session_id.to_s.strip
+              if session_id.length > 0
+                request.add_field("Authorization", "Session #{session_id}")
+              else
+                user_pass = "#{@auth.username}:#{@auth.password}"
+                encoded = Base64.encode64(user_pass).to_s.split("\n").map(&:strip).join
+                request.add_field("Authorization", "Basic #{encoded}")
+              end
             end
 
             @headers.each { |key, value|
@@ -464,32 +470,39 @@ module Io
         end
 
         class AuthScheme
-
           attr_reader :name
 
           def initialize(name)
             @name = HttpClient::Preconditions.check_not_blank('name', name)
           end
 
           BASIC = AuthScheme.new("basic") unless defined?(BASIC)
-
+          SESSION = AuthScheme.new("session") unless defined?(SESSION)
         end
 
         class Authorization
+          attr_reader :scheme, :username, :password, :session_id
 
-          attr_reader :scheme, :username, :password
-
-          def initialize(scheme, username, opts={})
+          def initialize(scheme, username = nil, opts = {})
             @scheme = HttpClient::Preconditions.assert_class('schema', scheme, AuthScheme)
-            @username = HttpClient::Preconditions.check_not_blank('username', username, "username is required")
-            @password = HttpClient::Preconditions.assert_class_or_nil('password', opts.delete(:password), String)
+
+            if scheme.name == AuthScheme::BASIC.name
+              @username = HttpClient::Preconditions.check_not_blank('username', username, "username is required")
+              @password = HttpClient::Preconditions.assert_class_or_nil('password', opts.delete(:password), String)
+            elsif scheme.name == AuthScheme::SESSION.name
+              @session_id = HttpClient::Preconditions.assert_class_or_nil('session_id', opts.delete(:session_id), String)
+            end
+
             HttpClient::Preconditions.assert_empty_opts(opts)
           end
 
           def Authorization.basic(username, password=nil)
             Authorization.new(AuthScheme::BASIC, username, :password => password)
           end
 
+          def Authorization.session(session_id)
+            Authorization.new(AuthScheme::SESSION, nil, :session_id => session_id)
+          end
         end
 
         module Helper
@@ -566,4 +579,4 @@ module Io
       end
     end
   end
-end
+end

lib/src/test/resources/example-union-types-ruby-client.txt

@@ -489,7 +489,8 @@ module Io
                   Preconditions.assert_class('auth', auth, HttpClient::Authorization)
                   Preconditions.check_state(@auth.nil?, "auth previously set")
 
-                  if auth.scheme.name == AuthScheme::BASIC.name
+                  case auth.scheme.name
+                  when AuthScheme::BASIC.name, AuthScheme::SESSION.name
                     @auth = auth
                   else
                     raise "Auth Scheme[#{auth.scheme.name}] not supported"
@@ -549,8 +550,8 @@ module Io
                   Preconditions.assert_class('klass', klass, Class)
 
                   uri = @full_uri.dup
-                  if q = to_query(@params)
-                    uri += "?%s" % q
+                  if (q = to_query(@params))
+                    uri += "?#{q}"
                   end
 
                   request = klass.send(:new, uri)
@@ -571,9 +572,14 @@ module Io
                     # DEBUG curl << "-u \"%s:%s\"" % [@auth.username, @auth.password]
                     Preconditions.check_state(!@header_keys_lower_case.include?("authorization"),
                                               "Cannot specify both an Authorization header and an auth instance")
-                    user_pass = "%s:%s" % [@auth.username, @auth.password]
-                    encoded = Base64.encode64(user_pass).to_s.split("\n").map(&:strip).join
-                    request.add_field("Authorization", "Basic %s" % encoded)
+                    session_id = @auth.session_id.to_s.strip
+                    if session_id.length > 0
+                      request.add_field("Authorization", "Session #{session_id}")
+                    else
+                      user_pass = "#{@auth.username}:#{@auth.password}"
+                      encoded = Base64.encode64(user_pass).to_s.split("\n").map(&:strip).join
+                      request.add_field("Authorization", "Basic #{encoded}")
+                    end
                   end
 
                   @headers.each { |key, value|
@@ -741,32 +747,39 @@ module Io
               end
 
               class AuthScheme
-
                 attr_reader :name
 
                 def initialize(name)
                   @name = HttpClient::Preconditions.check_not_blank('name', name)
                 end
 
                 BASIC = AuthScheme.new("basic") unless defined?(BASIC)
-
+                SESSION = AuthScheme.new("session") unless defined?(SESSION)
               end
 
               class Authorization
+                attr_reader :scheme, :username, :password, :session_id
 
-                attr_reader :scheme, :username, :password
-
-                def initialize(scheme, username, opts={})
+                def initialize(scheme, username = nil, opts = {})
                   @scheme = HttpClient::Preconditions.assert_class('schema', scheme, AuthScheme)
-                  @username = HttpClient::Preconditions.check_not_blank('username', username, "username is required")
-                  @password = HttpClient::Preconditions.assert_class_or_nil('password', opts.delete(:password), String)
+
+                  if scheme.name == AuthScheme::BASIC.name
+                    @username = HttpClient::Preconditions.check_not_blank('username', username, "username is required")
+                    @password = HttpClient::Preconditions.assert_class_or_nil('password', opts.delete(:password), String)
+                  elsif scheme.name == AuthScheme::SESSION.name
+                    @session_id = HttpClient::Preconditions.assert_class_or_nil('session_id', opts.delete(:session_id), String)
+                  end
+
                   HttpClient::Preconditions.assert_empty_opts(opts)
                 end
 
                 def Authorization.basic(username, password=nil)
                   Authorization.new(AuthScheme::BASIC, username, :password => password)
                 end
 
+                def Authorization.session(session_id)
+                  Authorization.new(AuthScheme::SESSION, nil, :session_id => session_id)
+                end
               end
 
               module Helper
@@ -846,4 +859,4 @@ module Io
       end
     end
   end
-end
+end

lib/src/test/resources/generators/ruby-built-in-types.txt

@@ -417,7 +417,8 @@ module Apibuilder
         Preconditions.assert_class('auth', auth, HttpClient::Authorization)
         Preconditions.check_state(@auth.nil?, "auth previously set")
 
-        if auth.scheme.name == AuthScheme::BASIC.name
+        case auth.scheme.name
+        when AuthScheme::BASIC.name, AuthScheme::SESSION.name
           @auth = auth
         else
           raise "Auth Scheme[#{auth.scheme.name}] not supported"
@@ -477,8 +478,8 @@ module Apibuilder
         Preconditions.assert_class('klass', klass, Class)
 
         uri = @full_uri.dup
-        if q = to_query(@params)
-          uri += "?%s" % q
+        if (q = to_query(@params))
+          uri += "?#{q}"
         end
 
         request = klass.send(:new, uri)
@@ -499,9 +500,14 @@ module Apibuilder
           # DEBUG curl << "-u \"%s:%s\"" % [@auth.username, @auth.password]
           Preconditions.check_state(!@header_keys_lower_case.include?("authorization"),
                                     "Cannot specify both an Authorization header and an auth instance")
-          user_pass = "%s:%s" % [@auth.username, @auth.password]
-          encoded = Base64.encode64(user_pass).to_s.split("\n").map(&:strip).join
-          request.add_field("Authorization", "Basic %s" % encoded)
+          session_id = @auth.session_id.to_s.strip
+          if session_id.length > 0
+            request.add_field("Authorization", "Session #{session_id}")
+          else
+            user_pass = "#{@auth.username}:#{@auth.password}"
+            encoded = Base64.encode64(user_pass).to_s.split("\n").map(&:strip).join
+            request.add_field("Authorization", "Basic #{encoded}")
+          end
         end
 
         @headers.each { |key, value|
@@ -669,32 +675,39 @@ module Apibuilder
     end
 
     class AuthScheme
-
       attr_reader :name
 
       def initialize(name)
         @name = HttpClient::Preconditions.check_not_blank('name', name)
       end
 
       BASIC = AuthScheme.new("basic") unless defined?(BASIC)
-
+      SESSION = AuthScheme.new("session") unless defined?(SESSION)
     end
 
     class Authorization
+      attr_reader :scheme, :username, :password, :session_id
 
-      attr_reader :scheme, :username, :password
-
-      def initialize(scheme, username, opts={})
+      def initialize(scheme, username = nil, opts = {})
         @scheme = HttpClient::Preconditions.assert_class('schema', scheme, AuthScheme)
-        @username = HttpClient::Preconditions.check_not_blank('username', username, "username is required")
-        @password = HttpClient::Preconditions.assert_class_or_nil('password', opts.delete(:password), String)
+
+        if scheme.name == AuthScheme::BASIC.name
+          @username = HttpClient::Preconditions.check_not_blank('username', username, "username is required")
+          @password = HttpClient::Preconditions.assert_class_or_nil('password', opts.delete(:password), String)
+        elsif scheme.name == AuthScheme::SESSION.name
+          @session_id = HttpClient::Preconditions.assert_class_or_nil('session_id', opts.delete(:session_id), String)
+        end
+
         HttpClient::Preconditions.assert_empty_opts(opts)
       end
 
       def Authorization.basic(username, password=nil)
         Authorization.new(AuthScheme::BASIC, username, :password => password)
       end
 
+      def Authorization.session(session_id)
+        Authorization.new(AuthScheme::SESSION, nil, :session_id => session_id)
+      end
     end
 
     module Helper
@@ -769,4 +782,4 @@ module Apibuilder
     end
 
   end
-end
+end

lib/src/test/resources/ruby-client-generator-gilt-0.0.1-test.txt

@@ -666,7 +666,8 @@ module Io
                 Preconditions.assert_class('auth', auth, HttpClient::Authorization)
                 Preconditions.check_state(@auth.nil?, "auth previously set")
 
-                if auth.scheme.name == AuthScheme::BASIC.name
+                case auth.scheme.name
+                when AuthScheme::BASIC.name, AuthScheme::SESSION.name
                   @auth = auth
                 else
                   raise "Auth Scheme[#{auth.scheme.name}] not supported"
@@ -726,8 +727,8 @@ module Io
                 Preconditions.assert_class('klass', klass, Class)
 
                 uri = @full_uri.dup
-                if q = to_query(@params)
-                  uri += "?%s" % q
+                if (q = to_query(@params))
+                  uri += "?#{q}"
                 end
 
                 request = klass.send(:new, uri)
@@ -748,9 +749,14 @@ module Io
                   # DEBUG curl << "-u \"%s:%s\"" % [@auth.username, @auth.password]
                   Preconditions.check_state(!@header_keys_lower_case.include?("authorization"),
                                             "Cannot specify both an Authorization header and an auth instance")
-                  user_pass = "%s:%s" % [@auth.username, @auth.password]
-                  encoded = Base64.encode64(user_pass).to_s.split("\n").map(&:strip).join
-                  request.add_field("Authorization", "Basic %s" % encoded)
+                  session_id = @auth.session_id.to_s.strip
+                  if session_id.length > 0
+                    request.add_field("Authorization", "Session #{session_id}")
+                  else
+                    user_pass = "#{@auth.username}:#{@auth.password}"
+                    encoded = Base64.encode64(user_pass).to_s.split("\n").map(&:strip).join
+                    request.add_field("Authorization", "Basic #{encoded}")
+                  end
                 end
 
                 @headers.each { |key, value|
@@ -918,32 +924,39 @@ module Io
             end
 
             class AuthScheme
-
               attr_reader :name
 
               def initialize(name)
                 @name = HttpClient::Preconditions.check_not_blank('name', name)
               end
 
               BASIC = AuthScheme.new("basic") unless defined?(BASIC)
-
+              SESSION = AuthScheme.new("session") unless defined?(SESSION)
             end
 
             class Authorization
+              attr_reader :scheme, :username, :password, :session_id
 
-              attr_reader :scheme, :username, :password
-
-              def initialize(scheme, username, opts={})
+              def initialize(scheme, username = nil, opts = {})
                 @scheme = HttpClient::Preconditions.assert_class('schema', scheme, AuthScheme)
-                @username = HttpClient::Preconditions.check_not_blank('username', username, "username is required")
-                @password = HttpClient::Preconditions.assert_class_or_nil('password', opts.delete(:password), String)
+
+                if scheme.name == AuthScheme::BASIC.name
+                  @username = HttpClient::Preconditions.check_not_blank('username', username, "username is required")
+                  @password = HttpClient::Preconditions.assert_class_or_nil('password', opts.delete(:password), String)
+                elsif scheme.name == AuthScheme::SESSION.name
+                  @session_id = HttpClient::Preconditions.assert_class_or_nil('session_id', opts.delete(:session_id), String)
+                end
+
                 HttpClient::Preconditions.assert_empty_opts(opts)
               end
 
               def Authorization.basic(username, password=nil)
                 Authorization.new(AuthScheme::BASIC, username, :password => password)
               end
 
+              def Authorization.session(session_id)
+                Authorization.new(AuthScheme::SESSION, nil, :session_id => session_id)
+              end
             end
 
             module Helper
@@ -1022,4 +1035,4 @@ module Io
       end
     end
   end
-end
+end