ruby-lokalise-api 7.2.0 → 8.0.0.rc1

data/lib/ruby_lokalise_api/rest/team_user_groups.rb

@@ -3,106 +3,138 @@
 module RubyLokaliseApi
   module Rest
     module TeamUserGroups
-      # Returns all team user groups for the given team
+      using RubyLokaliseApi::Utils::Classes
+
+      # Returns team user groups
       #
-      # @see https://developers.lokalise.com/reference/list-all-team-users
-      # @return [RubyLokaliseApi::Collection::TeamUserGroup<RubyLokaliseApi::Resources::TeamUserGroup>]
-      # @param team_id [String]
-      # @param params [Hash]
-      def team_user_groups(team_id, params = {})
-        c_r RubyLokaliseApi::Collections::TeamUserGroup, :all, team_id, params
+      # @see https://developers.lokalise.com/reference/list-all-groups
+      # @return [RubyLokaliseApi::Collections::TeamUserGroups]
+      # @param team_id [Integer, String]
+      # @param req_params [Hash]
+      def team_user_groups(team_id, req_params = {})
+        name = 'TeamUserGroups'
+        params = { query: team_id, req: req_params }
+
+        data = endpoint(name: name, params: params).do_get
+
+        collection name, data
       end
 
-      # Returns team user from the given team
+      # Returns a single team user group
       #
-      # @see https://developers.lokalise.com/reference/retrieve-a-team-user
+      # @see https://developers.lokalise.com/reference/retrieve-a-group
       # @return [RubyLokaliseApi::Resources::TeamUserGroup]
-      # @param team_id [String]
+      # @param team_id [String, Integer]
       # @param group_id [String, Integer]
       def team_user_group(team_id, group_id)
-        c_r RubyLokaliseApi::Resources::TeamUserGroup, :find, [team_id, group_id]
+        params = { query: [team_id, group_id] }
+
+        response = endpoint(name: 'TeamUserGroups', params: params).do_get
+
+        resource 'TeamUserGroup', response
       end
 
-      # Creates team user group
+      # Creates a team user group
       #
       # @see https://developers.lokalise.com/reference/create-a-group
       # @return [RubyLokaliseApi::Resources::TeamUserGroup]
-      # @param params [Hash]
-      def create_team_user_group(team_id, params)
-        c_r RubyLokaliseApi::Resources::TeamUserGroup, :create, team_id, params
+      # @param team_id [String, Integer]
+      # @param req_params [Hash]
+      def create_team_user_group(team_id, req_params)
+        params = { query: team_id, req: req_params }
+
+        response = endpoint(name: 'TeamUserGroups', params: params).do_post
+
+        resource 'TeamUserGroup', response
       end
 
-      # Updates team user group for the given team
+      # Updates a team user group
       #
       # @see https://developers.lokalise.com/reference/update-a-group
       # @return [RubyLokaliseApi::Resources::TeamUserGroup]
-      # @param team_id [String]
+      # @param team_id [String, Integer]
       # @param group_id [String, Integer]
-      # @param params [Hash]
-      def update_team_user_group(team_id, group_id, params)
-        c_r RubyLokaliseApi::Resources::TeamUserGroup, :update, [team_id, group_id], params
+      # @param req_params [Hash]
+      def update_team_user_group(team_id, group_id, req_params = {})
+        params = { query: [team_id, group_id], req: req_params }
+
+        data = endpoint(name: 'TeamUserGroups', params: params).do_put
+
+        resource 'TeamUserGroup', data
       end
 
-      # Deletes team user group from the given team
+      # Deletes a team user group
       #
       # @see https://developers.lokalise.com/reference/delete-a-group
-      # @return [RubyLokaliseApi::Resources::TeamUserGroup]
-      # @param team_id [String]
+      # @return [RubyLokaliseApi::Generics::DeletedResource]
+      # @param team_id [String, Integer]
       # @param group_id [String, Integer]
       def destroy_team_user_group(team_id, group_id)
-        c_r RubyLokaliseApi::Resources::TeamUserGroup, :destroy, [team_id, group_id]
+        params = { query: [team_id, group_id] }
+
+        data = endpoint(name: 'TeamUserGroups', params: params).do_delete
+
+        RubyLokaliseApi::Generics::DeletedResource.new data.content
       end
 
-      # Adds projects to the given group
+      # Adds projects to the group
       #
       # @see https://developers.lokalise.com/reference/add-projects-to-group
       # @return [RubyLokaliseApi::Resources::TeamUserGroup]
-      # @param team_id [String]
+      # @param team_id [String, Integer]
       # @param group_id [String, Integer]
-      # @param project_ids [String, Integer, Array<String>, Array<Integer>]
+      # @param project_ids [Array, String]
       def add_projects_to_group(team_id, group_id, project_ids)
-        c_r RubyLokaliseApi::Resources::TeamUserGroup, :update,
-            [team_id, group_id, 'projects', 'add'],
-            project_ids, :projects, [team_id, group_id]
+        params = { query: [team_id, group_id, :projects, :add], req: project_ids.to_array_obj(:projects) }
+
+        data = endpoint(name: 'TeamUserGroups', params: params).do_put
+
+        resource 'TeamUserGroup', data
       end
 
-      # Removes projects from the given group
+      # Removes projects from the group
       #
       # @see https://developers.lokalise.com/reference/remove-projects-from-group
       # @return [RubyLokaliseApi::Resources::TeamUserGroup]
-      # @param team_id [String]
+      # @param team_id [String, Integer]
       # @param group_id [String, Integer]
-      # @param project_ids [String, Integer, Array<String>, Array<Integer>]
+      # @param project_ids [Array, String]
       def remove_projects_from_group(team_id, group_id, project_ids)
-        c_r RubyLokaliseApi::Resources::TeamUserGroup, :update,
-            [team_id, group_id, 'projects', 'remove'],
-            project_ids, :projects, [team_id, group_id]
+        params = { query: [team_id, group_id, :projects, :remove], req: project_ids.to_array_obj(:projects) }
+
+        data = endpoint(name: 'TeamUserGroups', params: params).do_put
+
+        resource 'TeamUserGroup', data
       end
 
-      # Adds users to the given group
+      # Adds members to the group
       #
       # @see https://developers.lokalise.com/reference/add-members-to-group
       # @return [RubyLokaliseApi::Resources::TeamUserGroup]
-      # @param team_id [String]
+      # @param team_id [String, Integer]
       # @param group_id [String, Integer]
-      # @param users_ids [String, Integer, Array<String>, Array<Integer>]
-      def add_users_to_group(team_id, group_id, users_ids)
-        c_r RubyLokaliseApi::Resources::TeamUserGroup, :update,
-            [team_id, group_id, 'members', 'add'],
-            users_ids, :users, [team_id, group_id]
+      # @param user_ids [Array, String]
+      def add_members_to_group(team_id, group_id, user_ids)
+        params = { query: [team_id, group_id, :members, :add], req: user_ids.to_array_obj(:users) }
+
+        data = endpoint(name: 'TeamUserGroups', params: params).do_put
+
+        resource 'TeamUserGroup', data
       end
 
-      # Removes users from the given group
+      # Removes members from the group
       #
       # @see https://developers.lokalise.com/reference/remove-members-from-group
       # @return [RubyLokaliseApi::Resources::TeamUserGroup]
-      # @param team_id [String]
+      # @param team_id [String, Integer]
       # @param group_id [String, Integer]
-      # @param users_ids [String, Integer, Array<String>, Array<Integer>]
-      def remove_users_from_group(team_id, group_id, users_ids)
-        c_r RubyLokaliseApi::Resources::TeamUserGroup, :update,
-            [team_id, group_id, 'members', 'remove'],
-            users_ids, :users, [team_id, group_id]
+      # @param user_ids [Array, String]
+      def remove_members_from_group(team_id, group_id, user_ids)
+        params = { query: [team_id, group_id, :members, :remove], req: user_ids.to_array_obj(:users) }
+
+        data = endpoint(name: 'TeamUserGroups', params: params).do_put
+
+        resource 'TeamUserGroup', data
       end
     end
   end

data/lib/ruby_lokalise_api/rest/team_users.rb

@@ -3,45 +3,62 @@
 module RubyLokaliseApi
   module Rest
     module TeamUsers
-      # Returns all team users for the given team
+      # Returns team users
       #
       # @see https://developers.lokalise.com/reference/list-all-team-users
-      # @return [RubyLokaliseApi::Collection::TeamUser<RubyLokaliseApi::Resources::TeamUser>]
-      # @param team_id [String]
-      # @param params [Hash]
-      def team_users(team_id, params = {})
-        c_r RubyLokaliseApi::Collections::TeamUser, :all, team_id, params
+      # @return [RubyLokaliseApi::Collections::TeamUsers]
+      # @param team_id [Integer, String]
+      # @param req_params [Hash]
+      def team_users(team_id, req_params = {})
+        name = 'TeamUsers'
+        params = { query: team_id, req: req_params }
+
+        data = endpoint(name: name, params: params).do_get
+
+        collection name, data
       end
 
-      # Returns team user from the given team
+      # Returns a single team user
       #
       # @see https://developers.lokalise.com/reference/retrieve-a-team-user
       # @return [RubyLokaliseApi::Resources::TeamUser]
-      # @param team_id [String]
+      # @param team_id [String, Integer]
       # @param user_id [String, Integer]
       def team_user(team_id, user_id)
-        c_r RubyLokaliseApi::Resources::TeamUser, :find, [team_id, user_id]
+        params = { query: [team_id, user_id] }
+
+        response = endpoint(name: 'TeamUsers', params: params).do_get
+
+        resource 'TeamUser', response
       end
 
-      # Updates team user for the given team
+      # Updates a team user
       #
       # @see https://developers.lokalise.com/reference/update-a-team-user
       # @return [RubyLokaliseApi::Resources::TeamUser]
-      # @param team_id [String]
+      # @param team_id [String, Integer]
       # @param user_id [String, Integer]
-      # @param params [Hash]
-      def update_team_user(team_id, user_id, params)
-        c_r RubyLokaliseApi::Resources::TeamUser, :update, [team_id, user_id], params
+      # @param req_params [Hash]
+      def update_team_user(team_id, user_id, req_params = {})
+        params = { query: [team_id, user_id], req: req_params }
+
+        data = endpoint(name: 'TeamUsers', params: params).do_put
+
+        resource 'TeamUser', data
       end
 
-      # Deletes team user from the given team
+      # Deletes a team user
       #
       # @see https://developers.lokalise.com/reference/delete-a-team-user
-      # @return [RubyLokaliseApi::Resources::TeamUser]
-      # @param team_id [String]
+      # @return [RubyLokaliseApi::Generics::DeletedResource]
+      # @param team_id [String, Integer]
       # @param user_id [String, Integer]
       def destroy_team_user(team_id, user_id)
-        c_r RubyLokaliseApi::Resources::TeamUser, :destroy, [team_id, user_id]
+        params = { query: [team_id, user_id] }
+
+        data = endpoint(name: 'TeamUsers', params: params).do_delete
+
+        RubyLokaliseApi::Generics::DeletedResource.new data.content
       end
     end
   end

data/lib/ruby_lokalise_api/rest/teams.rb

@@ -3,13 +3,18 @@
 module RubyLokaliseApi
   module Rest
     module Teams
-      # Returns all teams available to the user
+      # Returns teams
       #
       # @see https://developers.lokalise.com/reference/list-all-teams
-      # @return [RubyLokaliseApi::Collection::Team<RubyLokaliseApi::Resources::Team>]
-      # @param params [Hash]
-      def teams(params = {})
-        c_r RubyLokaliseApi::Collections::Team, :all, nil, params
+      # @return [RubyLokaliseApi::Collections::Teams]
+      # @param req_params [Hash]
+      def teams(req_params = {})
+        name = 'Teams'
+        params = { req: req_params }
+
+        data = endpoint(name: name, params: params).do_get
+
+        collection name, data
       end
     end
   end

data/lib/ruby_lokalise_api/rest/translation_providers.rb

@@ -3,24 +3,39 @@
 module RubyLokaliseApi
   module Rest
     module TranslationProviders
-      # Returns all translation providers for the given team
+      # Returns translation providers
       #
       # @see https://developers.lokalise.com/reference/list-all-providers
-      # @return [RubyLokaliseApi::Collection::TranslationProvider<RubyLokaliseApi::Resources::TranslationProvider>]
-      # @param team_id [String]
-      # @param params [Hash]
-      def translation_providers(team_id, params = {})
-        c_r RubyLokaliseApi::Collections::TranslationProvider, :all, team_id, params
+      # @return [RubyLokaliseApi::Collections::TranslationProviders]
+      # @param team_id [String, Integer]
+      # @param req_params [Hash]
+      def translation_providers(team_id, req_params = {})
+        name = 'TranslationProviders'
+        params = { query: team_id, req: req_params }
+
+        response = endpoint(name: name, params: params).do_get
+
+        # We must patch content because the API does not return team_id and it's mandatory to build resource URLs
+        response.patch_content_with 'team_id', team_id
+
+        collection name, response
       end
 
-      # Returns a single translation provider for the given team
+      # Returns a single translation provider
       #
       # @see https://developers.lokalise.com/reference/retrieve-a-provider
       # @return [RubyLokaliseApi::Resources::TranslationProvider]
-      # @param team_id [String]
+      # @param team_id [String, Integer]
       # @param provider_id [String, Integer]
       def translation_provider(team_id, provider_id)
-        c_r RubyLokaliseApi::Resources::TranslationProvider, :find, [team_id, provider_id]
+        params = { query: [team_id, provider_id] }
+
+        response = endpoint(name: 'TranslationProviders', params: params).do_get
+
+        # We must patch content because the API does not return team_id and it's mandatory to build resource URLs
+        response.patch_content_with 'team_id', team_id
+
+        resource 'TranslationProvider', response
       end
     end
   end

data/lib/ruby_lokalise_api/rest/translations.rb

@@ -3,36 +3,49 @@
 module RubyLokaliseApi
   module Rest
     module Translations
-      # Returns all translations for the given project (ungrouped)
+      # Returns translations
       #
       # @see https://developers.lokalise.com/reference/list-all-translations
-      # @return [RubyLokaliseApi::Collection::Translation<RubyLokaliseApi::Resources::Translation>]
+      # @return [RubyLokaliseApi::Collections::Translations]
       # @param project_id [String]
-      # @param params [Hash]
-      def translations(project_id, params = {})
-        c_r RubyLokaliseApi::Collections::Translation, :all, project_id, params
+      # @param req_params [Hash]
+      def translations(project_id, req_params = {})
+        name = 'Translations'
+        params = { query: project_id, req: req_params }
+
+        data = endpoint(name: name, params: params).do_get
+
+        collection name, data
       end
 
-      # Returns translation of the given project
+      # Returns a single translation
       #
       # @see https://developers.lokalise.com/reference/retrieve-a-translation
       # @return [RubyLokaliseApi::Resources::Translation]
       # @param project_id [String]
-      # @param translation_id [String, Integer]
-      # @param params [Hash]
-      def translation(project_id, translation_id, params = {})
-        c_r RubyLokaliseApi::Resources::Translation, :find, [project_id, translation_id], params
+      # @param translation_id [String]
+      # @param req_params[Hash]
+      def translation(project_id, translation_id, req_params = {})
+        params = { query: [project_id, translation_id], req: req_params }
+
+        data = endpoint(name: 'Translations', params: params).do_get
+
+        resource 'Translation', data
       end
 
-      # Updates translation of the given project
+      # Updates a translation
       #
       # @see https://developers.lokalise.com/reference/update-a-translation
       # @return [RubyLokaliseApi::Resources::Translation]
       # @param project_id [String]
-      # @param translation_id [String, Integer]
-      # @param params [Hash]
-      def update_translation(project_id, translation_id, params)
-        c_r RubyLokaliseApi::Resources::Translation, :update, [project_id, translation_id], params
+      # @param translation_id [String]
+      # @param req_params [Hash]
+      def update_translation(project_id, translation_id, req_params)
+        params = { query: [project_id, translation_id], req: req_params }
+
+        data = endpoint(name: 'Translations', params: params).do_put
+
+        resource 'Translation', data
       end
     end
   end

data/lib/ruby_lokalise_api/rest/webhooks.rb

@@ -3,66 +3,90 @@
 module RubyLokaliseApi
   module Rest
     module Webhooks
-      # Returns all webhooks for the given project
+      # Returns project webhooks
       #
       # @see https://developers.lokalise.com/reference/list-all-webhooks
-      # @return [RubyLokaliseApi::Collection::Webhook<RubyLokaliseApi::Resources::Webhook>]
+      # @return [RubyLokaliseApi::Collections::Webhooks]
       # @param project_id [String]
-      # @param params [Hash]
-      def webhooks(project_id, params = {})
-        c_r RubyLokaliseApi::Collections::Webhook, :all, project_id, params
+      # @param req_params [Hash]
+      def webhooks(project_id, req_params = {})
+        name = 'Webhooks'
+        params = { query: project_id, req: req_params }
+
+        data = endpoint(name: name, params: params).do_get
+
+        collection name, data
       end
 
-      # Returns a single webhook for the given project
+      # Returns a single webhook
       #
       # @see https://developers.lokalise.com/reference/retrieve-a-webhook
       # @return [RubyLokaliseApi::Resources::Webhook]
       # @param project_id [String]
-      # @param webhook_id [String, Integer]
+      # @param webhook_id [String]
       def webhook(project_id, webhook_id)
-        c_r RubyLokaliseApi::Resources::Webhook, :find, [project_id, webhook_id]
+        params = { query: [project_id, webhook_id] }
+
+        data = endpoint(name: 'Webhooks', params: params).do_get
+
+        resource 'Webhook', data
       end
 
-      # Creates webhook for the given project
+      # Creates a webhook
       #
       # @see https://developers.lokalise.com/reference/create-a-webhook
       # @return [RubyLokaliseApi::Resources::Webhook]
       # @param project_id [String]
-      # @param params [Hash]
-      def create_webhook(project_id, params)
-        c_r RubyLokaliseApi::Resources::Webhook, :create, project_id, params
+      # @param req_params [Hash]
+      def create_webhook(project_id, req_params)
+        params = { query: project_id, req: req_params }
+
+        data = endpoint(name: 'Webhooks', params: params).do_post
+
+        resource 'Webhook', data
       end
 
-      # Updates webhook for the given project
+      # Updates a webhook
       #
       # @see https://developers.lokalise.com/reference/update-a-webhook
       # @return [RubyLokaliseApi::Resources::Webhook]
       # @param project_id [String]
-      # @param webhook_id [String, Integer]
-      # @param params [Hash]
-      def update_webhook(project_id, webhook_id, params = {})
-        c_r RubyLokaliseApi::Resources::Webhook, :update, [project_id, webhook_id], params
+      # @param webhook_id [String]
+      # @param req_params [Hash]
+      def update_webhook(project_id, webhook_id, req_params)
+        params = { query: [project_id, webhook_id], req: req_params }
+
+        data = endpoint(name: 'Webhooks', params: params).do_put
+
+        resource 'Webhook', data
       end
 
-      # Deletes webhook for the given project
+      # Regenerates webhook secret
       #
-      # @see https://developers.lokalise.com/reference/delete-a-webhook
-      # @return [Hash]
+      # @see https://developers.lokalise.com/reference/regenerate-a-webhook-secret
+      # @return [RubyLokaliseApi::Generics::RegeneratedWebhookSecret]
       # @param project_id [String]
-      # @param webhook_id [String, Integer]
-      def destroy_webhook(project_id, webhook_id)
-        c_r RubyLokaliseApi::Resources::Webhook, :destroy, [project_id, webhook_id]
+      # @param webhook_id [String]
+      def regenerate_webhook_secret(project_id, webhook_id)
+        params = { query: [project_id, webhook_id, :secret, :regenerate] }
+
+        data = endpoint(name: 'Webhooks', params: params).do_patch
+
+        RubyLokaliseApi::Generics::RegeneratedWebhookSecret.new data.content
       end
 
-      # Regenerates secret for the given webhook
+      # Deletes a webhook
       #
-      # @see https://developers.lokalise.com/reference/regenerate-a-webhook-secret
-      # @return [Hash]
+      # @see https://developers.lokalise.com/reference/delete-a-webhook
+      # @return [RubyLokaliseApi::Generics::DeletedResource]
       # @param project_id [String]
-      # @param webhook_id [String, Integer]
-      def regenerate_webhook_secret(project_id, webhook_id)
-        c_r RubyLokaliseApi::Resources::Webhook, :regenerate_secret,
-            [project_id, webhook_id, 'secret', 'regenerate']
+      # @param webhook_id [String]
+      def destroy_webhook(project_id, webhook_id)
+        params = { query: [project_id, webhook_id] }
+
+        data = endpoint(name: 'Webhooks', params: params).do_delete
+
+        RubyLokaliseApi::Generics::DeletedResource.new data.content
       end
     end
   end

data/lib/ruby_lokalise_api/rest.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubyLokaliseApi
+  module Rest
+    include Utils::Loaders
+
+    include Rest::Branches
+    include Rest::Comments
+    include Rest::Contributors
+    include Rest::CustomTranslationStatuses
+    include Rest::Files
+    include Rest::Jwts
+    include Rest::Keys
+    include Rest::Languages
+    include Rest::Orders
+    include Rest::PaymentCards
+    include Rest::Projects
+    include Rest::QueuedProcesses
+    include Rest::Segments
+    include Rest::Screenshots
+    include Rest::Snapshots
+    include Rest::Tasks
+    include Rest::TeamUserBillingDetails
+    include Rest::Teams
+    include Rest::TeamUsers
+    include Rest::TeamUserGroups
+    include Rest::TranslationProviders
+    include Rest::Translations
+    include Rest::Webhooks
+  end
+end

data/lib/ruby_lokalise_api/utils/attributes.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubyLokaliseApi
+  module Utils
+    module Attributes
+      using RubyLokaliseApi::Utils::Strings
+      using RubyLokaliseApi::Utils::Classes
+
+      private
+
+      UNIFIED_RESOURCES = %w[comment].freeze
+
+      # Loads attributes for the given resource based on its name
+      #
+      # @return [Array<String>]
+      def attributes_for(klass, filename)
+        @attributes ||= YAML.load_file(File.expand_path("../data/#{filename}", __dir__)).freeze
+
+        name = unify klass.base_name.snakecase
+
+        @attributes.key?(name) ? @attributes[name] : @attributes["#{name}s"]
+      end
+
+      # Unify some resources' names (eg, `ProjectComment` and `KeyComment` have the same
+      # attributes which are stored under `comment`)
+      #
+      # @return [String]
+      def unify(name)
+        UNIFIED_RESOURCES.each do |u_a|
+          return u_a if name.match?(/#{u_a}/)
+        end
+
+        name
+      end
+    end
+  end
+end

data/lib/ruby_lokalise_api/utils/classes.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RubyLokaliseApi
+  module Utils
+    module Classes
+      refine Object do
+        # Turn `Module::Nested::ClassName` to just `ClassName`
+        def base_name
+          name.split('::').last
+        end
+
+        def to_array
+          is_a?(Array) ? self : [self]
+        end
+
+        def to_array_obj(key)
+          return self if is_a?(Hash) && (key?(key) || key?(key.to_s))
+
+          { key => to_array }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lokalise_api/utils/keys.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RubyLokaliseApi
+  module Utils
+    module Keys
+      using RubyLokaliseApi::Utils::Strings
+
+      def data_key_for(klass:)
+        key = if Module.const_defined? "RubyLokaliseApi::Resources::#{klass}::DATA_KEY"
+                Module.const_get "RubyLokaliseApi::Resources::#{klass}::DATA_KEY"
+              else
+                klass
+              end
+
+        key.snakecase
+      end
+
+      def collection_key_for(klass:)
+        key = if Module.const_defined?("RubyLokaliseApi::Collections::#{klass}::DATA_KEY")
+                Module.const_get("RubyLokaliseApi::Collections::#{klass}::DATA_KEY")
+              else
+                klass
+              end
+
+        key.snakecase
+      end
+    end
+  end
+end