deepl-rb 3.9.0 → 3.10.0

data/lib/deepl/requests/multilingual_glossary/helpers.rb

@@ -0,0 +1,63 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    module MultilingualGlossary
+      # Encoding shared by the v3 glossary requests.
+      module Helpers
+        private
+
+        def glossary_id(glossary)
+          return glossary.id if glossary.is_a?(DeepL::Resources::MultilingualGlossary)
+
+          glossary.to_s
+        end
+
+        # The path of a glossary, with its ID URL-encoded.
+        def glossary_path(id, suffix = nil)
+          ["glossaries/#{escape_path_segment(id)}", suffix].compact.join('/')
+        end
+
+        # Accepts a MultilingualGlossaryDictionaryEntries object or a hash with +:source_lang+,
+        # +:target_lang+, +:entries+ and optionally +:entries_format+ (default +tsv+). Only a CSV
+        # string is sent as CSV; all other entries are converted and sent as TSV.
+        def dictionary_payload(dictionary)
+          if dictionary.is_a?(DeepL::Resources::MultilingualGlossaryDictionaryEntries)
+            return { source_lang: dictionary.source_lang, target_lang: dictionary.target_lang,
+                     entries: entries_to_string(dictionary.entries), entries_format: 'tsv' }
+          end
+
+          value = ->(key) { dictionary[key] || dictionary[key.to_s] }
+          entries = value.call(:entries)
+          # CSV content is sent as given; TSV content is parsed so its terms are checked too.
+          csv = value.call(:entries_format) == 'csv' && entries.is_a?(String)
+          { source_lang: value.call(:source_lang), target_lang: value.call(:target_lang),
+            entries: csv ? entries : entries_to_string(entries),
+            entries_format: csv ? 'csv' : 'tsv' }
+        end
+
+        # A hash, source/target pairs or a TSV string of them, checked and joined as TSV.
+        def entries_to_string(entries)
+          entries_class = Resources::MultilingualGlossaryDictionaryEntries
+          entries = entries.is_a?(String) ? entries_class.tsv_to_pairs(entries) : entries.to_a
+          entries_class.check_pairs!(entries).map do |entry|
+            source = Utils::TermValidator.validate!(entry.first)
+            target = Utils::TermValidator.validate!(entry.last)
+            "#{source}\t#{target}"
+          end.join("\n")
+        end
+
+        def build_glossary(request, response)
+          Resources::MultilingualGlossary.new(JSON.parse(response.body), request, response)
+        end
+
+        def uri
+          @uri ||= URI("#{host}/v3/#{path}")
+        end
+      end
+    end
+  end
+end

data/lib/deepl/requests/multilingual_glossary/list.rb

@@ -0,0 +1,39 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    module MultilingualGlossary
+      class List < Base
+        include Helpers
+
+        def initialize(api, options = {})
+          super
+        end
+
+        def request
+          build_glossary_list(*execute_request_with_retries(get_request))
+        end
+
+        def to_s
+          "GET #{uri.request_uri}"
+        end
+
+        private
+
+        def build_glossary_list(request, response)
+          data = JSON.parse(response.body)
+          data['glossaries'].map do |glossary|
+            Resources::MultilingualGlossary.new(glossary, request, response)
+          end
+        end
+
+        def path
+          'glossaries'
+        end
+      end
+    end
+  end
+end

data/lib/deepl/requests/multilingual_glossary/replace_dictionary.rb

@@ -0,0 +1,41 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    module MultilingualGlossary
+      class ReplaceDictionary < Base
+        include Helpers
+
+        attr_reader :id, :dictionary
+
+        def initialize(api, id, dictionary, options = {})
+          super(api, options)
+          @id = glossary_id(id)
+          @dictionary = dictionary_payload(dictionary)
+        end
+
+        def request
+          build_dictionary(*execute_request_with_retries(put_request(dictionary)))
+        end
+
+        def to_s
+          "PUT #{uri.request_uri}"
+        end
+
+        private
+
+        def build_dictionary(request, response)
+          data = JSON.parse(response.body)
+          Resources::MultilingualGlossaryDictionary.new(data, request, response)
+        end
+
+        def path
+          glossary_path(id, 'dictionaries')
+        end
+      end
+    end
+  end
+end

data/lib/deepl/requests/multilingual_glossary/update.rb

@@ -0,0 +1,40 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    module MultilingualGlossary
+      class Update < Base
+        include Helpers
+
+        attr_reader :id, :name, :dictionaries
+
+        def initialize(api, id, name, dictionaries, options = {})
+          super(api, options)
+          @id = glossary_id(id)
+          @name = name
+          @dictionaries = dictionaries&.map { |dictionary| dictionary_payload(dictionary) }
+        end
+
+        def request
+          payload = {}
+          payload[:name] = name unless name.nil?
+          payload[:dictionaries] = dictionaries unless dictionaries.nil?
+          build_glossary(*execute_request_with_retries(patch_request(payload)))
+        end
+
+        def to_s
+          "PATCH #{uri.request_uri}"
+        end
+
+        private
+
+        def path
+          glossary_path(id)
+        end
+      end
+    end
+  end
+end

data/lib/deepl/requests/rephrase.rb

@@ -6,6 +6,8 @@
 module DeepL
   module Requests
     class Rephrase < Base
+      include WriteImprovements
+
       attr_reader :text, :target_lang, :writing_style, :tone
 
       def initialize(api, text, target_lang = nil, writing_style = nil, tone = nil, options = {}, # rubocop:disable Metrics/ParameterLists
@@ -27,8 +29,8 @@ module DeepL
       end
 
       def details
-        "HTTP Headers: #{headers}\nPayload #{{ text: text, target_lang: target_lang,
-                                               writing_style: writing_style, tone: tone }}"
+        "HTTP Headers: #{loggable_headers}\nPayload #{{ text: text, target_lang: target_lang,
+                                                        writing_style: writing_style, tone: tone }}"
       end
 
       def to_s
@@ -38,13 +40,7 @@ module DeepL
       private
 
       def build_texts(request, response)
-        data = JSON.parse(response.body)
-
-        texts = data['improvements'].map do |improvement|
-          Resources::Text.new(improvement['text'], improvement['detected_source_language'], nil,
-                              request, response)
-        end
-
+        texts = build_improvements(text.is_a?(Array) ? text.size : 1, request, response)
         texts.size == 1 ? texts.first : texts
       end
 

data/lib/deepl/requests/spoken_terms/create.rb

@@ -0,0 +1,37 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    module SpokenTerms
+      class Create < Base
+        include Helpers
+
+        attr_reader :name, :term_lists
+
+        def initialize(api, name, term_lists, options = {})
+          super(api, options)
+          @name = name
+          @term_lists = term_lists
+        end
+
+        def request
+          payload = { name: name, term_lists: term_lists_payload(term_lists) }
+          build_spoken_terms(*execute_request_with_retries(post_request(payload)))
+        end
+
+        def to_s
+          "POST #{uri.request_uri}"
+        end
+
+        private
+
+        def path
+          'spoken-terms'
+        end
+      end
+    end
+  end
+end

data/lib/deepl/requests/spoken_terms/destroy.rb

@@ -0,0 +1,36 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    module SpokenTerms
+      class Destroy < Base
+        include Helpers
+
+        attr_reader :id
+
+        def initialize(api, id)
+          super(api)
+          @id = spoken_terms_id(id)
+        end
+
+        def request
+          execute_request_with_retries(delete_request)
+          nil
+        end
+
+        def to_s
+          "DELETE #{uri.request_uri}"
+        end
+
+        private
+
+        def path
+          spoken_terms_path(id)
+        end
+      end
+    end
+  end
+end

data/lib/deepl/requests/spoken_terms/destroy_term_list.rb

@@ -0,0 +1,41 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    module SpokenTerms
+      class DestroyTermList < Base
+        include Helpers
+
+        attr_reader :id, :lang
+
+        def initialize(api, id, lang)
+          super(api)
+          @id = spoken_terms_id(id)
+          @lang = lang
+        end
+
+        def request
+          execute_request_with_retries(delete_request)
+          nil
+        end
+
+        def to_s
+          "DELETE #{uri.request_uri}"
+        end
+
+        private
+
+        def uri
+          @uri ||= URI("#{host}/v3/#{path}?#{encode_query(lang: lang)}")
+        end
+
+        def path
+          spoken_terms_path(id, 'term-lists')
+        end
+      end
+    end
+  end
+end

data/lib/deepl/requests/spoken_terms/entries.rb

@@ -0,0 +1,46 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    module SpokenTerms
+      class Entries < Base
+        include Helpers
+
+        attr_reader :id, :lang
+
+        def initialize(api, id, lang)
+          super(api)
+          @id = spoken_terms_id(id)
+          @lang = lang
+        end
+
+        def request
+          build_entries(*execute_request_with_retries(get_request))
+        end
+
+        def to_s
+          "GET #{uri.request_uri}"
+        end
+
+        private
+
+        def build_entries(request, response)
+          data = JSON.parse(response.body)
+          Resources::SpokenTermsEntries.new(data['lang'], entries_from_string(data['entries']),
+                                            request, response)
+        end
+
+        def uri
+          @uri ||= URI("#{host}/v3/#{path}?#{encode_query(lang: lang)}")
+        end
+
+        def path
+          spoken_terms_path(id, 'entries')
+        end
+      end
+    end
+  end
+end

data/lib/deepl/requests/spoken_terms/find.rb

@@ -0,0 +1,35 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    module SpokenTerms
+      class Find < Base
+        include Helpers
+
+        attr_reader :id
+
+        def initialize(api, id)
+          super(api)
+          @id = spoken_terms_id(id)
+        end
+
+        def request
+          build_spoken_terms(*execute_request_with_retries(get_request))
+        end
+
+        def to_s
+          "GET #{uri.request_uri}"
+        end
+
+        private
+
+        def path
+          spoken_terms_path(id)
+        end
+      end
+    end
+  end
+end

data/lib/deepl/requests/spoken_terms/helpers.rb

@@ -0,0 +1,67 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    module SpokenTerms
+      # Encoding shared by the spoken terms requests. The API sends and returns the terms of a
+      # language as one newline-separated string; the SDK exposes them as an array.
+      module Helpers
+        private
+
+        def spoken_terms_id(spoken_terms)
+          return spoken_terms.spoken_terms_id if spoken_terms.is_a?(DeepL::Resources::SpokenTerms)
+
+          spoken_terms.to_s
+        end
+
+        # The path of a collection, with its ID URL-encoded.
+        def spoken_terms_path(id, suffix = nil)
+          ["spoken-terms/#{escape_path_segment(id)}", suffix].compact.join('/')
+        end
+
+        def entries_to_string(entries)
+          entries.map { |entry| Utils::TermValidator.validate!(entry) }.join("\n")
+        end
+
+        def entries_from_string(entries)
+          (entries || '').split("\n").reject(&:empty?)
+        end
+
+        def term_lists_payload(term_lists)
+          term_lists.map { |term_list| term_list_payload(term_list) }
+        end
+
+        # Accepts a SpokenTermsEntries object or a hash with +:lang+ and +:entries+.
+        def term_list_payload(term_list)
+          lang, entries = if term_list.is_a?(DeepL::Resources::SpokenTermsEntries)
+                            [term_list.lang, term_list.entries]
+                          else
+                            [term_list[:lang] || term_list['lang'],
+                             term_list[:entries] || term_list['entries']]
+                          end
+          { lang: lang, entries: entries_to_string(entries) }
+        end
+
+        def build_spoken_terms(request, response)
+          Resources::SpokenTerms.new(JSON.parse(response.body), request, response)
+        end
+
+        def uri
+          @uri ||= URI("#{host}/v3/#{path}")
+        end
+
+        # GET and DELETE send no body.
+        def get_request # rubocop:disable Naming/AccessorMethodName
+          Net::HTTP::Get.new(uri.request_uri, add_json_content_type(headers))
+        end
+
+        def delete_request
+          Net::HTTP::Delete.new(uri.request_uri, add_json_content_type(headers))
+        end
+      end
+    end
+  end
+end

data/lib/deepl/requests/spoken_terms/list.rb

@@ -0,0 +1,35 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    module SpokenTerms
+      class List < Base
+        include Helpers
+
+        def request
+          build_spoken_terms_list(*execute_request_with_retries(get_request))
+        end
+
+        def to_s
+          "GET #{uri.request_uri}"
+        end
+
+        private
+
+        def build_spoken_terms_list(request, response)
+          data = JSON.parse(response.body)
+          (data['spoken_terms'] || []).map do |spoken_terms|
+            Resources::SpokenTerms.new(spoken_terms, request, response)
+          end
+        end
+
+        def path
+          'spoken-terms'
+        end
+      end
+    end
+  end
+end

data/lib/deepl/requests/spoken_terms/replace_term_list.rb

@@ -0,0 +1,41 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    module SpokenTerms
+      class ReplaceTermList < Base
+        include Helpers
+
+        attr_reader :id, :entries
+
+        def initialize(api, id, entries, options = {})
+          super(api, options)
+          @id = spoken_terms_id(id)
+          @entries = entries
+        end
+
+        def request
+          payload = term_list_payload(entries)
+          build_term_list(*execute_request_with_retries(put_request(payload)))
+        end
+
+        def to_s
+          "PUT #{uri.request_uri}"
+        end
+
+        private
+
+        def build_term_list(request, response)
+          Resources::SpokenTermsList.new(JSON.parse(response.body), request, response)
+        end
+
+        def path
+          spoken_terms_path(id, 'term-lists')
+        end
+      end
+    end
+  end
+end

data/lib/deepl/requests/spoken_terms/update.rb

@@ -0,0 +1,40 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    module SpokenTerms
+      class Update < Base
+        include Helpers
+
+        attr_reader :id, :name, :term_lists
+
+        def initialize(api, id, name, term_lists, options = {})
+          super(api, options)
+          @id = spoken_terms_id(id)
+          @name = name
+          @term_lists = term_lists
+        end
+
+        def request
+          payload = {}
+          payload[:name] = name unless name.nil?
+          payload[:term_lists] = term_lists_payload(term_lists) unless term_lists.nil?
+          build_spoken_terms(*execute_request_with_retries(patch_request(payload)))
+        end
+
+        def to_s
+          "PATCH #{uri.request_uri}"
+        end
+
+        private
+
+        def path
+          spoken_terms_path(id)
+        end
+      end
+    end
+  end
+end

data/lib/deepl/requests/style_profile/base.rb

@@ -0,0 +1,83 @@
+# Copyright 2026 DeepL SE (https://www.deepl.com)
+# Use of this source code is governed by an MIT
+# license that can be found in the LICENSE.md file.
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    module StyleProfile
+      # Common behaviour of the style profile requests: served under +v3+, with the ID escaped
+      # into the path and GET/DELETE sent without a body.
+      class Base < DeepL::Requests::Base
+        COMPONENT_ID_FIELDS = %i[glossary_ids style_rule_ids translation_memory_ids].freeze
+
+        private
+
+        def style_profile_id(style_profile)
+          id = if style_profile.is_a?(DeepL::Resources::StyleProfile)
+                 style_profile.style_profile_id.to_s
+               else
+                 style_profile.to_s
+               end
+          raise ArgumentError, 'style_profile_id must not be empty' if id.empty?
+
+          id
+        end
+
+        def escaped_id
+          URI.encode_www_form_component(id).gsub('+', '%20')
+        end
+
+        # Adds the optional fields that are set. nil is not sent; '' and [] are sent as given.
+        def optional_fields_payload(fields)
+          fields.each_with_object({}) do |(key, value), payload|
+            next if value.nil?
+
+            payload[key] = COMPONENT_ID_FIELDS.include?(key) ? component_ids(value) : value
+          end
+        end
+
+        # Replaces resource objects in a component list by their IDs; other entries are kept.
+        def component_ids(value)
+          return value unless value.is_a?(Array)
+
+          value.map { |component| component_id(component) }
+        end
+
+        def component_id(component)
+          case component
+          when DeepL::Resources::Glossary, DeepL::Resources::MultilingualGlossary then component.id
+          when DeepL::Resources::StyleRule then component.style_id
+          when DeepL::Resources::TranslationMemory then component.translation_memory_id
+          else component
+          end
+        end
+
+        def build_style_profile(request, response)
+          Resources::StyleProfile.new(JSON.parse(response.body), request, response)
+        end
+
+        def uri
+          @uri ||= begin
+            base_uri = URI("#{host}/v3/#{path}")
+            query_string = encode_query(query_params)
+            base_uri.query = query_string unless query_string.empty?
+            base_uri
+          end
+        end
+
+        def query_params
+          {}
+        end
+
+        def get_request # rubocop:disable Naming/AccessorMethodName
+          Net::HTTP::Get.new(uri.request_uri, add_json_content_type(headers))
+        end
+
+        def delete_request
+          Net::HTTP::Delete.new(uri.request_uri, add_json_content_type(headers))
+        end
+      end
+    end
+  end
+end