ruby-lokalise-api 7.2.0 → 8.0.0.rc1

data/lib/ruby_lokalise_api/rest/projects.rb

@@ -3,59 +3,82 @@
 module RubyLokaliseApi
   module Rest
     module Projects
-      # Returns all projects available to the user authorized with the API token
-      #
-      # @see https://developers.lokalise.com/reference/list-all-projects
-      # @return [RubyLokaliseApi::Collection::Project<RubyLokaliseApi::Resources::Project>]
-      # @param params [Hash]
-      def projects(params = {})
-        c_r RubyLokaliseApi::Collections::Project, :all, nil, params
-      end
-
       # Returns a single project
       #
       # @see https://developers.lokalise.com/reference/retrieve-a-project
       # @return [RubyLokaliseApi::Resources::Project]
-      # @param project_id [String, Integer]
+      # @param project_id [String]
       def project(project_id)
-        c_r RubyLokaliseApi::Resources::Project, :find, project_id
+        params = { query: project_id }
+
+        data = endpoint(name: 'Projects', params: params).do_get
+
+        resource 'Project', data
+      end
+
+      # Returns a collection of projects
+      #
+      # @see https://developers.lokalise.com/reference/list-all-projects
+      # @return [RubyLokaliseApi::Collections::Projects]
+      # @param req_params [Hash]
+      def projects(req_params = {})
+        name = 'Projects'
+        params = { req: req_params }
+
+        data = endpoint(name: name, params: params).do_get
+
+        collection name, data
       end
 
-      # Creates project
+      # Creates a project
       #
       # @see https://developers.lokalise.com/reference/create-a-project
       # @return [RubyLokaliseApi::Resources::Project]
-      # @param params [Hash]
-      def create_project(params)
-        c_r RubyLokaliseApi::Resources::Project, :create, nil, params
+      # @param req_params [Hash]
+      def create_project(req_params)
+        params = { req: req_params }
+
+        data = endpoint(name: 'Projects', params: params).do_post
+
+        resource 'Project', data
       end
 
-      # Updates project
+      # Updates a project
       #
       # @see https://developers.lokalise.com/reference/update-a-project
       # @return [RubyLokaliseApi::Resources::Project]
-      # @param project_id [String, Integer]
-      # @param params [Hash]
-      def update_project(project_id, params)
-        c_r RubyLokaliseApi::Resources::Project, :update, project_id, params
-      end
+      # @param project_id [String]
+      # @param req_params [Hash]
+      def update_project(project_id, req_params)
+        params = { query: project_id, req: req_params }
 
-      # Deletes all keys and translations from the project
-      #
-      # @see https://developers.lokalise.com/reference/empty-a-project
-      # @return [Hash]
-      # @param project_id [String, Integer]
-      def empty_project(project_id)
-        c_r RubyLokaliseApi::Resources::Project, :empty, [project_id, 'empty']
+        data = endpoint(name: 'Projects', params: params).do_put
+
+        resource 'Project', data
       end
 
-      # Deletes the project
+      # Deletes a project
       #
       # @see https://developers.lokalise.com/reference/delete-a-project
-      # @return [Hash]
-      # @param project_id [String, Integer]
+      # @return [RubyLokaliseApi::Generics::DeletedResource]
+      # @param project_id [String]
       def destroy_project(project_id)
-        c_r RubyLokaliseApi::Resources::Project, :destroy, project_id
+        params = { query: project_id }
+
+        data = endpoint(name: 'Projects', params: params).do_delete
+
+        RubyLokaliseApi::Generics::DeletedResource.new data.content
+      end
+
+      # Empties a project by deleting all keys and translations
+      #
+      # @see https://developers.lokalise.com/reference/empty-a-project
+      # @return [RubyLokaliseApi::Generics::EmptiedResource]
+      # @param project_id [String]
+      def empty_project(project_id)
+        data = endpoint(name: 'Projects', params: { query: [project_id, :empty] }).do_put
+
+        RubyLokaliseApi::Generics::EmptiedResource.new data.content
       end
     end
   end

data/lib/ruby_lokalise_api/rest/queued_processes.rb

@@ -3,25 +3,33 @@
 module RubyLokaliseApi
   module Rest
     module QueuedProcesses
-      # Returns all queued processes for the given project
+      # Returns a single queued process
       #
-      # @see https://developers.lokalise.com/reference/list-all-processes
-      # @return [RubyLokaliseApi::Collection::QueuedProcess<RubyLokaliseApi::Resources::QueuedProcess>]
+      # @see https://developers.lokalise.com/reference/retrieve-a-process
+      # @return [RubyLokaliseApi::Resources::QueuedProcess]
       # @param project_id [String]
-      # @param params [Hash]
-      def queued_processes(project_id, params = {})
-        c_r RubyLokaliseApi::Collections::QueuedProcess, :all, project_id, params
+      # @param process_id [String, Integer]
+      def queued_process(project_id, process_id)
+        params = { query: [project_id, process_id] }
+
+        data = endpoint(name: 'QueuedProcesses', params: params).do_get
+
+        resource 'QueuedProcess', data
       end
 
-      # Returns a queued process for the given project
+      # Returns queued processes
       #
-      # @see https://developers.lokalise.com/reference/retrieve-a-process
-      # @return [RubyLokaliseApi::Resources::QueuedProcess]
+      # @see https://developers.lokalise.com/reference/list-all-processes
+      # @return [RubyLokaliseApi::Collections::QueuedProcesses]
       # @param project_id [String]
-      # @param process_id [String]
-      def queued_process(project_id, process_id)
-        c_r RubyLokaliseApi::Resources::QueuedProcess, :find,
-            [project_id, process_id]
+      # @param req_params [Hash]
+      def queued_processes(project_id, req_params = {})
+        name = 'QueuedProcesses'
+        params = { query: project_id, req: req_params }
+
+        data = endpoint(name: name, params: params).do_get
+
+        collection name, data
       end
     end
   end

data/lib/ruby_lokalise_api/rest/screenshots.rb

@@ -3,55 +3,80 @@
 module RubyLokaliseApi
   module Rest
     module Screenshots
-      # Returns all screenshots for the given project
+      using RubyLokaliseApi::Utils::Classes
+
+      # Returns project screenshots
       #
       # @see https://developers.lokalise.com/reference/list-all-screenshots
-      # @return [RubyLokaliseApi::Collection::Screenshot<RubyLokaliseApi::Resources::Screenshot>]
+      # @return [RubyLokaliseApi::Collections::Screenshots]
       # @param project_id [String]
-      # @param params [Hash]
-      def screenshots(project_id, params = {})
-        c_r RubyLokaliseApi::Collections::Screenshot, :all, project_id, params
+      # @param req_params [Hash]
+      def screenshots(project_id, req_params = {})
+        name = 'Screenshots'
+        params = { query: project_id, req: req_params }
+
+        data = endpoint(name: name, params: params).do_get
+
+        collection name, data
       end
 
-      # Returns a single screenshot for the given project
+      # Returns a single screenshot
       #
       # @see https://developers.lokalise.com/reference/retrieve-a-screenshot
       # @return [RubyLokaliseApi::Resources::Screenshot]
       # @param project_id [String]
       # @param screenshot_id [String, Integer]
-      def screenshot(project_id, screenshot_id)
-        c_r RubyLokaliseApi::Resources::Screenshot, :find, [project_id, screenshot_id]
+      # @param req_params[Hash]
+      def screenshot(project_id, screenshot_id, req_params = {})
+        params = { query: [project_id, screenshot_id], req: req_params }
+
+        data = endpoint(name: 'Screenshots', params: params).do_get
+
+        resource 'Screenshot', data
       end
 
-      # Creates one or more screenshots for the given project
+      # Creates a new order
       #
       # @see https://developers.lokalise.com/reference/create-screenshots
-      # @return [RubyLokaliseApi::Collection::Screenshot<RubyLokaliseApi::Resources::Screenshot>]
+      # @return [RubyLokaliseApi::Collections::Screenshots]
       # @param project_id [String]
-      # @param params [Hash]
-      def create_screenshots(project_id, params = {})
-        c_r RubyLokaliseApi::Resources::Screenshot, :create, project_id, params, :screenshots
+      # @param req_params [Hash, Array]
+      def create_screenshots(project_id, req_params)
+        name = 'Screenshots'
+        params = { query: project_id, req: req_params.to_array_obj(:screenshots) }
+
+        data = endpoint(name: name, params: params).do_post
+
+        collection name, data
       end
 
-      # Updates screenshot
+      # Updates a screenshot
       #
       # @see https://developers.lokalise.com/reference/update-a-screenshot
       # @return [RubyLokaliseApi::Resources::Screenshot]
       # @param project_id [String]
       # @param screenshot_id [String, Integer]
-      # @param params [Hash]
-      def update_screenshot(project_id, screenshot_id, params = {})
-        c_r RubyLokaliseApi::Resources::Screenshot, :update, [project_id, screenshot_id], params
+      # @param req_params [Hash]
+      def update_screenshot(project_id, screenshot_id, req_params = {})
+        params = { query: [project_id, screenshot_id], req: req_params }
+
+        data = endpoint(name: 'Screenshots', params: params).do_put
+
+        resource 'Screenshot', data
       end
 
-      # Deletes screenshot
+      # Deletes a screenshot
       #
       # @see https://developers.lokalise.com/reference/delete-a-screenshot
-      # @return [Hash]
+      # @return [RubyLokaliseApi::Generics::DeletedResource]
       # @param project_id [String]
       # @param screenshot_id [String, Integer]
       def destroy_screenshot(project_id, screenshot_id)
-        c_r RubyLokaliseApi::Resources::Screenshot, :destroy, [project_id, screenshot_id]
+        params = { query: [project_id, screenshot_id] }
+
+        data = endpoint(name: 'Screenshots', params: params).do_delete
+
+        RubyLokaliseApi::Generics::DeletedResource.new data.content
       end
     end
   end

data/lib/ruby_lokalise_api/rest/segments.rb

@@ -3,42 +3,55 @@
 module RubyLokaliseApi
   module Rest
     module Segments
-      # Returns all segments for the given key and language ISO code
+      # Returns project segments
       #
       # @see https://developers.lokalise.com/reference/list-all-segments-for-key-language
-      # @return [RubyLokaliseApi::Collection::Segments<RubyLokaliseApi::Resources::Segment>]
+      # @return [RubyLokaliseApi::Collections::Segments]
       # @param project_id [String]
       # @param key_id [String, Integer]
-      # @param lang_iso [String]
-      # @param params [Hash]
-      def segments(project_id, key_id, lang_iso, params = {})
-        c_r RubyLokaliseApi::Collections::Segment, :all, [project_id, key_id, lang_iso], params
+      # @param language_iso [String]
+      # @param req_params [Hash]
+      def segments(project_id, key_id, language_iso, req_params = {})
+        name = 'Segments'
+        params = { query: [project_id, key_id, language_iso], req: req_params }
+
+        data = endpoint(name: name, params: params).do_get
+
+        collection name, data
       end
 
-      # Returns a segment under a given number for the given key and language ISO code
+      # Returns a single project segment
       #
       # @see https://developers.lokalise.com/reference/retrieve-a-segment-for-key-language
       # @return [RubyLokaliseApi::Resources::Segment]
       # @param project_id [String]
       # @param key_id [String, Integer]
-      # @param lang_iso [String]
-      # @params segment_number [Integer, String]
-      # @param params [Hash]
-      def segment(project_id, key_id, lang_iso, segment_number, params = {})
-        c_r RubyLokaliseApi::Resources::Segment, :find, [project_id, key_id, lang_iso, segment_number], params
+      # @param language_iso [String]
+      # @param segment_number [String, Integer]
+      # @param req_params [Hash]
+      def segment(project_id, key_id, language_iso, segment_number, req_params = {})
+        params = { query: [project_id, key_id, language_iso, segment_number], req: req_params }
+
+        data = endpoint(name: 'Segments', params: params).do_get
+
+        resource 'Segment', data
       end
 
-      # Updates a segment under a given number for the given key and language ISO code
+      # Updates a segment
       #
       # @see https://developers.lokalise.com/reference/update-a-segment
       # @return [RubyLokaliseApi::Resources::Segment]
       # @param project_id [String]
       # @param key_id [String, Integer]
-      # @param lang_iso [String]
-      # @params segment_number [Integer, String]
-      # @param params [Hash]
-      def update_segment(project_id, key_id, lang_iso, segment_number, params = {})
-        c_r RubyLokaliseApi::Resources::Segment, :update, [project_id, key_id, lang_iso, segment_number], params
+      # @param language_iso [String]
+      # @param segment_number [String, Integer]
+      # @param req_params [Hash]
+      def update_segment(project_id, key_id, language_iso, segment_number, req_params = {})
+        params = { query: [project_id, key_id, language_iso, segment_number], req: req_params }
+
+        data = endpoint(name: 'Segments', params: params).do_put
+
+        resource 'Segment', data
       end
     end
   end

data/lib/ruby_lokalise_api/rest/snapshots.rb

@@ -3,44 +3,64 @@
 module RubyLokaliseApi
   module Rest
     module Snapshots
-      # Returns all snapshots for the given project
+      # Returns project snapshots
       #
       # @see https://developers.lokalise.com/reference/list-all-snapshots
-      # @return [RubyLokaliseApi::Collection::Snapshot<RubyLokaliseApi::Resources::Snapshot>]
+      # @return [RubyLokaliseApi::Collections::Snapshots]
       # @param project_id [String]
-      # @param params [Hash]
-      def snapshots(project_id, params = {})
-        c_r RubyLokaliseApi::Collections::Snapshot, :all, project_id, params
+      # @param req_params [Hash]
+      def snapshots(project_id, req_params = {})
+        name = 'Snapshots'
+        params = { query: project_id, req: req_params }
+
+        data = endpoint(name: name, params: params).do_get
+
+        collection name, data
       end
 
-      # Creates snapshot for the given project
+      # Creates a snapshot
       #
       # @see https://developers.lokalise.com/reference/create-a-snapshot
       # @return [RubyLokaliseApi::Resources::Snapshot]
       # @param project_id [String]
-      # @param params [Hash]
-      def create_snapshot(project_id, params = {})
-        c_r RubyLokaliseApi::Resources::Snapshot, :create, project_id, params
+      # @param req_params [Hash]
+      def create_snapshot(project_id, req_params = {})
+        params = { query: project_id, req: req_params }
+
+        data = endpoint(name: 'Snapshots', params: params).do_post
+
+        resource 'Snapshot', data
       end
 
-      # Restore project from the given snapshot by producing project's copy
+      # Restores a snapshot by creating a project copy
       #
       # @see https://developers.lokalise.com/reference/restore-a-snapshot
       # @return [RubyLokaliseApi::Resources::Project]
       # @param project_id [String]
       # @param snapshot_id [String, Integer]
       def restore_snapshot(project_id, snapshot_id)
-        c_r RubyLokaliseApi::Resources::Snapshot, :restore, [project_id, snapshot_id]
+        params = { query: [project_id, snapshot_id] }
+
+        response = endpoint(name: 'Snapshots', params: params).do_post
+
+        # We restore a project so its endpoint is different
+        response.patch_endpoint_with endpoint(name: 'Projects', params: { query: [project_id] })
+
+        resource 'Project', response
       end
 
-      # Deletes snapshot
+      # Deletes a snapshot
       #
       # @see https://developers.lokalise.com/reference/delete-a-snapshot
-      # @return [Hash]
+      # @return [RubyLokaliseApi::Generics::DeletedResource]
       # @param project_id [String]
       # @param snapshot_id [String, Integer]
       def destroy_snapshot(project_id, snapshot_id)
-        c_r RubyLokaliseApi::Resources::Snapshot, :destroy, [project_id, snapshot_id]
+        params = { query: [project_id, snapshot_id] }
+
+        data = endpoint(name: 'Snapshots', params: params).do_delete
+
+        RubyLokaliseApi::Generics::DeletedResource.new data.content
       end
     end
   end

data/lib/ruby_lokalise_api/rest/tasks.rb

@@ -3,55 +3,77 @@
 module RubyLokaliseApi
   module Rest
     module Tasks
-      # Returns all tasks for the given project
+      # Returns project tasks
       #
       # @see https://developers.lokalise.com/reference/list-all-tasks
-      # @return [RubyLokaliseApi::Collection::Task<RubyLokaliseApi::Resources::Task>]
+      # @return [RubyLokaliseApi::Collections::Tasks]
       # @param project_id [String]
-      # @param params [Hash]
-      def tasks(project_id, params = {})
-        c_r RubyLokaliseApi::Collections::Task, :all, project_id, params
+      # @param req_params [Hash]
+      def tasks(project_id, req_params = {})
+        name = 'Tasks'
+        params = { query: project_id, req: req_params }
+
+        data = endpoint(name: name, params: params).do_get
+
+        collection name, data
       end
 
-      # Returns a single task for the given project
+      # Returns a single task
       #
       # @see https://developers.lokalise.com/reference/retrieve-a-task
       # @return [RubyLokaliseApi::Resources::Task]
       # @param project_id [String]
       # @param task_id [String, Integer]
-      def task(project_id, task_id)
-        c_r RubyLokaliseApi::Resources::Task, :find, [project_id, task_id]
+      # @param req_params[Hash]
+      def task(project_id, task_id, req_params = {})
+        params = { query: [project_id, task_id], req: req_params }
+
+        data = endpoint(name: 'Tasks', params: params).do_get
+
+        resource 'Task', data
       end
 
-      # Creates task for the given project
+      # Creates a new task
       #
       # @see https://developers.lokalise.com/reference/create-a-task
       # @return [RubyLokaliseApi::Resources::Task]
       # @param project_id [String]
-      # @param params [Hash]
-      def create_task(project_id, params)
-        c_r RubyLokaliseApi::Resources::Task, :create, project_id, params
+      # @param req_params [Hash, Array]
+      def create_task(project_id, req_params)
+        params = { query: project_id, req: req_params }
+
+        data = endpoint(name: 'Tasks', params: params).do_post
+
+        resource 'Task', data
       end
 
-      # Updates task for the given project
+      # Updates a task
       #
       # @see https://developers.lokalise.com/reference/update-a-task
       # @return [RubyLokaliseApi::Resources::Task]
       # @param project_id [String]
       # @param task_id [String, Integer]
-      # @param params [Hash]
-      def update_task(project_id, task_id, params = {})
-        c_r RubyLokaliseApi::Resources::Task, :update, [project_id, task_id], params
+      # @param req_params [Hash]
+      def update_task(project_id, task_id, req_params = {})
+        params = { query: [project_id, task_id], req: req_params }
+
+        data = endpoint(name: 'Tasks', params: params).do_put
+
+        resource 'Task', data
       end
 
-      # Deletes task for the given project
+      # Deletes a task
       #
       # @see https://developers.lokalise.com/reference/delete-a-task
-      # @return [Hash]
+      # @return [RubyLokaliseApi::Generics::DeletedResource]
       # @param project_id [String]
       # @param task_id [String, Integer]
       def destroy_task(project_id, task_id)
-        c_r RubyLokaliseApi::Resources::Task, :destroy, [project_id, task_id]
+        params = { query: [project_id, task_id] }
+
+        data = endpoint(name: 'Tasks', params: params).do_delete
+
+        RubyLokaliseApi::Generics::DeletedResource.new data.content
       end
     end
   end

data/lib/ruby_lokalise_api/rest/team_user_billing_details.rb

@@ -3,33 +3,54 @@
 module RubyLokaliseApi
   module Rest
     module TeamUserBillingDetails
-      # Returns team user billing details
+      # Returns billing details for a team user
       #
       # @see https://developers.lokalise.com/reference/retrieve-team-user-billing-details
       # @return [RubyLokaliseApi::Resources::TeamUserBillingDetails]
-      # @param team_id [String]
+      # @param team_id [String, Integer]
       def team_user_billing_details(team_id)
-        c_r RubyLokaliseApi::Resources::TeamUserBillingDetails, :find, team_id
+        params = { query: team_id }
+
+        response = endpoint(name: 'TeamUserBillingDetails', 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 'TeamUserBillingDetails', response
       end
 
       # Creates team user billing details
       #
       # @see https://developers.lokalise.com/reference/create-team-user-billing-details
       # @return [RubyLokaliseApi::Resources::TeamUserBillingDetails]
-      # @param team_id [String]
-      # @param params [Hash]
-      def create_team_user_billing_details(team_id, params)
-        c_r RubyLokaliseApi::Resources::TeamUserBillingDetails, :create, team_id, params
+      # @param team_id [String, Integer]
+      # @param req_params [Hash, Array]
+      def create_team_user_billing_details(team_id, req_params)
+        params = { query: team_id, req: req_params }
+
+        response = endpoint(name: 'TeamUserBillingDetails', params: params).do_post
+
+        # We must patch content because the API does not return team_id and it's mandatory to build resource URL
+        response.patch_content_with 'team_id', team_id
+
+        resource 'TeamUserBillingDetails', response
       end
 
       # Updates team user billing details
       #
-      # @see https://developers.lokalise.com/reference/create-team-user-billing-details
+      # @see https://developers.lokalise.com/reference/update-team-user-billing-details
       # @return [RubyLokaliseApi::Resources::TeamUserBillingDetails]
-      # @param team_id [String]
-      # @param params [Hash]
-      def update_team_user_billing_details(team_id, params)
-        c_r RubyLokaliseApi::Resources::TeamUserBillingDetails, :update, team_id, params
+      # @param team_id [String, Integer]
+      # @param req_params [Hash]
+      def update_team_user_billing_details(team_id, req_params = {})
+        params = { query: team_id, req: req_params }
+
+        data = endpoint(name: 'TeamUserBillingDetails', params: params).do_put
+
+        # We must patch content because the API does not return team_id and it's mandatory to build resource URL
+        data.patch_content_with 'team_id', team_id
+
+        resource 'TeamUserBillingDetails', data
       end
     end
   end