shotgrid_api_ruby 0.1.3 → 0.2.0.1

data/lib/shotgrid_api_ruby/entities/params.rb

@@ -1,15 +1,38 @@
+# typed: strict
 # frozen_string_literal: true
 
 module ShotgridApiRuby
   class Entities
-    class Params < Hash
+    class Params
+      extend T::Sig
+      extend Forwardable
+
       class TooComplexFiltersError < StandardError
       end
 
+      sig { void }
+      def initialize
+        @parsed_params = T.let({}, T::Hash[T.any(String, Symbol), T.untyped])
+      end
+
+      def_delegators :@parsed_params, :[], :[]=, :delete, :to_h, :each
+
+      SORT_TYPE =
+        T.type_alias do
+          T.nilable(
+            T.any(
+              T::Hash[T.any(String, Symbol), T.any(String, Symbol)],
+              T::Array[T.any(String, Symbol)],
+              String,
+              Symbol,
+            ),
+          )
+        end
+      sig { params(sort: SORT_TYPE).returns(T.nilable(String)) }
       def add_sort(sort)
         return unless sort
 
-        self[:sort] =
+        @parsed_params[:sort] =
           if sort.is_a?(Hash)
             sort
               .map do |field, direction|
@@ -21,6 +44,13 @@ module ShotgridApiRuby
           end
       end
 
+      PAGE_TYPE = T.type_alias { T.nilable(T.any(String, Integer)) }
+      PAGE_SIZE_TYPE = T.type_alias { T.nilable(T.any(String, Integer)) }
+
+      sig do
+        params(page: PAGE_TYPE, page_size: PAGE_SIZE_TYPE)
+          .returns(T.nilable(T::Hash[T.untyped, T.untyped]))
+      end
       def add_page(page, page_size)
         return unless page || page_size
 
@@ -28,95 +58,252 @@ module ShotgridApiRuby
         page_size = page_size.to_i if page_size
 
         page = 1 if page && page < 1
-        self[:page] = { size: page_size || 20, number: page || 1 }
+        @parsed_params[:page] = { size: page_size || 20, number: page || 1 }
       end
 
+      FIELDS_TYPE =
+        T.type_alias do
+          T.nilable(T.any(String, Symbol, T::Array[T.any(String, Symbol)]))
+        end
+      sig { params(fields: FIELDS_TYPE).returns(String) }
       def add_fields(fields)
-        self[:fields] =
+        @parsed_params[:fields] =
           fields && !fields.empty? ? [fields].flatten.join(',') : '*'
       end
 
+      sig do
+        params(
+            return_only: T.nilable(T::Boolean),
+            include_archived_projects: T.nilable(T::Boolean),
+          )
+          .returns(
+            T.nilable(
+              { return_only: String, include_archived_projects: T::Boolean },
+            ),
+          )
+      end
       def add_options(return_only, include_archived_projects)
         return if return_only.nil? && include_archived_projects.nil?
 
-        self[:options] = {
+        @parsed_params[:options] = {
           return_only: return_only ? 'retired' : 'active',
           include_archived_projects: !!include_archived_projects,
         }
       end
 
+      LOGICAL_OPERATOR_TYPE = T.type_alias { T.any(String, Symbol) }
+      FILTERS_FIELD_TYPE =
+        T.type_alias do
+          T.nilable(
+            T.any(
+              T::Array[T.untyped],
+              T::Hash[
+                T.any(String, Symbol),
+                T.any(
+                  String,
+                  Symbol,
+                  Integer,
+                  Float,
+                  T::Array[T.any(String, Symbol, Integer, Float)],
+                  T::Hash[
+                    T.any(String, Symbol),
+                    T.any(
+                      String,
+                      Symbol,
+                      Integer,
+                      Float,
+                      T::Array[T.any(String, Symbol, Integer, Float)],
+                      T.untyped,
+                    )
+                  ],
+                  T.untyped,
+                )
+              ],
+              T::Hash[
+                T.any(String, Symbol),
+                T.any(
+                  String,
+                  Symbol,
+                  Integer,
+                  Float,
+                  T::Array[T.any(String, Symbol, Integer, Float)],
+                )
+              ],
+            ),
+          )
+        end
+      sig do
+        params(
+            filters: FILTERS_FIELD_TYPE,
+            logical_operator: LOGICAL_OPERATOR_TYPE,
+          )
+          .returns(
+            T.nilable(
+              T.any(
+                T::Hash[String, String],
+                {
+                  conditions:
+                    T.any(
+                      T::Array[T.any(String, Symbol, Integer, Float)],
+                      T::Array[T.untyped],
+                    ),
+                  logical_operator: String,
+                },
+              ),
+            ),
+          )
+      end
       def add_filter(filters, logical_operator = 'and')
         return unless filters
 
-        self[:filter] =
+        # cast are here because Sorbet is confused by the madness filters can be
+        @parsed_params[:filter] =
           if (self.class.filters_are_simple?(filters))
-            translate_simple_filters_to_sg(filters)
+            translate_simple_filters_to_sg(
+              T.cast(
+                filters,
+                T::Hash[
+                  T.any(String, Symbol),
+                  T.any(
+                    String,
+                    Symbol,
+                    Integer,
+                    Float,
+                    T::Array[T.any(String, Symbol, Integer, Float)],
+                  )
+                ],
+              ),
+            )
           elsif filters.is_a? Hash
+            filters =
+              T.cast(
+                T.unsafe(filters),
+                T::Hash[
+                  T.any(String, Symbol),
+                  T.any(
+                    String,
+                    Symbol,
+                    Integer,
+                    Float,
+                    T::Array[T.any(String, Symbol, Integer, Float)],
+                    T::Hash[
+                      T.any(String, Symbol),
+                      T.any(
+                        String,
+                        Symbol,
+                        Integer,
+                        Float,
+                        T::Array[T.any(String, Symbol, Integer, Float)],
+                        T.untyped,
+                      )
+                    ],
+                    T.untyped,
+                  )
+                ],
+              )
             {
               conditions:
                 filters[:conditions] || filters['conditions'] ||
                   translate_complex_filters_to_sg(filters),
               logical_operator:
                 filters[:logical_operator] || filters['logical_operator'] ||
-                  logical_operator,
+                  logical_operator.to_s,
             }
           else
-            { conditions: filters, logical_operator: logical_operator }
+            { conditions: filters, logical_operator: logical_operator.to_s }
           end
       end
 
+      GROUPING_FIELD_TYPE =
+        T.type_alias do
+          T.nilable(
+            T.any(
+              T::Array[T::Array[T.any(String, Symbol)]],
+              T::Hash[
+                String,
+                T.any(
+                  String,
+                  Symbol,
+                  { type: String },
+                  { 'type' => String },
+                  { direction: String },
+                  { 'direction' => String },
+                  { type: String, direction: String },
+                  { :type => String, 'direction' => String },
+                  { 'type' => String, :direction => String },
+                  { 'type' => String, 'direction' => String },
+                )
+              ],
+            ),
+          )
+        end
+      sig { params(grouping: GROUPING_FIELD_TYPE).returns(T.untyped) }
       def add_grouping(grouping)
         return unless grouping
 
         if grouping.is_a? Array
-          self[:grouping] = grouping
+          @parsed_params[:grouping] = grouping
           return
         end
 
-        self[:grouping] =
-          grouping
-            .each
-            .with_object([]) do |(key, options), result|
-              if options.is_a? Hash
-                result << {
-                  field: key.to_s,
-                  type:
-                    options[:type]&.to_s || options['type']&.to_s || 'exact',
-                  direction:
-                    options[:direction]&.to_s || options['direction']&.to_s ||
-                      'asc',
-                }
-              else
-                result << {
-                  field: key.to_s,
-                  type: 'exact',
-                  direction: options.to_s,
-                }
-              end
+        @parsed_params[:grouping] =
+          grouping.each_with_object([]) do |(key, options), result|
+            if options.is_a? Hash
+              result << {
+                field: key.to_s,
+                type: options[:type]&.to_s || options['type']&.to_s || 'exact',
+                direction:
+                  options[:direction]&.to_s || options['direction']&.to_s ||
+                    'asc',
+              }
+            else
+              result << {
+                field: key.to_s,
+                type: 'exact',
+                direction: options.to_s,
+              }
             end
+          end
       end
 
+      SUMMARY_FILEDS_TYPE =
+        T.type_alias do
+          T.nilable(
+            T.any(
+              T::Array[
+                T::Hash[
+                  T.any(String, Symbol),
+                  T::Hash[T.any(String, Symbol), T.any(String, Symbol)]
+                ]
+              ],
+              T::Hash[T.any(String, Symbol), T.any(String, Symbol)],
+            ),
+          )
+        end
+      sig do
+        params(summary_fields: SUMMARY_FILEDS_TYPE)
+          .returns(T.nilable(T::Array[T::Hash[T.untyped, T.untyped]]))
+      end
       def add_summary_fields(summary_fields)
         return unless summary_fields
 
         if summary_fields.is_a? Array
-          self[:summary_fields] = summary_fields
+          @parsed_params[:summary_fields] = summary_fields
           return
         end
 
         if summary_fields.is_a? Hash
-          self[:summary_fields] =
+          @parsed_params[:summary_fields] =
             summary_fields.map { |k, v| { field: k.to_s, type: v.to_s } }
         end
       end
 
+      sig { params(filters: FILTERS_FIELD_TYPE).returns(T::Boolean) }
       def self.filters_are_simple?(filters)
+        return false unless filters
         return false if filters.is_a? Array
 
-        if filters.is_a?(Hash) &&
-             (filters[:conditions] || filters['conditions'])
-          return false
-        end
+        return false if filters[:conditions] || filters['conditions']
 
         filters.values.all? do |filter_val|
           (
@@ -134,6 +321,22 @@ module ShotgridApiRuby
 
       private
 
+      sig do
+        params(
+            filters:
+              T::Hash[
+                T.any(String, Symbol),
+                T.any(
+                  String,
+                  Symbol,
+                  Integer,
+                  Float,
+                  T::Array[T.any(String, Symbol, Integer, Float)],
+                )
+              ],
+          )
+          .returns(T::Hash[String, String])
+      end
       def translate_simple_filters_to_sg(filters)
         filters.map do |field, value|
           [
@@ -143,42 +346,78 @@ module ShotgridApiRuby
         end.to_h
       end
 
+      sig do
+        params(
+            filters:
+              T.any(
+                T::Array[T.untyped],
+                T::Hash[
+                  T.any(String, Symbol),
+                  T.any(
+                    String,
+                    Symbol,
+                    Integer,
+                    Float,
+                    T::Array[T.any(String, Symbol, Integer, Float)],
+                    T::Hash[
+                      T.any(String, Symbol),
+                      T.any(
+                        String,
+                        Symbol,
+                        Integer,
+                        Float,
+                        T::Array[T.any(String, Symbol, Integer, Float)],
+                        T.untyped,
+                      )
+                    ],
+                    T.untyped,
+                  )
+                ],
+              ),
+          )
+          .returns(
+            T::Array[
+              T.any(
+                T::Array[T.any(String, Symbol, Integer, Float)],
+                T::Array[T.untyped],
+              )
+            ],
+          )
+      end
       def translate_complex_filters_to_sg(filters)
         # We don't know how to translate anything but hashes
-        return filters if !filters.is_a?(Hash)
-
-        filters
-          .each
-          .with_object([]) do |item, result|
-            field, value = item
-            case value
-            when String, Symbol, Integer, Float
-              result << [field.to_s, 'is', value]
-            when Hash
-              value.each do |subfield, subvalue|
-                sanitized_subfield =
-                  if !subfield.to_s.include?('.')
-                    "#{field.capitalize}.#{subfield}"
-                  else
-                    subfield
-                  end
-                case subvalue
-                when String, Symbol, Integer, Float
-                  result << ["#{field}.#{sanitized_subfield}", 'is', subvalue]
-                when Array
-                  result << ["#{field}.#{sanitized_subfield}", 'in', subvalue]
+        return filters unless filters.is_a?(Hash)
+
+        filters.each_with_object([]) do |item, result|
+          field, value = item
+          case value
+          when String, Symbol, Integer, Float
+            result << [field.to_s, 'is', value]
+          when Hash
+            value.each do |subfield, subvalue|
+              sanitized_subfield =
+                if !subfield.to_s.include?('.')
+                  "#{field.capitalize}.#{subfield}"
                 else
-                  raise TooComplexFiltersError,
-                        'This case is too complex to auto-translate. Please use shotgrid query syntax.'
+                  subfield
                 end
+              case subvalue
+              when String, Symbol, Integer, Float
+                result << ["#{field}.#{sanitized_subfield}", 'is', subvalue]
+              when Array
+                result << ["#{field}.#{sanitized_subfield}", 'in', subvalue]
+              else
+                raise TooComplexFiltersError,
+                      'This case is too complex to auto-translate. Please use shotgrid query syntax.'
               end
-            when Array
-              result << [field.to_s, 'in', value]
-            else
-              raise TooComplexFiltersError,
-                    'This case is too complex to auto-translate. Please use shotgrid query syntax.'
             end
+          when Array
+            result << [field.to_s, 'in', value]
+          else
+            raise TooComplexFiltersError,
+                  'This case is too complex to auto-translate. Please use shotgrid query syntax.'
           end
+        end
       end
     end
   end

data/lib/shotgrid_api_ruby/entities/schema.rb

@@ -1,15 +1,29 @@
+# typed: strict
 # frozen_string_literal: true
 
 module ShotgridApiRuby
   class Entities
     class Schema
+      extend T::Sig
+
+      sig do
+        params(
+          connection: Faraday::Connection,
+          type: T.any(String, Symbol),
+          base_url_prefix: URI,
+        ).void
+      end
       def initialize(connection, type, base_url_prefix)
-        @connection = connection.dup
-        @type = type
+        @connection = T.let(connection.dup, Faraday::Connection)
+        @type = T.let(type, T.any(String, Symbol))
         @connection.url_prefix = "#{base_url_prefix}/schema/#{type}"
       end
-      attr_reader :type, :connection
+      sig { returns(T.any(String, Symbol)) }
+      attr_reader :type
+      sig { returns(Faraday::Connection) }
+      attr_reader :connection
 
+      sig { returns(OpenStruct) }
       def read
         resp = @connection.get('')
 
@@ -25,6 +39,7 @@ module ShotgridApiRuby
         OpenStruct.new(resp_body['data'].transform_values { |v| v['value'] })
       end
 
+      sig { returns(OpenStruct) }
       def fields
         resp = @connection.get('fields')
         resp_body = JSON.parse(resp.body)

data/lib/shotgrid_api_ruby/entities/summarize.rb

@@ -1,15 +1,37 @@
+# typed: strict
 module ShotgridApiRuby
   class Entities
     class Summarize
-      Summary = Struct.new(:summaries, :groups)
+      extend T::Sig
 
+      class Summary < T::Struct
+        const :summaries, T.nilable(T::Hash[T.untyped, T.untyped])
+        const :groups, T.nilable(T::Array[T.untyped])
+      end
+
+      sig do
+        params(
+          connection: Faraday::Connection,
+          type: T.any(String, Symbol),
+          base_url_prefix: URI,
+        ).void
+      end
       def initialize(connection, type, base_url_prefix)
-        @connection = connection.dup
-        @type = type
-        @connection.url_prefix = "#{base_url_prefix}/entity/#{type}/_summarize"
+        @connection = T.let(connection.dup, Faraday::Connection)
+        @type = T.let(type, T.any(String, Symbol))
+        @connection.url_prefix =
+          T.let("#{base_url_prefix}/entity/#{type}/_summarize", String)
       end
-      attr_reader :type, :connection
 
+      sig { returns(T.any(String, Symbol)) }
+      attr_reader :type
+      sig { returns(Faraday::Connection) }
+      attr_reader :connection
+
+      sig do
+        params(filter: T.nilable(T.untyped), logical_operator: T.untyped)
+          .returns(T.untyped)
+      end
       def count(filter: nil, logical_operator: 'and')
         result =
           summarize(
@@ -20,6 +42,16 @@ module ShotgridApiRuby
         result.summaries&.[]('id') || 0
       end
 
+      sig do
+        params(
+            filter: Params::FILTERS_FIELD_TYPE,
+            grouping: Params::GROUPING_FIELD_TYPE,
+            summary_fields: Params::SUMMARY_FILEDS_TYPE,
+            logical_operator: Params::LOGICAL_OPERATOR_TYPE,
+            include_archived_projects: T.nilable(T::Boolean),
+          )
+          .returns(Summary)
+      end
       def summarize(
         filter: nil,
         grouping: nil,
@@ -59,8 +91,8 @@ module ShotgridApiRuby
         end
 
         Summary.new(
-          resp_body['data']['summaries'],
-          resp_body['data']&.[]('groups'),
+          summaries: resp_body['data']['summaries'],
+          groups: resp_body['data']&.[]('groups'),
         )
       end
     end