deepl-rb 3.9.0 → 3.10.0

data/spec/support/managed_glossary.rb

@@ -1,65 +0,0 @@
-# Copyright 2025 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
-
-module ManagedGlossary
-  # Bounded retry budget for tolerating a freshly-created glossary that is not
-  # yet resolvable on the real API (eventual consistency): up to ~10 seconds.
-  GLOSSARY_RETRY_ATTEMPTS = 20
-  GLOSSARY_RETRY_DELAY = 0.5
-
-  def with_managed_glossary(name:, source_lang:, target_lang:, entries:, options: {})
-    glossary = DeepL.glossaries.create(name, source_lang, target_lang, entries, options)
-    yield glossary
-  ensure
-    begin
-      DeepL.glossaries.destroy(glossary.id) if glossary
-    rescue StandardError
-      nil
-    end
-  end
-
-  # A just-created glossary is not always immediately resolvable by id on the
-  # real API (eventual consistency). Poll #find until each glossary is
-  # retrievable so subsequent calls (e.g. translate with glossary_ids) do not
-  # fail with a transient "Glossary <uuid> not found" error.
-  #
-  # Note: no keyword arguments here — Ruby 2.7 would fold a trailing options
-  # hash from callers into keywords, breaking positional-hash APIs.
-  def wait_until_glossaries_ready(*glossaries)
-    glossaries.each do |glossary|
-      remaining = GLOSSARY_RETRY_ATTEMPTS
-      begin
-        DeepL.glossaries.find(glossary.id)
-      rescue DeepL::Exceptions::RequestError
-        raise if (remaining -= 1) <= 0
-
-        sleep(GLOSSARY_RETRY_DELAY)
-        retry
-      end
-    end
-  end
-
-  # Translate with a bounded retry that tolerates a transient
-  # "Glossary <uuid> not found" error caused by eventual consistency on a
-  # freshly created glossary. Depending on timing the real API returns this as
-  # either a 400 or a 404, so match on the message rather than the status.
-  # Any other error is re-raised immediately.
-  #
-  # `options` is an explicit positional hash (matching DeepL.translate) rather
-  # than keyword arguments, so passing `{ glossary_ids: [...] }` works on Ruby
-  # 2.7 as well as 3.x.
-  def translate_retrying_missing_glossary(text, source_lang, target_lang, options = {})
-    remaining = GLOSSARY_RETRY_ATTEMPTS
-    begin
-      DeepL.translate(text, source_lang, target_lang, options)
-    rescue DeepL::Exceptions::RequestError => e
-      raise unless e.to_s.match?(/glossary .* not found/i)
-      raise if (remaining -= 1) <= 0
-
-      sleep(GLOSSARY_RETRY_DELAY)
-      retry
-    end
-  end
-end

data/spec/support/managed_style_rule.rb

@@ -1,17 +0,0 @@
-# Copyright 2025 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
-
-module ManagedStyleRule
-  def with_managed_style_rule(name:, language:, options: {})
-    style_rule = DeepL.style_rules.create(name, language, options)
-    yield style_rule
-  ensure
-    begin
-      DeepL.style_rules.destroy(style_rule.style_id) if style_rule
-    rescue StandardError
-      nil
-    end
-  end
-end

data/spec/support/managed_translation_memory.rb

@@ -1,55 +0,0 @@
-# Copyright 2025 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
-
-module ManagedTranslationMemory
-  # A minimal, valid TMX document to import in the translation memory specs.
-  EXAMPLE_TMX = <<~TMX
-    <?xml version="1.0" encoding="UTF-8"?>
-    <tmx version="1.4">
-      <header creationtool="deepl-rb-spec" srclang="de" segtype="sentence"
-              adminlang="en" datatype="plaintext" o-tmf="TMX"/>
-      <body>
-        <tu>
-          <tuv xml:lang="de"><seg>Quelltext Nummer 0</seg></tuv>
-          <tuv xml:lang="en"><seg>Source text number 0</seg></tuv>
-        </tu>
-      </body>
-    </tmx>
-  TMX
-
-  # Imports the TMX file at +input_file_path+ and yields the finished import job, deleting the
-  # resulting translation memory afterwards.
-  def with_managed_translation_memory(input_file_path, display_name: nil)
-    job = DeepL.translation_memories.import_from_filepath(input_file_path,
-                                                          display_name: display_name)
-    yield job
-  ensure
-    begin
-      DeepL.translation_memories.destroy(job.result.translation_memory_id) if job
-    rescue StandardError
-      nil
-    end
-  end
-
-  # Creates an import job for the TMX file at +input_file_path+ through +translation_memories+
-  # and uploads the file, then returns the created import. The mock server keeps the job in the
-  # `awaiting_input` status for +processing_polls+ status queries before completing it, standing
-  # in for the live API detecting the upload asynchronously.
-  def create_uploaded_import(translation_memories, input_file_path, processing_polls:)
-    file_content = File.binread(input_file_path)
-    created = translation_memories.create_import(
-      File.basename(input_file_path), file_content.bytesize,
-      additional_headers: tm_job_processing_polls_header(processing_polls)
-    )
-    translation_memories.upload_file(created, file_content)
-    created
-  end
-
-  # Writes the example TMX document to +path+ and returns the path.
-  def write_example_tmx(path)
-    File.write(path, EXAMPLE_TMX)
-    path
-  end
-end