ruby-lokalise-api 7.1.1 → 8.0.0.rc1

data/lib/ruby_lokalise_api/endpoints/segments_endpoint.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RubyLokaliseApi
+  module Endpoints
+    class SegmentsEndpoint < MainEndpoint
+      private
+
+      def base_query(project_id, key_id, language_iso, segment_number = nil)
+        {
+          projects: project_id,
+          keys: key_id,
+          segments: [language_iso, segment_number]
+        }
+      end
+    end
+  end
+end

data/lib/ruby_lokalise_api/endpoints/snapshots_endpoint.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyLokaliseApi
+  module Endpoints
+    class SnapshotsEndpoint < MainEndpoint
+      private
+
+      def base_query(project_id, snapshot_id = nil)
+        {
+          projects: project_id,
+          snapshots: snapshot_id
+        }
+      end
+    end
+  end
+end

data/lib/ruby_lokalise_api/endpoints/system_languages_endpoint.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RubyLokaliseApi
+  module Endpoints
+    class SystemLanguagesEndpoint < MainEndpoint
+      private
+
+      def base_query(*_args)
+        {
+          system: :languages
+        }
+      end
+    end
+  end
+end

data/lib/ruby_lokalise_api/endpoints/tasks_endpoint.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyLokaliseApi
+  module Endpoints
+    class TasksEndpoint < MainEndpoint
+      private
+
+      def base_query(project_id, task_id = nil)
+        {
+          projects: project_id,
+          tasks: task_id
+        }
+      end
+    end
+  end
+end

data/lib/ruby_lokalise_api/endpoints/team_user_billing_details_endpoint.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RubyLokaliseApi
+  module Endpoints
+    class TeamUserBillingDetailsEndpoint < MainEndpoint
+      private
+
+      def base_query(team_id)
+        {
+          teams: [team_id, :billing_details]
+        }
+      end
+    end
+  end
+end

data/lib/ruby_lokalise_api/endpoints/team_user_groups_endpoint.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyLokaliseApi
+  module Endpoints
+    class TeamUserGroupsEndpoint < MainEndpoint
+      private
+
+      def base_query(team_id, group_id = nil, *actions)
+        {
+          teams: team_id,
+          groups: [group_id, actions]
+        }
+      end
+    end
+  end
+end

data/lib/ruby_lokalise_api/endpoints/team_users_endpoint.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyLokaliseApi
+  module Endpoints
+    class TeamUsersEndpoint < MainEndpoint
+      private
+
+      def base_query(team_id, user_id = nil)
+        {
+          teams: team_id,
+          users: user_id
+        }
+      end
+    end
+  end
+end

data/lib/ruby_lokalise_api/endpoints/teams_endpoint.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RubyLokaliseApi
+  module Endpoints
+    class TeamsEndpoint < MainEndpoint
+      private
+
+      def base_query(*_args)
+        [:teams]
+      end
+    end
+  end
+end

data/lib/ruby_lokalise_api/endpoints/translation_providers_endpoint.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyLokaliseApi
+  module Endpoints
+    class TranslationProvidersEndpoint < MainEndpoint
+      private
+
+      def base_query(team_id, provider_id = nil)
+        {
+          teams: team_id,
+          translation_providers: provider_id
+        }
+      end
+    end
+  end
+end

data/lib/ruby_lokalise_api/endpoints/translations_endpoint.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyLokaliseApi
+  module Endpoints
+    class TranslationsEndpoint < MainEndpoint
+      private
+
+      def base_query(project_id, translation_id = nil)
+        {
+          projects: project_id,
+          translations: translation_id
+        }
+      end
+    end
+  end
+end

data/lib/ruby_lokalise_api/endpoints/webhooks_endpoint.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyLokaliseApi
+  module Endpoints
+    class WebhooksEndpoint < MainEndpoint
+      private
+
+      def base_query(project_id, webhook_id = nil, *actions)
+        {
+          projects: project_id,
+          webhooks: [webhook_id, actions]
+        }
+      end
+    end
+  end
+end

data/lib/ruby_lokalise_api/error.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module RubyLokaliseApi
+  # Standard API errors
   class Error < StandardError
     ClientError = Class.new(self)
     ServerError = Class.new(self)

data/lib/ruby_lokalise_api/generics.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RubyLokaliseApi
+  # Simple generic objects to decorate certain responses (usually, related to data deletion)
+  class Generics
+    include RubyLokaliseApi::Concerns::HashAccessible
+
+    DeletedResource = Class.new(self)
+    EmptiedResource = Class.new(self)
+    CustomStatusAvailableColors = Class.new(self)
+    DownloadBundle = Class.new(self)
+    MergedBranches = Class.new(self)
+    RegeneratedWebhookSecret = Class.new(self)
+
+    def initialize(raw_data)
+      raw_data.each do |att, val|
+        instance_variable_set "@#{att}", val
+
+        self.class.class_exec do
+          attr_reader att.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lokalise_api/json_handler.rb

@@ -3,9 +3,8 @@
 require 'json'
 
 module RubyLokaliseApi
+  # JSON custom parser. Uses built-in JSON by default but can be overridden to any other parser
   module JsonHandler
-    # JSON custom parser. Uses built-in JSON by default but can be overridden to any other parser
-
     # Converts Ruby object to JSON
     def custom_dump(obj)
       JSON.dump obj

data/lib/ruby_lokalise_api/oauth2/auth.rb

@@ -3,10 +3,10 @@
 module RubyLokaliseApi
   module OAuth2
     class Auth
-      include RubyLokaliseApi::BaseRequest
-
       attr_reader :client_id, :client_secret, :timeout, :open_timeout
 
+      OAUTH2_ENDPOINT = RubyLokaliseApi::Endpoints::OAuth2::OAuth2Endpoint
+
       def initialize(client_id, client_secret, params = {})
         @client_id = client_id
         @client_secret = client_secret
@@ -14,61 +14,55 @@ module RubyLokaliseApi
         @open_timeout = params[:open_timeout]
       end
 
-      def auth(scope:, redirect_uri: nil, state: nil)
-        scope = scope.join(' ') if scope.is_a?(Array)
+      def oauth2_endpoint
+        self.class.const_get(:OAUTH2_ENDPOINT)
+      end
 
-        params = {
+      def auth(scope:, redirect_uri: nil, state: nil)
+        get_params = {
           client_id: client_id,
-          scope: scope
+          scope: (scope.is_a?(Array) ? scope.join(' ') : scope),
+          state: state,
+          redirect_uri: redirect_uri
         }
-        params[:state] = state unless state.nil?
-        params[:redirect_uri] = redirect_uri unless redirect_uri.nil?
 
-        _build_url_from params
+        oauth2_endpoint.new(self, query: 'auth', get: get_params).full_uri
       end
 
       def token(code)
-        params = base_params.merge({
-                                     code: code,
-                                     grant_type: 'authorization_code'
-                                   })
-
-        RubyLokaliseApi::OAuth2::Token.new post('token', self, params)
-      end
-
-      def refresh(token)
-        params = base_params.merge({
-                                     refresh_token: token,
-                                     grant_type: 'refresh_token'
-                                   })
+        endpoint = oauth2_endpoint.new(
+          self,
+          query: :token,
+          req: common_params.merge(
+            grant_type: 'authorization_code',
+            code: code
+          )
+        )
 
-        RubyLokaliseApi::OAuth2::Refresh.new post('token', self, params)
+        RubyLokaliseApi::Resources::OAuth2Token.new endpoint.do_post
       end
 
-      def base_url
-        URI('https://app.lokalise.com/oauth2/')
-      end
+      def refresh(refresh_token)
+        endpoint = oauth2_endpoint.new(
+          self,
+          query: :token,
+          req: common_params.merge(
+            grant_type: 'refresh_token',
+            refresh_token: refresh_token
+          )
+        )
 
-      def compression?
-        false
+        RubyLokaliseApi::Resources::OAuth2RefreshedToken.new endpoint.do_post
       end
 
       private
 
-      def base_params
+      def common_params
         {
-          client_id: client_id,
-          client_secret: client_secret
+          client_id: @client_id,
+          client_secret: @client_secret
         }
       end
-
-      def _build_url_from(params)
-        URI::HTTPS.build(
-          host: base_url.host,
-          path: "#{base_url.path}auth",
-          query: URI.encode_www_form(params)
-        ).to_s
-      end
     end
   end
 end

data/lib/ruby_lokalise_api/oauth2_client.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
 module RubyLokaliseApi
+  # Client used to perform API requests with an OAuth2 access token
   class OAuth2Client < Client
+    include RubyLokaliseApi::Rest
+
     def initialize(token, params = {})
       super(token, params)
       @token_header = 'Authorization'

data/lib/ruby_lokalise_api/request.rb

@@ -1,31 +1,79 @@
 # frozen_string_literal: true
 
 module RubyLokaliseApi
+  # Contains methods to perform the actual HTTP requests
   module Request
-    include RubyLokaliseApi::BaseRequest
+    include RubyLokaliseApi::JsonHandler
+    include RubyLokaliseApi::Connection
 
-    # Lokalise returns pagination info in special headers
-    PAGINATION_HEADERS = %w[x-pagination-total-count x-pagination-page-count x-pagination-limit
-                            x-pagination-page].freeze
+    # Sends a GET request
+    def get(endpoint)
+      respond_with(
+        connection(endpoint).get(prepare(endpoint.uri), endpoint.req_params),
+        endpoint
+      )
+    end
+
+    # Sends a POST request
+    def post(endpoint)
+      respond_with(
+        connection(endpoint).post(prepare(endpoint.uri), custom_dump(endpoint.req_params)),
+        endpoint
+      )
+    end
+
+    # Sends a PUT request
+    def put(endpoint)
+      respond_with(
+        connection(endpoint).put(prepare(endpoint.uri), custom_dump(endpoint.req_params)),
+        endpoint
+      )
+    end
+
+    # Sends a PATCH request
+    def patch(endpoint)
+      respond_with(
+        connection(endpoint).patch(prepare(endpoint.uri),
+                                   endpoint.req_params.nil? ? nil : custom_dump(endpoint.req_params)),
+        endpoint
+      )
+    end
+
+    # Sends a DELETE request
+    def delete(endpoint)
+      respond_with(
+        connection(endpoint).delete(prepare(endpoint.uri)) do |req|
+          req.body = custom_dump endpoint.req_params
+        end,
+        endpoint
+      )
+    end
 
     private
 
-    def respond_with(response, client)
+    # Get rid of double slashes in the `path`, leading and trailing slash
+    def prepare(path)
+      path.delete_prefix('/').gsub(%r{//}, '/').gsub(%r{/+\z}, '')
+    end
+
+    def raise_on_error!(response, body)
+      return unless !response.success? || (body.respond_to?(:has_key?) && body.key?('error'))
+
+      respond_with_error(response.status, body)
+    end
+
+    def respond_with(response, endpoint)
       body = custom_load response.body
-      uri = Addressable::URI.parse response.env.url
+
       raise_on_error! response, body
-      extract_headers_from(response).
-        merge('content' => body,
-              'client' => client,
-              'path' => uri.path.gsub(%r{/api2/}, ''))
-    end
-
-    # Keep only pagination headers
-    def extract_headers_from(response)
-      response.
-        headers.
-        to_h.
-        keep_if { |k, _v| PAGINATION_HEADERS.include?(k) }
+
+      RubyLokaliseApi::Response.new(body, endpoint, response.headers)
+    end
+
+    def respond_with_error(code, body)
+      raise(RubyLokaliseApi::Error, body['error'] || body) unless RubyLokaliseApi::Error::ERRORS.key? code
+
+      raise RubyLokaliseApi::Error::ERRORS[code].from_response(body)
     end
   end
 end