shotgun_api_ruby 0.0.8.4 → 0.1.0.1

data/bin/prettirun

@@ -0,0 +1 @@
+yarn prettier -c './**/*.rb'

data/bin/ruborun

@@ -0,0 +1 @@
+bundle exec rubocop -P

data/lib/shotgun_api_ruby/auth.rb

@@ -1,20 +1,33 @@
 # frozen_string_literal: true
 
 module ShotgunApiRuby
+  # Faraday middleware responsible for authentication with
+  # the shotgun site
   class Auth < Faraday::Middleware
+    # Validate auth parameters format
     module Validator
-      def self.valid?(auth)
-        (auth[:client_id] && auth[:client_secret]) ||
-          (auth[:password] && auth[:username]) ||
-          auth[:session_token] ||
-          auth[:refresh_token]
+      # Validate auth parameters format
+      #
+      # @param []
+      def self.valid?(
+        client_id: nil,
+        client_secret: nil,
+        username: nil,
+        password: nil,
+        session_token: nil,
+        refresh_token: nil
+      )
+        (client_id && client_secret) || (password && username) ||
+          session_token || refresh_token
       end
     end
 
     def initialize(app = nil, options = {})
-      raise "missing auth" unless options[:auth]
-      raise "missing site_url" unless options[:site_url]
-      raise "Auth not valid" unless Validator.valid?(options[:auth])
+      raise 'missing auth' unless options[:auth]
+      raise 'missing site_url' unless options[:site_url]
+      unless Validator.valid?(**options[:auth]&.transform_keys(&:to_sym))
+        raise 'Auth not valid'
+      end
 
       super(app)
 
@@ -27,19 +40,25 @@ module ShotgunApiRuby
       @refresh_token = options[:auth][:refresh_token]
     end
 
-    attr_reader :client_id, :client_secret, :site_url, :username, :password, :session_token, :refresh_token
+    attr_reader :client_id,
+                :client_secret,
+                :site_url,
+                :username,
+                :password,
+                :session_token,
+                :refresh_token
 
     def auth_type
       @auth_type ||=
         begin
-          if client_id
+          if refresh_token
+            'refresh_token'
+          elsif client_id
             'client_credentials'
           elsif username
             'password'
           elsif session_token
             'session_token'
-          elsif refresh_token
-            'refresh_token'
           end
         end
     end
@@ -56,16 +75,18 @@ module ShotgunApiRuby
       @auth_params ||=
         begin
           case auth_type
+          when 'refresh_token'
+            "refresh_token=#{refresh_token}&grant_type=refresh_token"
           when 'client_credentials'
-            "client_id=#{client_id}&client_secret=#{client_secret}&grant_type=client_credentials"
+            "client_id=#{client_id}&client_secret=#{
+              client_secret
+            }&grant_type=client_credentials"
           when 'password'
             "username=#{username}&password=#{password}&grant_type=password"
           when 'session_token'
             "session_token=#{session_token}&grant_type=session_token"
-          when 'refresh_token'
-            "refresh_token=#{refresh_token}&grant_type=refresh_token"
           else
-            raise "Not a valid/implemented auth type"
+            raise 'Not a valid/implemented auth type'
           end
         end
     end
@@ -81,8 +102,8 @@ module ShotgunApiRuby
     def sign_in
       resp =
         Faraday.post(auth_url) do |req|
-          req.headers["Content-Type"] = 'application/x-www-form-urlencoded'
-          req.headers["Accept"] = "application/json"
+          req.headers['Content-Type'] = 'application/x-www-form-urlencoded'
+          req.headers['Accept'] = 'application/json'
         end
       resp_body = JSON.parse(resp.body)
 
@@ -95,8 +116,8 @@ module ShotgunApiRuby
 
     def std_headers
       {
-        "Accept" => "application/json",
-        "Authorization" => "Bearer #{access_token}",
+        'Accept' => 'application/json',
+        'Authorization' => "Bearer #{access_token}",
       }
     end
   end

data/lib/shotgun_api_ruby/client.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
 module ShotgunApiRuby
+  # Main class for connection.
+  #
+  # This should be only instanciated once to re-use tokens
   class Client
+    # Faraday connection
     attr_reader :connection
 
     def initialize(auth:, site_url: nil, shotgun_site: nil)
-      raise "No site given" unless site_url || shotgun_site
-      raise "auth param not valid" unless auth && Auth::Validator.valid?(auth)
+      raise 'No site given' unless site_url || shotgun_site
+      raise 'auth param not valid' unless auth && Auth::Validator.valid?(**auth)
 
       site_url ||= "https://#{shotgun_site}.shotgunstudio.com/api/v1"
       @connection =
@@ -16,14 +20,17 @@ module ShotgunApiRuby
         end
     end
 
+    # Access preferences APIs
     def preferences
       @preferences = Preferences.new(connection)
     end
 
+    # Access server_info APIs
     def server_info
       @server_info || ServerInfo.new(connection)
     end
 
+    # Access entities related APIs
     def entities(type)
       public_send(type)
     end
@@ -34,16 +41,19 @@ module ShotgunApiRuby
 
     def method_missing(name, *args, &block)
       if args.empty?
-        name = formated_name(name)
-        define_singleton_method(name) do
-          if entities_client = instance_variable_get("@#{name}")
-            entities_client
-          else
-            entities_client = entities_aux(name)
-            instance_variable_set("@#{name}", entities_client)
+        fname = formated_name(name)
+        self
+          .class
+          .define_method(fname) do
+            if entities_client = instance_variable_get("@#{fname}")
+              entities_client
+            else
+              entities_client = entities_aux(fname)
+              instance_variable_set("@#{fname}", entities_client)
+            end
           end
-        end
-        send(name)
+        self.class.instance_eval { alias_method name, fname }
+        send(fname)
       else
         super
       end

data/lib/shotgun_api_ruby/entities.rb

@@ -26,7 +26,7 @@ module ShotgunApiRuby
         retired: retired,
         logical_operator: logical_operator,
         include_archived_projects: include_archived_projects,
-        page_size: 1
+        page_size: 1,
       ).first
     end
 
@@ -43,13 +43,13 @@ module ShotgunApiRuby
         raise "Error while getting #{type}: #{resp_body['errors']}"
       end
 
-      entity = resp_body["data"]
+      entity = resp_body['data']
       Entity.new(
         entity['type'],
         OpenStruct.new(entity['attributes']),
         entity['relationships'],
         entity['id'],
-        entity['links']
+        entity['links'],
       )
     end
 
@@ -62,16 +62,18 @@ module ShotgunApiRuby
       resp_body = JSON.parse(resp.body)
 
       if resp.status >= 300
-        raise "Error while creating #{type}# with #{attributes}: #{resp_body['errors']}"
+        raise "Error while creating #{type} with #{attributes}: #{
+                resp_body['errors']
+              }"
       end
 
-      entity = resp_body["data"]
+      entity = resp_body['data']
       Entity.new(
         entity['type'],
         OpenStruct.new(entity['attributes']),
         entity['relationships'],
         entity['id'],
-        entity['links']
+        entity['links'],
       )
     end
 
@@ -86,16 +88,18 @@ module ShotgunApiRuby
       resp_body = JSON.parse(resp.body)
 
       if resp.status >= 300
-        raise "Error while updating #{type}##{id} with #{changes}: #{resp_body['errors']}"
+        raise "Error while updating #{type}##{id} with #{changes}: #{
+                resp_body['errors']
+              }"
       end
 
-      entity = resp_body["data"]
+      entity = resp_body['data']
       Entity.new(
         entity['type'],
         OpenStruct.new(entity['attributes']),
         entity['relationships'],
         entity['id'],
-        entity['links']
+        entity['links'],
       )
     end
 
@@ -114,8 +118,7 @@ module ShotgunApiRuby
     end
 
     def revive(id)
-      resp =
-        @connection.post("#{id}?revive=true")
+      resp = @connection.post("#{id}?revive=true")
 
       if resp.status >= 300
         resp_body = JSON.parse(resp.body)
@@ -135,16 +138,18 @@ module ShotgunApiRuby
       retired: nil,
       include_archived_projects: nil
     )
-      if filter && !filters_are_simple?(filter)
-        return search(
-          fields: fields,
-          logical_operator: logical_operator,
-          sort: sort,
-          filter: filter,
-          page: page,
-          page_size: page_size,
-          retired: retired,
-          include_archived_projects: include_archived_projects
+      if filter && !Params.filters_are_simple?(filter)
+        return(
+          search(
+            fields: fields,
+            logical_operator: logical_operator,
+            sort: sort,
+            filter: filter,
+            page: page,
+            page_size: page_size,
+            retired: retired,
+            include_archived_projects: include_archived_projects,
+          )
         )
       end
 
@@ -163,13 +168,13 @@ module ShotgunApiRuby
         raise "Error while getting #{type}: #{resp_body['errors']}"
       end
 
-      resp_body["data"].map do |entity|
+      resp_body['data'].map do |entity|
         Entity.new(
           entity['type'],
           OpenStruct.new(entity['attributes']),
           entity['relationships'],
           entity['id'],
-          entity['links']
+          entity['links'],
         )
       end
     end
@@ -184,16 +189,18 @@ module ShotgunApiRuby
       retired: nil,
       include_archived_projects: nil
     )
-      if filter.nil? || filters_are_simple?(filter)
-        return all(
-          fields: fields,
-          logical_operator: logical_operator,
-          sort: sort,
-          filter: filter,
-          page: page,
-          page_size: page_size,
-          retired: retired,
-          include_archived_projects: include_archived_projects
+      if filter.nil? || Params.filters_are_simple?(filter)
+        return(
+          all(
+            fields: fields,
+            logical_operator: logical_operator,
+            sort: sort,
+            filter: filter,
+            page: page,
+            page_size: page_size,
+            retired: retired,
+            include_archived_projects: include_archived_projects,
+          )
         )
       end
       params = Params.new
@@ -202,25 +209,21 @@ module ShotgunApiRuby
       params.add_sort(sort)
       params.add_page(page, page_size)
       params.add_options(retired, include_archived_projects)
-      new_filter = {}
-      if filter.is_a?(Hash)
-        new_filter[:conditions] =
-          (filter[:conditions] || translate_complex_to_sg_filters(filter))
-        new_filter[:logical_operator] = filter[:logical_operator] || filter['logical_operator'] || logical_operator
-      else
-        new_filter[:conditions] = filter
-        new_filter[:logical_operator] = logical_operator
-      end
-      filter = new_filter
+      params.add_filter(filter, logical_operator)
+
+      # In search: The name is filters and not filter
+      params[:filters] = params[:filter]
+      params.delete(:filter)
 
       resp =
         @connection.post('_search', params) do |req|
-          if filter.is_a? Array
-            req.headers["Content-Type"] = 'application/vnd+shotgun.api3_array+json'
-          else
-            req.headers['Content-Type'] = 'application/vnd+shotgun.api3_hash+json'
-          end
-          req.body = params.to_h.merge(filters: filter).to_json
+          req.headers['Content-Type'] =
+            if params[:filters].is_a? Array
+              'application/vnd+shotgun.api3_array+json'
+            else
+              'application/vnd+shotgun.api3_hash+json'
+            end
+          req.body = params.to_h.to_json
         end
       resp_body = JSON.parse(resp.body)
 
@@ -228,13 +231,13 @@ module ShotgunApiRuby
         raise "Error while getting #{type}: #{resp_body['errors']}"
       end
 
-      resp_body["data"].map do |entity|
+      resp_body['data'].map do |entity|
         Entity.new(
           entity['type'],
           OpenStruct.new(entity['attributes']),
           entity['relationships'],
           entity['id'],
-          entity['links']
+          entity['links'],
         )
       end
     end
@@ -250,47 +253,5 @@ module ShotgunApiRuby
     def fields
       schema_client.fields
     end
-
-    private
-
-    def filters_are_simple?(filters)
-      return false if filters.is_a? Array
-
-      filters.values.all? do |filter_val|
-        (filter_val.is_a?(Integer) || filter_val.is_a?(String) || filter_val.is_a?(Symbol)) ||
-          (filter_val.is_a?(Array) && filter_val.all?{ |val|
-             val.is_a?(String) || val.is_a?(Symbol) || val.is_a?(Integer)
-           } )
-      end
-    end
-
-    def translate_complex_to_sg_filters(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, "is", value]
-        when Hash
-          value.each do |subfield, subvalue|
-            sanitized_subfield = "#{field.capitalize}.#{subfield}" unless subfield.to_s.include?(".")
-            case subvalue
-            when String, Symbol, Integer, Float
-              result << ["#{field}.#{sanitized_subfield}", "is", subvalue]
-            when Array
-              result << ["#{field}.#{sanitized_subfield}", "in", subvalue]
-            else
-              raise "This case is too complex to auto-translate. Please use shotgun query syntax."
-            end
-          end
-        when Array
-          result << [field, "in", value]
-        else
-          raise "This case is too complex to auto-translate. Please use shotgun query syntax."
-        end
-      end
-    end
   end
 end

data/lib/shotgun_api_ruby/entities/params.rb

@@ -3,12 +3,17 @@
 module ShotgunApiRuby
   class Entities
     class Params < Hash
+      class TooComplexFiltersError < StandardError
+      end
+
       def add_sort(sort)
         return unless sort
 
         self[:sort] =
           if sort.is_a?(Hash)
-            sort.map{ |field, direction| "#{direction.to_s.start_with?('desc') ? '-' : ''}#{field}" }.join(',')
+            sort.map do |field, direction|
+              "#{direction.to_s.start_with?('desc') ? '-' : ''}#{field}"
+            end.join(',')
           else
             [sort].flatten.join(',')
           end
@@ -26,11 +31,7 @@ module ShotgunApiRuby
 
       def add_fields(fields)
         self[:fields] =
-          if fields
-            [fields].flatten.join(',')
-          else
-            "*"
-          end
+          fields && !fields.empty? ? [fields].flatten.join(',') : '*'
       end
 
       def add_options(return_only, include_archived_projects)
@@ -42,16 +43,50 @@ module ShotgunApiRuby
         }
       end
 
-      def add_filter(filters)
+      def add_filter(filters, logical_operator = 'and')
         return unless filters
 
-        # filter
-        self['filter'] = translate_simple_filter_to_sg(filters)
+        self[:filter] =
+          if (self.class.filters_are_simple?(filters))
+            translate_simple_filters_to_sg(filters)
+          elsif filters.is_a? Hash
+            {
+              conditions:
+                filters[:conditions] || filters['conditions'] ||
+                  translate_complex_filters_to_sg(filters),
+              logical_operator:
+                filters[:logical_operator] || filters['logical_operator'] ||
+                  logical_operator,
+            }
+          else
+            { conditions: filters, logical_operator: logical_operator }
+          end
+      end
+
+      def self.filters_are_simple?(filters)
+        return false if filters.is_a? Array
+
+        if filters.is_a?(Hash) &&
+             (filters[:conditions] || filters['conditions'])
+          return false
+        end
+
+        filters.values.all? do |filter_val|
+          (
+            filter_val.is_a?(Integer) || filter_val.is_a?(String) ||
+              filter_val.is_a?(Symbol)
+          ) ||
+            (
+              filter_val.is_a?(Array) && filter_val.all? do |val|
+                val.is_a?(String) || val.is_a?(Symbol) || val.is_a?(Integer)
+              end
+            )
+        end
       end
 
       private
 
-      def translate_simple_filter_to_sg(filters)
+      def translate_simple_filters_to_sg(filters)
         filters.map do |field, value|
           [
             field.to_s,
@@ -59,6 +94,44 @@ module ShotgunApiRuby
           ]
         end.to_h
       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]
+                else
+                  raise TooComplexFiltersError,
+                        'This case is too complex to auto-translate. Please use shotgun query syntax.'
+                end
+              end
+            when Array
+              result << [field.to_s, 'in', value]
+            else
+              raise TooComplexFiltersError,
+                    'This case is too complex to auto-translate. Please use shotgun query syntax.'
+            end
+          end
+      end
     end
   end
 end