ruby-lokalise-api 7.1.1 → 8.0.0.rc1

data/lib/ruby_lokalise_api/resources/base.rb

@@ -1,217 +1,77 @@
 # frozen_string_literal: true
 
 module RubyLokaliseApi
+  # Base resource class. A resource is an individual object returned by the API
   module Resources
     class Base
-      using RubyLokaliseApi::Utils::StringUtils
+      using RubyLokaliseApi::Utils::Classes
+      extend RubyLokaliseApi::Utils::Attributes
+      extend RubyLokaliseApi::Concerns::Unsupportable
+      extend RubyLokaliseApi::Concerns::AttrsLoadable
+      include RubyLokaliseApi::Concerns::HashAccessible
+      include RubyLokaliseApi::Utils::Keys
 
-      extend RubyLokaliseApi::Request
-      extend RubyLokaliseApi::Utils::AttributeHelpers
-      include RubyLokaliseApi::Utils::AttributeHelpers
-      extend RubyLokaliseApi::Utils::EndpointHelpers
+      ATTRS_FILENAME = 'resource_attributes.yml'
 
-      attr_reader :raw_data, :project_id, :client, :path, :branch, :user_id, :team_id, :key_id
+      def initialize(response)
+        @self_endpoint = response.endpoint
 
-      # Initializes a new resource based on the response.
-      # `endpoint_generator` is used in cases when a new instance is generated
-      # from a different resource. For example, restoring from a snapshot
-      # creates a totally different project which should have a new path.
-      #
-      # @param response [Hash]
-      # @param endpoint_generator [Proc] Generate proper paths for certain resources
-      # @return [RubyLokaliseApi::Resources::Base]
-      def initialize(response, endpoint_generator = nil)
-        populate_attributes_for response['content']
-        extract_common_attributes_for response['content']
-        @client = response['client']
-        @path = infer_path_from response, endpoint_generator
+        populate_attrs_from response.content
       end
 
-      # Returns object attribute with [] notation by calling
-      # the corresponding method on the object if the
-      # instance variable named after the requested key exists
-      #
-      # @param raw_key_attr [String or Hash]
-      def [](raw_key_attr)
-        key_attr = raw_key_attr.to_s.to_sym
+      # Updates the current resource
+      def update(params)
+        self.class.new reinit_endpoint(params).do_put
+      end
 
-        return nil unless instance_variables.include?(:"@#{key_attr}")
+      # Deletes the current resource
+      def destroy
+        RubyLokaliseApi::Generics::DeletedResource.new(
+          reinit_endpoint.do_delete.content
+        )
+      end
 
-        send key_attr
+      # Reloads the current resource with new values from the API
+      def reload_data
+        self.class.new reinit_endpoint.do_get
       end
 
       class << self
-        # Dynamically adds attribute readers for each inherited class.
-        # Attributes are defined in the `data/attributes.json` file.
-        # Also sets the `ATTRIBUTES` constant to assign values to each attribute later when
-        # the response arrives from the API
-        def inherited(subclass)
-          klass_attributes = attributes_for subclass
-          subclass.class_exec do
-            const_set :ATTRIBUTES, klass_attributes
-            attr_reader(*klass_attributes)
-          end
-          super
-        end
-
-        # Defines CRUD instance methods. In the simplest case it delegates work to the
-        # class method. In more complex case it is possible to specify sub-path and the
-        # class method name to call.
-        # Usage: `supports :update, :destroy, [:complex_method, '/sub/path', :update]`
-        def supports(*methods)
-          methods.each do |m_data|
-            # `method_name` - the method that the resource should support
-            # `sub_path` - a string that has to be appended to a base path
-            # `c_method` - method name to delegate the work to
-            method_name, sub_path, c_method =
-              m_data.is_a?(Array) ? m_data : [m_data, '', m_data]
-
-            define_method method_name do |params = {}|
-              path = instance_variable_get(:@path)
-              # If there's a sub_path which is a string,
-              # preserve the initial path to allow further chaining
-              params = params.merge(_initial_path: path) if sub_path
-              self.class.send c_method, instance_variable_get(:@client),
-                              path + sub_path, params
-            end
-          end
-        end
-
-        # Fetches a single record
-        def find(client, path, params = {})
-          new get(path, client, prepare_params(params))
-        end
-
-        # Creates one or multiple records
-        def create(client, path, params)
-          response = post path, client, prepare_params(params)
-          object_from response, params
-        end
-
-        # Updates one or multiple records
-        def update(client, path, params)
-          response = put path, client, prepare_params(params)
-          object_from response, params
-        end
-
-        # Destroys records by given ids
-        def destroy(client, path, params = {})
-          delete(path, client, prepare_params(params))['content']
-        end
-
-        private
-
-        # Filters out internal attributes that should not be sent to Lokalise
-        def prepare_params(params)
-          filter_attrs = %i[_initial_path]
-          params.reject { |key, _v| filter_attrs.include?(key) }
-        end
-
-        # Instantiates a new resource or collection based on the given response
-        def object_from(response, params)
-          model_class = name.base_class_name
-          data_key_plural = data_key_for model_class: model_class, plural: true
-          # Preserve the initial path to allow chaining
-          response['path'] = params.delete(:_initial_path) if params.key?(:_initial_path)
-
-          if response['content'].key?(data_key_plural)
-            produce_collection model_class, response, params
-          else
-            produce_resource model_class, response
-          end
-        end
-
-        def produce_resource(model_class, response)
-          content = response['content']
-          data_key_singular = data_key_for model_class: model_class
-          if content.key? data_key_singular
-            data = content.delete data_key_singular
-            content.merge! data
+        # Delegates instance method calls to the client methods
+        def delegate_call(from, to = nil)
+          define_method(from) do |*args|
+            @self_endpoint.client.send((to || from), *read_main_params.push(*args))
           end
-
-          new response
-        end
-
-        def produce_collection(model_class, response, params)
-          Module.const_get("RubyLokaliseApi::Collections::#{model_class}").new(response, params)
         end
       end
 
-      # Generates path for the individual resource based on the path for the collection
-      def infer_path_from(response, endpoint_generator = nil)
-        id_key = id_key_for self.class.name.base_class_name
-        data_key = data_key_for model_class: self.class.name.base_class_name
-
-        path_with_id response, id_key, data_key, endpoint_generator
-      end
+      private
 
-      def path_with_id(response, id_key, data_key, endpoint_generator = nil)
-        # Some resources do not have ids at all
-        return unless response['content'] && (response['content'].key?(id_key) || response['content'].key?(data_key))
-
-        # ID of the resource
-        id = id_from response, id_key, data_key
-
-        # If `endpoint_generator` is present, generate a new path
-        # based on the fetched id
-        if endpoint_generator
-          path = endpoint_generator.call project_id, id
-          return path.remove_trailing_slash
+      def read_main_params
+        self.class.const_get(:MAIN_PARAMS).to_array.map do |param|
+          instance_variable_get "@#{param}"
         end
-
-        path = response['path'] || response['base_path']
-        # If path already has id - just return it
-        return path if path.match?(/#{id}\z/)
-
-        # Otherwise this looks like a collection path, so append the resource id to it
-        path.remove_trailing_slash + "/#{id}"
       end
 
-      def id_from(response, id_key, data_key)
-        # Content may be `{"project_id": '123', ...}` or {"snapshot": {"snapshot_id": '123', ...}}
-        # Sometimes there is an `id_key` but it has a value of `null`
-        # (for example when we do not place the actual order but only check its price).
-        # In rare cases the actual identifier does not have an "_id" suffix
-        # (for segments that have "segment_number" field instead)
-        # Therefore we must explicitly check if the key is present
-        content = response['content']
-        return content[id_key] if content.respond_to?(:key?) && content&.key?(id_key)
-
-        content[data_key][id_key]
+      def reinit_endpoint(req_params = {})
+        @self_endpoint.reinitialize(query_params: read_main_params, req_params: req_params)
       end
 
-      # Store all resources attributes under the corresponding instance variables.
-      # `ATTRIBUTES` is defined inside resource-specific classes
-      def populate_attributes_for(content)
+      def populate_attrs_from(content)
         return unless content
 
-        data_key = data_key_for model_class: self.class.name.base_class_name
+        data_key = data_key_for klass: self.class.base_name
 
-        self.class.const_get(:ATTRIBUTES).each do |attr|
-          value = if content.key?(data_key) && content[data_key].is_a?(Hash)
-                    content[data_key][attr]
+        supported_attrs.each do |attrib|
+          value = if content.key?(data_key) && content[data_key].is_a?(Hash) && content[data_key].key?(attrib)
+                    content[data_key][attrib]
                   else
-                    content[attr]
+                    content[attrib]
                   end
 
-          instance_variable_set "@#{attr}", value
+          instance_variable_set "@#{attrib}", value
         end
       end
-
-      # Extracts all common attributes that resources have.
-      # Some of them may be absent in certain cases.
-      # rubocop:disable Naming/MemoizedInstanceVariableName
-      def extract_common_attributes_for(content)
-        return unless content
-
-        @raw_data = content
-        @project_id ||= content['project_id']
-        @user_id ||= content['user_id']
-        @team_id ||= content['team_id']
-        @key_id ||= content['key_id']
-        @branch ||= content['branch']
-      end
-      # rubocop:enable Naming/MemoizedInstanceVariableName
     end
   end
 end

data/lib/ruby_lokalise_api/resources/branch.rb

@@ -3,28 +3,9 @@
 module RubyLokaliseApi
   module Resources
     class Branch < Base
-      ID_KEY = 'branch_id'
-      supports :update, :destroy, [:reload_data, '', :find]
+      MAIN_PARAMS = %i[project_id branch_id].freeze
 
-      def merge(params = {})
-        klass = self.class
-        klass.merge @client, klass.endpoint(project_id, branch_id, :merge), params
-      end
-
-      class << self
-        def merge(client, path, params, *_args)
-          post(path, client, params)['content']
-        end
-
-        def endpoint(project_id, branch_id = nil, action = nil)
-          params = {projects: project_id,
-                    branches: branch_id}
-
-          params[:merge] = '' if action == :merge
-
-          path_from params
-        end
-      end
+      delegate_call :merge, :merge_branch
     end
   end
 end

data/lib/ruby_lokalise_api/resources/comment.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RubyLokaliseApi
+  module Resources
+    class Comment < Base
+      MAIN_PARAMS = %i[project_id key_id comment_id].freeze
+
+      no_support_for %i[update]
+    end
+  end
+end

data/lib/ruby_lokalise_api/resources/contributor.rb

@@ -3,15 +3,7 @@
 module RubyLokaliseApi
   module Resources
     class Contributor < Base
-      ID_KEY = 'user_id'
-      supports :update, :destroy, [:reload_data, '', :find]
-
-      class << self
-        def endpoint(project_id, contributor_id = nil)
-          path_from projects: project_id,
-                    contributors: contributor_id
-        end
-      end
+      MAIN_PARAMS = %i[project_id user_id].freeze
     end
   end
 end

data/lib/ruby_lokalise_api/resources/custom_translation_status.rb

@@ -3,19 +3,7 @@
 module RubyLokaliseApi
   module Resources
     class CustomTranslationStatus < Base
-      ID_KEY = 'status_id'
-      supports :update, :destroy, [:reload_data, '', :find]
-
-      class << self
-        def colors(client, path, *_args)
-          get(path, client)['content']['colors']
-        end
-
-        def endpoint(project_id, status_id = nil)
-          path_from projects: project_id,
-                    custom_translation_statuses: status_id
-        end
-      end
+      MAIN_PARAMS = %i[project_id status_id].freeze
     end
   end
 end

data/lib/ruby_lokalise_api/resources/file.rb

@@ -3,22 +3,8 @@
 module RubyLokaliseApi
   module Resources
     class File < Base
-      class << self
-        def download(client, path, params)
-          post(path, client, params)['content']
-        end
-
-        def upload(client, path, params)
-          klass = RubyLokaliseApi::Resources::QueuedProcess
-          klass.new post(path, client, params),
-                    ->(project_id, id) { klass.endpoint(project_id, id) }
-        end
-
-        def endpoint(project_id, action = '')
-          path_from projects: project_id,
-                    files: action
-        end
-      end
+      MAIN_PARAMS = %i[project_id file_id].freeze
+      no_support_for %i[update reload_data]
     end
   end
 end

data/lib/ruby_lokalise_api/resources/jwt.rb

@@ -3,11 +3,8 @@
 module RubyLokaliseApi
   module Resources
     class Jwt < Base
-      class << self
-        def endpoint(*_args)
-          path_from 'jwt-tokens': 'ota'
-        end
-      end
+      MAIN_PARAMS = :project_id
+      no_support_for %i[update destroy reload_data]
     end
   end
 end

data/lib/ruby_lokalise_api/resources/key.rb

@@ -3,15 +3,12 @@
 module RubyLokaliseApi
   module Resources
     class Key < Base
-      ID_KEY = 'key_id'
-      supports :update, :destroy, [:reload_data, '', :find]
+      MAIN_PARAMS = %i[project_id key_id].freeze
 
-      class << self
-        def endpoint(project_id, key_id = nil)
-          path_from projects: project_id,
-                    keys: key_id
-        end
-      end
+      delegate_call :key_comment, :comment
+      delegate_call :key_comments, :comments
+      delegate_call :create_comments
+      delegate_call :destroy_comment
     end
   end
 end

data/lib/ruby_lokalise_api/resources/oauth2_refreshed_token.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RubyLokaliseApi
+  module Resources
+    class OAuth2RefreshedToken < Base
+      no_support_for %i[update destroy reload_data]
+    end
+  end
+end

data/lib/ruby_lokalise_api/resources/oauth2_token.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RubyLokaliseApi
+  module Resources
+    class OAuth2Token < Base
+      no_support_for %i[update destroy reload_data]
+    end
+  end
+end

data/lib/ruby_lokalise_api/resources/order.rb

@@ -3,15 +3,8 @@
 module RubyLokaliseApi
   module Resources
     class Order < Base
-      ID_KEY = 'order_id'
-      supports [:reload_data, '', :find]
-
-      class << self
-        def endpoint(team_id, order_id = nil)
-          path_from teams: team_id,
-                    orders: order_id
-        end
-      end
+      MAIN_PARAMS = %i[team_id order_id].freeze
+      no_support_for %i[update destroy]
     end
   end
 end

data/lib/ruby_lokalise_api/resources/payment_card.rb

@@ -3,14 +3,8 @@
 module RubyLokaliseApi
   module Resources
     class PaymentCard < Base
-      ID_KEY = 'card_id'
-      supports :destroy, [:reload_data, '', :find]
-
-      class << self
-        def endpoint(card_id = nil)
-          path_from payment_cards: card_id
-        end
-      end
+      MAIN_PARAMS = %i[card_id].freeze
+      no_support_for %i[update]
     end
   end
 end

data/lib/ruby_lokalise_api/resources/project.rb

@@ -3,22 +3,91 @@
 module RubyLokaliseApi
   module Resources
     class Project < Base
-      ID_KEY = 'project_id'
-      supports :update, :destroy, [:reload_data, '', :find]
-
-      def empty
-        self.class.empty @client, "#{@path}/empty"
-      end
-
-      class << self
-        def empty(client, path, *_args)
-          put(path, client)['content']
-        end
-
-        def endpoint(project_id = nil, action = nil)
-          path_from projects: [project_id, action]
-        end
-      end
+      MAIN_PARAMS = :project_id
+
+      delegate_call :empty, :empty_project
+
+      delegate_call :branches
+      delegate_call :branch
+      delegate_call :create_branch
+      delegate_call :update_branch
+      delegate_call :destroy_branch
+      delegate_call :merge_branch
+
+      delegate_call :key_comment, :comment
+      delegate_call :key_comments, :comments
+      delegate_call :project_comments
+      delegate_call :create_comments
+      delegate_call :destroy_comment
+
+      delegate_call :contributor
+      delegate_call :contributors
+      delegate_call :create_contributors
+      delegate_call :update_contributor
+      delegate_call :destroy_contributor
+
+      delegate_call :custom_translation_status
+      delegate_call :custom_translation_statuses
+      delegate_call :create_custom_translation_status
+      delegate_call :update_custom_translation_status
+      delegate_call :destroy_custom_translation_status
+      delegate_call :custom_translation_status_colors
+
+      delegate_call :files
+      delegate_call :upload_file
+      delegate_call :download_files
+      delegate_call :destroy_file
+
+      delegate_call :create_jwt
+
+      delegate_call :keys
+      delegate_call :key
+      delegate_call :create_keys
+      delegate_call :update_key
+      delegate_call :update_keys
+      delegate_call :destroy_key
+      delegate_call :destroy_keys
+
+      delegate_call :languages, :project_languages
+      delegate_call :language, :project_language
+      delegate_call :create_languages, :create_project_languages
+      delegate_call :update_language, :update_project_language
+      delegate_call :destroy_language, :destroy_project_language
+
+      delegate_call :queued_process
+      delegate_call :queued_processes
+
+      delegate_call :segments
+      delegate_call :segment
+      delegate_call :update_segment
+
+      delegate_call :screenshots
+      delegate_call :screenshot
+      delegate_call :create_screenshots
+      delegate_call :update_screenshot
+      delegate_call :destroy_screenshot
+
+      delegate_call :snapshots
+      delegate_call :create_snapshot
+      delegate_call :restore_snapshot
+      delegate_call :destroy_snapshot
+
+      delegate_call :tasks
+      delegate_call :task
+      delegate_call :create_task
+      delegate_call :update_task
+      delegate_call :destroy_task
+
+      delegate_call :translations
+      delegate_call :translation
+      delegate_call :update_translation
+
+      delegate_call :webhooks
+      delegate_call :webhook
+      delegate_call :create_webhook
+      delegate_call :update_webhook
+      delegate_call :regenerate_webhook_secret
+      delegate_call :destroy_webhook
     end
   end
 end

data/lib/ruby_lokalise_api/resources/project_language.rb

@@ -3,16 +3,8 @@
 module RubyLokaliseApi
   module Resources
     class ProjectLanguage < Base
-      DATA_KEY = 'Language'
-      ID_KEY = 'lang_id'
-      supports :update, :destroy, [:reload_data, '', :find]
-
-      class << self
-        def endpoint(project_id, language_id = nil)
-          path_from projects: project_id,
-                    languages: language_id
-        end
-      end
+      MAIN_PARAMS = %i[project_id lang_id].freeze
+      DATA_KEY = 'language'
     end
   end
 end

data/lib/ruby_lokalise_api/resources/queued_process.rb

@@ -3,16 +3,9 @@
 module RubyLokaliseApi
   module Resources
     class QueuedProcess < Base
-      DATA_KEY = 'Process'
-      ID_KEY = 'process_id'
-      supports [:reload_data, '', :find]
-
-      class << self
-        def endpoint(project_id, process_id = nil)
-          path_from projects: project_id,
-                    processes: process_id
-        end
-      end
+      MAIN_PARAMS = %i[project_id process_id].freeze
+      no_support_for %i[update destroy]
+      DATA_KEY = 'process'
     end
   end
 end

data/lib/ruby_lokalise_api/resources/screenshot.rb

@@ -3,15 +3,7 @@
 module RubyLokaliseApi
   module Resources
     class Screenshot < Base
-      ID_KEY = 'screenshot_id'
-      supports :update, :destroy, [:reload_data, '', :find]
-
-      class << self
-        def endpoint(project_id, screenshot_id = nil)
-          path_from projects: project_id,
-                    screenshots: screenshot_id
-        end
-      end
+      MAIN_PARAMS = %i[project_id screenshot_id].freeze
     end
   end
 end

data/lib/ruby_lokalise_api/resources/segment.rb

@@ -3,17 +3,8 @@
 module RubyLokaliseApi
   module Resources
     class Segment < Base
-      DATA_KEY = 'Segment'
-      ID_KEY = 'segment_number'
-      supports :update, [:reload_data, '', :find]
-
-      class << self
-        def endpoint(project_id, key_id, lang_iso, segment_number = nil)
-          path_from projects: project_id,
-                    keys: key_id,
-                    segments: [lang_iso, segment_number]
-        end
-      end
+      MAIN_PARAMS = %i[project_id key_id language_iso segment_number].freeze
+      no_support_for %i[destroy]
     end
   end
 end