deepl-rb 3.6.1 → 3.7.0

data/spec/fixtures/vcr_cassettes/translate_texts.yml

@@ -10367,7 +10367,7 @@ http_interactions:
       - de2645cb65c3418db54e3bdefd35fe52
     body:
       encoding: ASCII-8BIT
-      string: '{"translations":[{"detected_source_language":"EN","text":"Beispieltext","model_type_used":"latency_optimized"}]}'
+      string: '{"translations":[{"detected_source_language":"EN","text":"Beispieltext","model_type_used":"quality_optimized"}]}'
   recorded_at: Fri, 15 Nov 2024 11:35:22 GMT
 - request:
     method: post

data/spec/fixtures/vcr_cassettes/translation_memories.yml

@@ -0,0 +1,74 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: https://api.deepl.com/v3/translation_memories
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Authorization:
+      - DeepL-Auth-Key VALID_TOKEN
+      User-Agent:
+      - deepl-ruby/3.0.2 (darwin24) ruby/3.2.2
+      Content-Type:
+      - application/json
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Content-Type:
+      - application/json; charset=utf-8
+      Date:
+      - Tue, 22 Apr 2026 10:00:00 GMT
+      X-Trace-Id:
+      - abc123def456
+      Access-Control-Expose-Headers:
+      - Server-Timing, X-Trace-ID
+      Strict-Transport-Security:
+      - max-age=63072000; includeSubDomains; preload
+      Transfer-Encoding:
+      - chunked
+      Vary:
+      - Accept-Encoding
+    body:
+      encoding: ASCII-8BIT
+      string: '{"translation_memories":[{"translation_memory_id":"a74d88fb-ed2a-4943-a664-a4512398b994","name":"Legal","source_language":"en","target_languages":["es","de"],"segment_count":3542},{"translation_memory_id":"855d36ab-6112-4ef5-8868-0d69bc4d826a","name":"Medical
+        terms","source_language":"de","target_languages":["fr","ja","zh"],"segment_count":23}],"total_count":2}'
+  recorded_at: Tue, 22 Apr 2026 10:00:00 GMT
+- request:
+    method: get
+    uri: https://api.deepl.com/v3/translation_memories
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Authorization:
+      - DeepL-Auth-Key invalid
+      User-Agent:
+      - deepl-ruby/3.0.2 (darwin24) ruby/3.2.2
+      Content-Type:
+      - application/json
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+  response:
+    status:
+      code: 403
+      message: Forbidden
+    headers:
+      Content-Type:
+      - application/json; charset=utf-8
+      Date:
+      - Tue, 22 Apr 2026 10:00:01 GMT
+    body:
+      encoding: ASCII-8BIT
+      string: '{"message":"Forbidden"}'
+  recorded_at: Tue, 22 Apr 2026 10:00:01 GMT
+recorded_with: VCR 6.3.1

data/spec/integration_tests/style_rule_api_spec.rb

@@ -65,6 +65,62 @@ describe DeepL::StyleRuleApi do
     end
   end
 
+  describe 'style rule management operations' do
+    it 'when performing all management operations on style rules' do # rubocop:disable RSpec/ExampleLength,RSpec/MultipleExpectations
+      skip 'Only runs on mock server' if real_server?
+
+      # Create a style rule
+      style_rule = DeepL.style_rules.create('Test Style Rule', 'en')
+      expect(style_rule).to be_a(DeepL::Resources::StyleRule)
+      expect(style_rule.style_id).not_to be_nil
+      style_id = style_rule.style_id
+
+      # Find the style rule
+      found_rule = DeepL.style_rules.find(style_id)
+      expect(found_rule).to be_a(DeepL::Resources::StyleRule)
+      expect(found_rule.style_id).to eq(style_id)
+
+      # Update the style rule name
+      updated_rule = DeepL.style_rules.update_name(style_id, 'Updated Style Rule')
+      expect(updated_rule).to be_a(DeepL::Resources::StyleRule)
+
+      # Update configured rules
+      configured_rules = {
+        'dates_and_times' => { 'calendar_era' => 'use_bc_and_ad' }
+      }
+      updated_rule = DeepL.style_rules.update_configured_rules(style_id, configured_rules)
+      expect(updated_rule).to be_a(DeepL::Resources::StyleRule)
+
+      # Create a custom instruction
+      custom_instruction = DeepL.style_rules.create_custom_instruction(
+        style_id, 'Test Instruction', 'Always use formal language'
+      )
+      expect(custom_instruction).to be_a(DeepL::Resources::CustomInstruction)
+      expect(custom_instruction.id).not_to be_nil
+      instruction_id = custom_instruction.id
+
+      # Find a custom instruction
+      fetched_instruction = DeepL.style_rules.find_custom_instruction(style_id, instruction_id)
+      expect(fetched_instruction).to be_a(DeepL::Resources::CustomInstruction)
+      expect(fetched_instruction.id).to eq(instruction_id)
+
+      # Update a custom instruction
+      updated_instruction = DeepL.style_rules.update_custom_instruction(
+        style_id, instruction_id, 'Updated Instruction', 'Use casual language'
+      )
+      expect(updated_instruction).to be_a(DeepL::Resources::CustomInstruction)
+
+      # Destroy the custom instruction
+      deleted_instruction_id = DeepL.style_rules.destroy_custom_instruction(style_id,
+                                                                            instruction_id)
+      expect(deleted_instruction_id).to eq(instruction_id)
+
+      # Destroy the style rule
+      deleted_style_id = DeepL.style_rules.destroy(style_id)
+      expect(deleted_style_id).to eq(style_id)
+    end
+  end
+
   def build_test_style_rule
     style_rule_data = {
       'style_id' => 'dca2e053-8ae5-45e6-a0d2-881156e7f4e4',

data/spec/integration_tests/translation_memory_api_spec.rb

@@ -0,0 +1,70 @@
+# 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 file.
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::TranslationMemoryApi do
+  before do
+    VCR.turn_off!
+    WebMock.allow_net_connect!
+  end
+
+  after do
+    VCR.turn_on!
+    WebMock.disable_net_connect!
+  end
+
+  describe '#translate_with_translation_memory' do
+    it 'when performing a request with translation_memory_id' do
+      skip 'Only runs on mock server' if real_server?
+
+      source_lang = 'DE'
+      target_lang = 'EN'
+      text = 'Protonenstrahl'
+      translation_memory_id = 'a74d88fb-ed2a-4943-a664-a4512398b994'
+
+      result = DeepL.translate(text, source_lang, target_lang,
+                               { translation_memory: translation_memory_id })
+      expect(result).to be_a(DeepL::Resources::Text)
+    end
+
+    it 'when performing a request with translation_memory resource object' do
+      skip 'Only runs on mock server' if real_server?
+
+      source_lang = 'DE'
+      target_lang = 'EN'
+      text = 'Protonenstrahl'
+      translation_memory = build_test_translation_memory
+
+      result = DeepL.translate(text, source_lang, target_lang,
+                               { translation_memory: translation_memory })
+      expect(result).to be_a(DeepL::Resources::Text)
+    end
+  end
+
+  describe '#list_translation_memories' do
+    it 'when requesting a list of all translation memories' do
+      skip 'Only runs on mock server' if real_server?
+
+      translation_memories = DeepL.translation_memories.list
+      expect(translation_memories).to be_an(Array)
+      expect(translation_memories).not_to be_empty
+      expect(translation_memories.first).to be_a(DeepL::Resources::TranslationMemory)
+      expect(translation_memories.first.translation_memory_id).not_to be_nil
+      expect(translation_memories.first.name).not_to be_nil
+    end
+  end
+
+  def build_test_translation_memory
+    tm_data = {
+      'translation_memory_id' => 'a74d88fb-ed2a-4943-a664-a4512398b994',
+      'name' => 'Default Translation Memory',
+      'source_language' => 'DE',
+      'target_languages' => %w[EN ES FR],
+      'segment_count' => 3542
+    }
+    DeepL::Resources::TranslationMemory.new(tm_data, nil, nil)
+  end
+end

data/spec/requests/style_rule/create_custom_instruction_spec.rb

@@ -0,0 +1,54 @@
+# 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
+
+require 'spec_helper'
+
+describe DeepL::Requests::StyleRule::CreateCustomInstruction do
+  subject(:create_instruction) { described_class.new(api, style_id, label, prompt, nil, options) }
+
+  around do |tests|
+    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
+    tests.call
+    ENV.replace(tmp_env)
+  end
+
+  let(:api) { build_deepl_api }
+  let(:style_id) { 'dca2e053-8ae5-45e6-a0d2-881156e7f4e4' }
+  let(:label) { 'Test Instruction' }
+  let(:prompt) { 'Always use formal language' }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(create_instruction).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('style_rules_crud') { example.call }
+    end
+
+    context 'when performing a valid request' do
+      subject(:create_instruction) do
+        described_class.new(api, new_rule.style_id, label, prompt)
+      end
+
+      let(:new_rule) do
+        DeepL::Requests::StyleRule::Create.new(api, 'Instruction Test', 'en').request
+      end
+
+      it 'returns a custom instruction object' do
+        instruction = create_instruction.request
+        expect(instruction).to be_a(DeepL::Resources::CustomInstruction)
+        expect(instruction.id).to be_a(String)
+        expect(instruction.label).to eq('Test Instruction')
+        expect(instruction.prompt).to eq('Always use formal language')
+      end
+    end
+  end
+end

data/spec/requests/style_rule/create_spec.rb

@@ -0,0 +1,45 @@
+# 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
+
+require 'spec_helper'
+
+describe DeepL::Requests::StyleRule::Create do
+  subject(:create) { described_class.new(api, name, language, options) }
+
+  around do |tests|
+    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
+    tests.call
+    ENV.replace(tmp_env)
+  end
+
+  let(:api) { build_deepl_api }
+  let(:name) { 'Test Style Rule' }
+  let(:language) { 'en' }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(create).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('style_rules_crud') { example.call }
+    end
+
+    context 'when performing a valid request' do
+      it 'returns a style rule object' do
+        style_rule = create.request
+        expect(style_rule).to be_a(DeepL::Resources::StyleRule)
+        expect(style_rule.style_id).to be_a(String)
+        expect(style_rule.name).to eq('Test Style Rule')
+        expect(style_rule.language).to eq('en')
+      end
+    end
+  end
+end

data/spec/requests/style_rule/destroy_custom_instruction_spec.rb

@@ -0,0 +1,54 @@
+# 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
+
+require 'spec_helper'
+
+describe DeepL::Requests::StyleRule::DestroyCustomInstruction do
+  subject(:destroy_instruction) { described_class.new(api, style_id, instruction_id) }
+
+  around do |tests|
+    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
+    tests.call
+    ENV.replace(tmp_env)
+  end
+
+  let(:api) { build_deepl_api }
+  let(:style_id) { 'dca2e053-8ae5-45e6-a0d2-881156e7f4e4' }
+  let(:instruction_id) { 'test-instruction-id' }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(destroy_instruction).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('style_rules_crud') { example.call }
+    end
+
+    context 'when performing a valid request' do
+      subject(:destroy_instruction) do
+        described_class.new(api, new_rule.style_id, new_instruction.id)
+      end
+
+      let(:new_rule) do
+        DeepL::Requests::StyleRule::Create.new(api, 'Destroy Instruction Test', 'en').request
+      end
+      let(:new_instruction) do
+        DeepL::Requests::StyleRule::CreateCustomInstruction.new(
+          api, new_rule.style_id, 'To Delete', 'Delete me'
+        ).request
+      end
+
+      it 'returns the deleted instruction id' do
+        response = destroy_instruction.request
+        expect(response).to eq(new_instruction.id)
+      end
+    end
+  end
+end

data/spec/requests/style_rule/destroy_spec.rb

@@ -0,0 +1,54 @@
+# 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
+
+require 'spec_helper'
+
+describe DeepL::Requests::StyleRule::Destroy do
+  subject(:destroy) { described_class.new(api, style_id) }
+
+  around do |tests|
+    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
+    tests.call
+    ENV.replace(tmp_env)
+  end
+
+  let(:api) { build_deepl_api }
+  let(:style_id) { 'dca2e053-8ae5-45e6-a0d2-881156e7f4e4' }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(destroy).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('style_rules_crud') { example.call }
+    end
+
+    context 'when performing a valid request' do
+      subject(:destroy) { described_class.new(api, new_rule.style_id) }
+
+      let(:new_rule) do
+        DeepL::Requests::StyleRule::Create.new(api, 'Destroy Test', 'en').request
+      end
+
+      it 'returns the deleted style rule id' do
+        response = destroy.request
+        expect(response).to eq(new_rule.style_id)
+      end
+    end
+
+    context 'when deleting a non existing style rule with an invalid id' do
+      let(:style_id) { 'invalid-uuid' }
+
+      it 'raises an error' do
+        expect { destroy.request }.to raise_error(DeepL::Exceptions::Error)
+      end
+    end
+  end
+end

data/spec/requests/style_rule/find_custom_instruction_spec.rb

@@ -0,0 +1,56 @@
+# 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
+
+require 'spec_helper'
+
+describe DeepL::Requests::StyleRule::FindCustomInstruction do
+  subject(:find_instruction) { described_class.new(api, style_id, instruction_id, options) }
+
+  around do |tests|
+    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
+    tests.call
+    ENV.replace(tmp_env)
+  end
+
+  let(:api) { build_deepl_api }
+  let(:style_id) { 'dca2e053-8ae5-45e6-a0d2-881156e7f4e4' }
+  let(:instruction_id) { 'test-instruction-id' }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(find_instruction).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('style_rules_crud') { example.call }
+    end
+
+    context 'when performing a valid request' do
+      subject(:find_instruction) do
+        described_class.new(api, new_rule.style_id, new_instruction.id)
+      end
+
+      let(:new_rule) do
+        DeepL::Requests::StyleRule::Create.new(api, 'Find Instruction Test', 'en').request
+      end
+      let(:new_instruction) do
+        DeepL::Requests::StyleRule::CreateCustomInstruction.new(
+          api, new_rule.style_id, 'Test', 'Test prompt'
+        ).request
+      end
+
+      it 'returns a custom instruction object' do
+        instruction = find_instruction.request
+        expect(instruction).to be_a(DeepL::Resources::CustomInstruction)
+        expect(instruction.id).to eq(new_instruction.id)
+      end
+    end
+  end
+end

data/spec/requests/style_rule/find_spec.rb

@@ -0,0 +1,56 @@
+# 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
+
+require 'spec_helper'
+
+describe DeepL::Requests::StyleRule::Find do
+  subject(:style_rule_find) { described_class.new(api, style_id, options) }
+
+  around do |tests|
+    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
+    tests.call
+    ENV.replace(tmp_env)
+  end
+
+  let(:api) { build_deepl_api }
+  let(:style_id) { 'dca2e053-8ae5-45e6-a0d2-881156e7f4e4' }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(style_rule_find).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('style_rules_crud') { example.call }
+    end
+
+    context 'when performing a valid request' do
+      subject(:style_rule_find) do
+        new_rule = DeepL::Requests::StyleRule::Create.new(api, 'Find Test', 'en').request
+        described_class.new(api, new_rule.style_id, options)
+      end
+
+      it 'returns a style rule object' do
+        style_rule = style_rule_find.request
+        expect(style_rule).to be_a(DeepL::Resources::StyleRule)
+        expect(style_rule.style_id).to be_a(String)
+        expect(style_rule.name).to be_a(String)
+      end
+    end
+
+    context 'when requesting a non existing style rule with an invalid id' do
+      let(:style_id) { 'invalid-uuid' }
+
+      it 'raises an error' do
+        expect { style_rule_find.request }.to raise_error(DeepL::Exceptions::Error)
+      end
+    end
+  end
+end

data/spec/requests/style_rule/list_spec.rb

@@ -0,0 +1,58 @@
+# 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
+
+require 'spec_helper'
+
+describe DeepL::Requests::StyleRule::List do
+  subject(:style_rule_list) { described_class.new(api, options) }
+
+  around do |tests|
+    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
+    tests.call
+    ENV.replace(tmp_env)
+  end
+
+  let(:api) { build_deepl_api }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(style_rule_list).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('style_rules') { example.call }
+    end
+
+    context 'when requesting a list of all style rules' do
+      it 'returns an array of style rules' do
+        style_rules = style_rule_list.request
+        expect(style_rules).to be_an(Array)
+        expect(style_rules).not_to be_empty
+        expect(style_rules.first).to be_a(DeepL::Resources::StyleRule)
+        expect(style_rules.first.style_id).to be_a(String)
+        expect(style_rules.first.name).to be_a(String)
+      end
+    end
+
+    context 'when performing a bad request' do
+      context 'when using an invalid token' do
+        let(:api) do
+          api = build_deepl_api
+          api.configuration.auth_key = 'invalid'
+          api
+        end
+
+        it 'raises an authorization failed error' do
+          expect { style_rule_list.request }.to raise_error(DeepL::Exceptions::AuthorizationFailed)
+        end
+      end
+    end
+  end
+end

data/spec/requests/style_rule/update_configured_rules_spec.rb

@@ -0,0 +1,52 @@
+# 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
+
+require 'spec_helper'
+
+describe DeepL::Requests::StyleRule::UpdateConfiguredRules do
+  subject(:update_configured_rules) do
+    described_class.new(api, style_id, configured_rules, options)
+  end
+
+  around do |tests|
+    tmp_env = replace_env_preserving_deepl_vars_except_mock_server
+    tests.call
+    ENV.replace(tmp_env)
+  end
+
+  let(:api) { build_deepl_api }
+  let(:style_id) { 'dca2e053-8ae5-45e6-a0d2-881156e7f4e4' }
+  let(:configured_rules) { { 'dates_and_times' => { 'calendar_era' => 'use_bc_and_ad' } } }
+  let(:options) { {} }
+
+  describe '#initialize' do
+    context 'when building a request' do
+      it 'creates a request object' do
+        expect(update_configured_rules).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('style_rules_crud') { example.call }
+    end
+
+    context 'when performing a valid request' do
+      subject(:update_configured_rules) do
+        described_class.new(api, new_rule.style_id, configured_rules)
+      end
+
+      let(:new_rule) do
+        DeepL::Requests::StyleRule::Create.new(api, 'Configured Rules Test', 'en').request
+      end
+
+      it 'returns a style rule object' do
+        style_rule = update_configured_rules.request
+        expect(style_rule).to be_a(DeepL::Resources::StyleRule)
+      end
+    end
+  end
+end