plex_ruby_sdk 0.8.1 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf3067a10347445724f3a5df1fc48c14e5ca0816e712b9f368e6bccac6cfc9e2
-  data.tar.gz: 878ce677d32082acefa11d54b24c0dcf6f93f8550bbaa87f6ca4e4aa6237a08f
+  metadata.gz: a5bad48f1f904e3a98d87694956684b027a45e4b4c515d6b172cfcb8c870f0d1
+  data.tar.gz: d64332ba8c2ca8eeb440b85c647e0ea1dffb927cf72e884aa63f8bd53748d6c8
 SHA512:
-  metadata.gz: d0e4e861fe59f6432aa7c6fdd5270ee7f9c2e00258af2f1d8db023c7f05c0ead2f060a1ec926828263dae2711be25e0b6717109f096afe93e968441462939ce8
-  data.tar.gz: 579c5b9be0c52f9a981d0e875ac673e1e6e70b6f2b3cac47aa6e6998f3b5e07d5bb8424cac60f81a6045ca5411e6b17cc7f5b605b96162812bf698c1758faba6
+  metadata.gz: 2d8d2cda546ae93a538f44a2ccfe86075cbb44d477d1b8b75cb593fea42c60a0a21527dc8ffdbeca79b68610fd866cc786b1f734ae0a9805d4637f255436b8a4
+  data.tar.gz: 668965cafbfb35d3ecc856e8d749b9bf45f068161d9d45390e5ce93a72f651eb5eda89619883f80d439e15edd5ab8e1b9bf299bc6ba9b0201003a8165d63152c

data/lib/crystalline/metadata_fields.rb

@@ -38,7 +38,7 @@ module Crystalline
       end
 
       def unmarshal_single(field_type, value, decoder = nil)
-        if field_type.instance_of?(Class) && field_type < ::Crystalline::FieldAugmented
+        if field_type.instance_of?(Class) && field_type.include?(::Crystalline::MetadataFields)
           unmarshalled = field_type.from_dict(value)
           return unmarshalled
         elsif field_type.to_s == 'Object'
@@ -57,7 +57,7 @@ module Crystalline
         end
       end
 
-      sig { params(json_obj: T.any(String, T::Hash[Symbol, String])).returns(::Crystalline::FieldAugmented) }
+      sig { params(json_obj: T.any(String, T::Hash[Symbol, String])).returns(Object) }
       def from_json(json_obj)
         begin
           d = JSON.parse(json_obj)
@@ -67,7 +67,7 @@ module Crystalline
         from_dict(d)
       end
 
-      sig { params(d: T::Hash[Symbol, String]).returns(::Crystalline::FieldAugmented) }
+      sig { params(d: T::Hash[Symbol, String]).returns(Object) }
       def from_dict(d)
         to_build = new
 
@@ -80,6 +80,10 @@ module Crystalline
           key = "#{field.name}="
           lookup = field.metadata.fetch(:format_json, {}).fetch(:letter_case, nil).call
           value = d[lookup]
+          
+          # If field is not nilable, and the value is not in the dict, raise a KeyError
+          raise KeyError, "key #{lookup} not found in hash" if value.nil? && !T.nilable?(field.type)
+          # If field is nilable, and the value is not in the dict, just move to the next field
           next if value.nil?
 
           if T.arr? field_type
@@ -93,12 +97,41 @@ module Crystalline
             unmarshalled_hash = value.map { |k, v| [k, unmarshal_single(val_type, v)] }.to_h
             # rubocop:enable Style/HashTransformValues
             to_build.send(key, unmarshalled_hash)
+          elsif T.union? field_type
+            discriminator = field.metadata.fetch(:discriminator, nil)
+            if !discriminator.nil?
+              type_to_deserialize = value.fetch(discriminator)
+              type_to_deserialize = T.get_union_types(field_type).find { |t| t.name.split('::').last == type_to_deserialize }              
+              unmarshalled_val = Crystalline.unmarshal_json(value, type_to_deserialize)
+              to_build.send(key, unmarshalled_val)
+            else
+              union_types = T.get_union_types(field_type)
+              union_types = union_types.sort_by { |klass| Crystalline.non_nilable_attr_count(klass) }
+
+              union_types.each do |union_type|
+                begin
+                  unmarshalled_val = Crystalline.unmarshal_json(value, union_type)
+                  to_build.send(key, unmarshalled_val)
+                rescue TypeError
+                  next
+                rescue NoMethodError
+                  next
+                rescue KeyError
+                  next
+                end
+                break
+              end
+            end
+          elsif field_type.instance_of?(Class) && field_type.include?(::Crystalline::MetadataFields)
+            unmarshalled = Crystalline.unmarshal_json(value, field_type)
+            to_build.send(key, unmarshalled)
           else
             decoder = field.metadata.fetch(:format_json, {}).fetch(:decoder, nil)
             final_value = unmarshal_single(field_type, value, decoder)
             to_build.send(key, final_value)
           end
         end
+
         to_build
       end
     end
@@ -124,7 +157,7 @@ module Crystalline
     end
 
     def marshal_single(field)
-      if field.is_a? ::Crystalline::FieldAugmented
+      if field.class.include? ::Crystalline::MetadataFields
         field.to_dict
       else
         ::Crystalline.val_to_string(field, primitives: false)

data/lib/crystalline/t.rb

@@ -27,11 +27,17 @@ module T
   end
 
   def self.nilable?(t)
-    t.respond_to? :unwrap_nilable
+    # in sorbet all `T.any` types provide unwrap_nilable for some reason
+    # So, in order to make this check more robust, we check if the type responds to the `types` method, and if so, whether
+    # one of those types is NilClass.  For non-nilable unions, `types` will return a valid list that does not include NilClass
+    return false unless t.respond_to?(:unwrap_nilable)
+    return true unless t.respond_to?(:types)
+    t.types.map { |tt| simplify_type(tt) }.include?(NilClass)
   end
 
   def self.nilable_of(t)
-    if t.respond_to? :unwrap_nilable
+    
+    if nilable t
       return simplify_type t.unwrap_nilable
     end
     nil
@@ -48,6 +54,19 @@ module T
     t
   end
 
+    
+  def self.union?(t)
+    return false unless t.respond_to? :types
+    return false if t.types.any? { |tt| get_raw_type(tt) == TrueClass }
+    return false if t.types.length == 2 && t.types.any? { |tt| get_raw_type(tt) == NilClass }
+    t.types.length > 1
+  end
+
+  def self.get_union_types(t)
+    t.types.map { |tt| get_raw_type(tt) }
+  end
+
+
   def self.get_raw_type(t)
     if t.respond_to? :raw_type
       return t.raw_type

data/lib/crystalline/utils.rb

@@ -8,30 +8,21 @@ require 'sorbet-runtime'
 module Crystalline
   extend T::Sig
 
-  class FieldAugmented
-    include MetadataFields
-  end
-
   sig { params(complex: Object).returns(Object) }
-  def self.marshal_dict_complex(complex)
+  def self.to_dict(complex)
     if complex.is_a? Array
-      complex.map { |v| Crystalline.marshal_dict_complex(v) }
+      complex.map { |v| Crystalline.to_dict(v) }
     elsif complex.is_a? Hash
-      complex.transform_values { |v| Crystalline.marshal_dict_complex(v) }
-    elsif complex.is_a? Crystalline::FieldAugmented
+      complex.transform_values { |v| Crystalline.to_dict(v) }
+    elsif complex.respond_to?(:class) && complex.class.include?(::Crystalline::MetadataFields)
       complex.to_dict
     else
-      complex
+      val_to_string complex, primitives: false
     end
   end
 
-  def self.marshal_json_complex(complex)
-    JSON.dump(marshal_dict_complex(complex))
-  end
-
-  sig { params(data: Object, type: Object).returns(Object) }
-  def self.unmarshal_complex(data, type)
-    unmarshal_json(data, type)
+  def self.to_json(complex)
+    JSON.dump(to_dict(complex))
   end
 
   sig { params(data: Object, type: Object).returns(Object) }
@@ -39,12 +30,12 @@ module Crystalline
     if T.simplifiable? type
       type = T.simplify_type type
     end
-    if type.instance_of?(Class) && type < ::Crystalline::FieldAugmented
+    if type.instance_of?(Class) && type.include?(::Crystalline::MetadataFields)
       type.from_dict(data)
     elsif T.arr? type
-      data.map { |v| Crystalline.unmarshal_complex(v, T.arr_of(type)) }
+      data.map { |v| Crystalline.unmarshal_json(v, T.arr_of(type)) }
     elsif T.hash? type
-      data.transform_values { |v| Crystalline.unmarshal_complex(v, T.hash_of(type)) }
+      data.transform_values { |v| Crystalline.unmarshal_json(v, T.hash_of(type)) }
     else
       data
     end
@@ -62,4 +53,25 @@ module Crystalline
       val
     end
   end
+
+  sig { params(klass: T.any(Class, T::Types::TypedArray, T::Types::TypedHash)).returns(Integer) }
+  def self.non_nilable_attr_count(klass)
+    # somewhat sane sort ordering for Union deserialization.
+    # All Crystalline objects return the number of non-nilable fields
+    # All non-string primitives return 2
+    # All arrays and hashes return 1
+    # Strings return 0 (since any data can deserialize to a string, it should be our last attempt)
+    if klass.respond_to? :fields
+      return -1 * klass.fields.count do |field|
+        !T.nilable? field.type
+      end
+    else
+      if klass == String
+        return 0
+      elsif klass.is_a?(T::Types::TypedArray) || klass.is_a?(T::Types::TypedHash)
+        return 1
+      end
+      return 2
+    end
+  end
 end

data/lib/plex_ruby_sdk/activities.rb

@@ -29,7 +29,7 @@ module PlexRubySDK
     end
 
 
-    sig { params(timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::GetServerActivitiesResponse) }
+    sig { params(timeout_ms: T.nilable(Integer)).returns(Models::Operations::GetServerActivitiesResponse) }
     def get_server_activities(timeout_ms = nil)
       # get_server_activities - Get Server Activities
       # Get Server Activities
@@ -49,16 +49,17 @@ module PlexRubySDK
 
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
-        oauth2_scopes: nil,
+        oauth2_scopes: [],
         operation_id: 'getServerActivities',
         security_source: @sdk_configuration.security_source
       )
 
       error = T.let(nil, T.nilable(StandardError))
-      r = T.let(nil, T.nilable(Faraday::Response))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+      
       
       begin
-        r = connection.get(url) do |req|
+        http_response = connection.get(url) do |req|
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
@@ -73,67 +74,101 @@ module PlexRubySDK
       rescue StandardError => e
         error = e
       ensure
-        if r.nil? || Utils.error_status?(r.status)
-          r = @sdk_configuration.hooks.after_error(
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
             error: error,
             hook_ctx: SDKHooks::AfterErrorHookContext.new(
               hook_ctx: hook_ctx
             ),
-            response: r
+            response: http_response
           )
         else
-          r = @sdk_configuration.hooks.after_success(
+          http_response = @sdk_configuration.hooks.after_success(
             hook_ctx: SDKHooks::AfterSuccessHookContext.new(
               hook_ctx: hook_ctx
             ),
-            response: r
+            response: http_response
           )
         end
         
-        if r.nil?
+        if http_response.nil?
           raise error if !error.nil?
           raise 'no response'
         end
       end
-
-      content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
-
-      res = ::PlexRubySDK::Operations::GetServerActivitiesResponse.new(
-        status_code: r.status, content_type: content_type, raw_response: r
-      )
-      if r.status == 200
+      
+      content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
+      if Utils.match_status_code(http_response.status, ['200'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetServerActivitiesResponseBody)
-          res.object = out
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Operations::GetServerActivitiesResponseBody)
+          response = Models::Operations::GetServerActivitiesResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            object: obj
+          )
+
+          return response
+        else
+          raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
         end
-      elsif r.status == 400
+      elsif Utils.match_status_code(http_response.status, ['400'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetServerActivitiesBadRequest)
-          res.bad_request = out
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetServerActivitiesBadRequest)
+          obj.raw_response = http_response
+          throw obj
+        else
+          raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
         end
-      elsif r.status == 401
+      elsif Utils.match_status_code(http_response.status, ['401'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::GetServerActivitiesUnauthorized)
-          res.unauthorized = out
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::GetServerActivitiesUnauthorized)
+          obj.raw_response = http_response
+          throw obj
+        else
+          raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
         end
-      end
+      elsif Utils.match_status_code(http_response.status, ['4XX'])
+        raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['5XX'])
+        raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      else
+        raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown status code received'
 
-      res
+      end
     end
 
 
-    sig { params(activity_uuid: ::String, timeout_ms: T.nilable(Integer)).returns(::PlexRubySDK::Operations::CancelServerActivitiesResponse) }
+    sig { params(activity_uuid: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::CancelServerActivitiesResponse) }
     def cancel_server_activities(activity_uuid, timeout_ms = nil)
       # cancel_server_activities - Cancel Server Activities
       # Cancel Server Activities
-      request = ::PlexRubySDK::Operations::CancelServerActivitiesRequest.new(
+      request = Models::Operations::CancelServerActivitiesRequest.new(
         
         activity_uuid: activity_uuid
       )
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        ::PlexRubySDK::Operations::CancelServerActivitiesRequest,
+        Models::Operations::CancelServerActivitiesRequest,
         base_url,
         '/activities/{activityUUID}',
         request
@@ -151,16 +186,17 @@ module PlexRubySDK
 
       hook_ctx = SDKHooks::HookContext.new(
         base_url: base_url,
-        oauth2_scopes: nil,
+        oauth2_scopes: [],
         operation_id: 'cancelServerActivities',
         security_source: @sdk_configuration.security_source
       )
 
       error = T.let(nil, T.nilable(StandardError))
-      r = T.let(nil, T.nilable(Faraday::Response))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+      
       
       begin
-        r = connection.delete(url) do |req|
+        http_response = connection.delete(url) do |req|
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
@@ -175,48 +211,78 @@ module PlexRubySDK
       rescue StandardError => e
         error = e
       ensure
-        if r.nil? || Utils.error_status?(r.status)
-          r = @sdk_configuration.hooks.after_error(
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
             error: error,
             hook_ctx: SDKHooks::AfterErrorHookContext.new(
               hook_ctx: hook_ctx
             ),
-            response: r
+            response: http_response
           )
         else
-          r = @sdk_configuration.hooks.after_success(
+          http_response = @sdk_configuration.hooks.after_success(
             hook_ctx: SDKHooks::AfterSuccessHookContext.new(
               hook_ctx: hook_ctx
             ),
-            response: r
+            response: http_response
           )
         end
         
-        if r.nil?
+        if http_response.nil?
           raise error if !error.nil?
           raise 'no response'
         end
       end
-
-      content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
-
-      res = ::PlexRubySDK::Operations::CancelServerActivitiesResponse.new(
-        status_code: r.status, content_type: content_type, raw_response: r
-      )
-      if r.status == 200
-      elsif r.status == 400
+      
+      content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
+      if Utils.match_status_code(http_response.status, ['200'])
+        http_response = @sdk_configuration.hooks.after_success(
+          hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+            hook_ctx: hook_ctx
+          ),
+          response: http_response
+        )
+        return Models::Operations::CancelServerActivitiesResponse.new(
+          status_code: http_response.status,
+          content_type: content_type,
+          raw_response: http_response
+        )
+      elsif Utils.match_status_code(http_response.status, ['400'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::CancelServerActivitiesBadRequest)
-          res.bad_request = out
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::CancelServerActivitiesBadRequest)
+          obj.raw_response = http_response
+          throw obj
+        else
+          raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
         end
-      elsif r.status == 401
+      elsif Utils.match_status_code(http_response.status, ['401'])
         if Utils.match_content_type(content_type, 'application/json')
-          out = Crystalline.unmarshal_json(JSON.parse(r.env.response_body), ::PlexRubySDK::Operations::CancelServerActivitiesUnauthorized)
-          res.unauthorized = out
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = Crystalline.unmarshal_json(JSON.parse(http_response.env.response_body), Models::Errors::CancelServerActivitiesUnauthorized)
+          obj.raw_response = http_response
+          throw obj
+        else
+          raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
         end
-      end
+      elsif Utils.match_status_code(http_response.status, ['4XX'])
+        raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['5XX'])
+        raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      else
+        raise ::PlexRubySDK::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown status code received'
 
-      res
+      end
     end
   end
 end