deepl-rb 2.3.0 → 2.5.0

data/spec/requests/glossary/create_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::Glossary::Create do
+  let(:api) { build_deepl_api }
+  let(:name) { 'Mi Glosario' }
+  let(:source_lang) { 'EN' }
+  let(:target_lang) { 'ES' }
+  let(:entries) do
+    [
+      %w[Hello Hola],
+      %w[World Mundo]
+    ]
+  end
+  let(:entries_format) { 'tsv' }
+  let(:options) { {} }
+  subject do
+    DeepL::Requests::Glossary::Create.new(api, name, source_lang, target_lang, entries, options)
+  end
+
+  describe '#initialize' do
+    context 'When building a request' do
+      it 'should create a request object' do
+        expect(subject).to be_a(described_class)
+      end
+
+      it 'should set the default value for the entries format if not specified' do
+        request = DeepL::Requests::Glossary::Create.new(api, name, source_lang, target_lang,
+                                                        entries, options)
+        expect(request.entries_format).to eq('tsv')
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('glossaries') { example.call }
+    end
+
+    context 'When performing a valid request with two glossary entries' do
+      it 'should return a glossaries object' do
+        glossary = subject.request
+        expect(glossary).to be_a(DeepL::Resources::Glossary)
+        expect(glossary.id).to be_kind_of(String)
+        expect(glossary.name).to eq('Mi Glosario')
+        expect(glossary.ready).to be(true).or be(false)
+        expect(glossary.source_lang).to eq('en')
+        expect(glossary.target_lang).to eq('es')
+        expect { Time.iso8601(glossary.creation_time) }.not_to raise_error
+        expect(glossary.entry_count).to eq(2)
+      end
+    end
+  end
+end

data/spec/requests/glossary/destroy_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::Glossary::Destroy do
+  let(:api) { build_deepl_api }
+  let(:id) { '367eef44-b533-4d95-be19-74950c7760e9' }
+  subject { DeepL::Requests::Glossary::Destroy.new(api, id) }
+
+  describe '#initialize' do
+    context 'When building a request' do
+      it 'should create a request object' do
+        expect(subject).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('glossaries') { example.call }
+    end
+
+    context 'When performing a valid request' do
+      let(:new_glossary) do
+        DeepL::Requests::Glossary::Create.new(api, 'fixture', 'EN', 'ES', [%w[Hello Hola]]).request
+      end
+      subject { DeepL::Requests::Glossary::Destroy.new(api, new_glossary.id) }
+      it 'should return an empty object' do
+        response = subject.request
+        expect(response).to eq(new_glossary.id)
+      end
+    end
+
+    context 'When deleting a non existing glossary with a valid id' do
+      let(:id) { '00000000-0000-0000-0000-000000000000' }
+      subject { DeepL::Requests::Glossary::Destroy.new(api, id) }
+      it 'should raise a not found error' do
+        expect { subject.request }.to raise_error(DeepL::Exceptions::NotFound)
+      end
+    end
+
+    context 'When deleting a non existing glossary with an invalid id' do
+      let(:id) { 'invalid-uuid' }
+      subject { DeepL::Requests::Glossary::Destroy.new(api, id) }
+      it 'should raise a bad request error' do
+        expect { subject.request }.to raise_error(DeepL::Exceptions::BadRequest)
+      end
+    end
+  end
+end

data/spec/requests/glossary/entries_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::Glossary::Entries do
+  let(:api) { build_deepl_api }
+  let(:id) { '012a5576-b551-4d4c-b917-ce01bc8debb6' }
+  subject { DeepL::Requests::Glossary::Entries.new(api, id) }
+
+  describe '#initialize' do
+    context 'When building a request' do
+      it 'should create a request object' do
+        expect(subject).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('glossaries') { example.call }
+    end
+
+    context 'When performing a valid request' do
+      it 'should return a list of entries in TSV format' do
+        entries = subject.request
+        expect(entries).to be_kind_of(Array)
+        expect(entries).to all(be_a(Array))
+        expect(entries.size).to eq(2)
+      end
+    end
+
+    context 'When requesting entries with a valid but non existing glossary id' do
+      let(:id) { '00000000-0000-0000-0000-000000000000' }
+      subject { DeepL::Requests::Glossary::Entries.new(api, id) }
+      it 'should raise a not found error' do
+        expect { subject.request }.to raise_error(DeepL::Exceptions::NotFound)
+      end
+    end
+
+    context 'When requesting entries with an invalid glossary id' do
+      let(:id) { 'invalid-uuid' }
+      subject { DeepL::Requests::Glossary::Entries.new(api, id) }
+      it 'should raise a bad request error' do
+        expect { subject.request }.to raise_error(DeepL::Exceptions::BadRequest)
+      end
+    end
+  end
+end

data/spec/requests/glossary/find_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::Glossary::Find do
+  let(:api) { build_deepl_api }
+  let(:id) { 'd9ad833f-c818-430c-a3c9-47071384fa3e' }
+  let(:options) { {} }
+  subject { DeepL::Requests::Glossary::Find.new(api, id, options) }
+
+  describe '#initialize' do
+    context 'When building a request' do
+      it 'should create a request object' do
+        expect(subject).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('glossaries') { example.call }
+    end
+
+    context 'When performing a valid request' do
+      it 'should return a glossary object' do
+        glossary = subject.request
+        expect(glossary).to be_a(DeepL::Resources::Glossary)
+        expect(glossary.id).to eq('d9ad833f-c818-430c-a3c9-47071384fa3e')
+        expect(glossary.name).to eq('Mi Glosario')
+        expect(glossary.ready).to be(true).or be(false)
+        expect(glossary.source_lang).to eq('en')
+        expect(glossary.target_lang).to eq('es')
+        expect { Time.iso8601(glossary.creation_time) }.not_to raise_error
+        expect(glossary.entry_count).to eq(2)
+      end
+    end
+
+    context 'When requesting a non existing glossary with a valid id' do
+      let(:id) { 'a0af40e1-d81b-4aab-a95c-7cafbcfd1eb1' }
+      subject { DeepL::Requests::Glossary::Find.new(api, id, options) }
+      it 'should raise a not found error' do
+        expect { subject.request }.to raise_error(DeepL::Exceptions::NotFound)
+      end
+    end
+
+    context 'When requesting a non existing glossary with an invalid id' do
+      let(:id) { 'invalid-uuid' }
+      subject { DeepL::Requests::Glossary::Find.new(api, id, options) }
+      it 'should raise a bad request error' do
+        expect { subject.request }.to raise_error(DeepL::Exceptions::BadRequest)
+      end
+    end
+  end
+end

data/spec/requests/glossary/language_pairs_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::Glossary::LanguagePairs do
+  let(:api) { build_deepl_api }
+  let(:options) { {} }
+  subject { DeepL::Requests::Glossary::LanguagePairs.new(api, options) }
+
+  describe '#initialize' do
+    context 'When building a request' do
+      it 'should create a request object' do
+        expect(subject).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('glossaries') { example.call }
+    end
+
+    context 'When requesting a list of all language pairs supported by glossaries' do
+      it 'should return a language pairs object' do
+        language_pairs = subject.request
+        expect(language_pairs).to be_an(Array)
+      end
+    end
+  end
+end

data/spec/requests/glossary/list_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Requests::Glossary::List do
+  let(:api) { build_deepl_api }
+  let(:options) { {} }
+  subject { DeepL::Requests::Glossary::List.new(api, options) }
+
+  describe '#initialize' do
+    context 'When building a request' do
+      it 'should create a request object' do
+        expect(subject).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#request' do
+    around do |example|
+      VCR.use_cassette('glossaries') { example.call }
+    end
+
+    context 'When requesting a list of all glossaries' do
+      it 'should return a glossaries object' do
+        glossaries = subject.request
+        expect(glossaries).to be_an(Array)
+      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 'should raise an unauthorized error' do
+          expect { subject.request }.to raise_error(DeepL::Exceptions::AuthorizationFailed)
+        end
+      end
+    end
+  end
+end

data/spec/requests/translate_spec.rb

@@ -90,6 +90,11 @@ describe DeepL::Requests::Translate do
         expect(request.options[:split_sentences]).to eq('0')
       end
 
+      it 'should leave `nonewlines` as is' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, split_sentences: 'nonewlines')
+        expect(request.options[:split_sentences]).to eq('nonewlines')
+      end
+
       it 'should leave `1` as is' do
         request = DeepL::Requests::Translate.new(api, nil, nil, nil, split_sentences: '1')
         expect(request.options[:split_sentences]).to eq('1')
@@ -117,6 +122,52 @@ describe DeepL::Requests::Translate do
         expect(request.options[:preserve_formatting]).to eq('1')
       end
     end
+
+    context 'when using `outline_detection` options' do
+      it 'should convert `true` to `1`' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, outline_detection: true)
+        expect(request.options[:outline_detection]).to eq('1')
+      end
+
+      it 'should convert `false` to `0`' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, outline_detection: false)
+        expect(request.options[:outline_detection]).to eq('0')
+      end
+
+      it 'should leave `0` as is' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, outline_detection: '0')
+        expect(request.options[:outline_detection]).to eq('0')
+      end
+
+      it 'should leave `1` as is' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, outline_detection: '1')
+        expect(request.options[:outline_detection]).to eq('1')
+      end
+    end
+
+    context 'when using `glossary_id` options' do
+      it 'should work with a nil values' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, glossary_id: nil)
+        expect(request.options[:glossary_id]).to eq(nil)
+      end
+
+      it 'should work with a string' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, glossary_id: 'sample_id')
+        expect(request.options[:glossary_id]).to eq('sample_id')
+      end
+    end
+
+    context 'when using `formality` options' do
+      it 'should work with a nil values' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, formality: nil)
+        expect(request.options[:formality]).to eq(nil)
+      end
+
+      it 'should work with a string' do
+        request = DeepL::Requests::Translate.new(api, nil, nil, nil, formality: 'more')
+        expect(request.options[:formality]).to eq('more')
+      end
+    end
   end
 
   describe '#request' do

data/spec/resources/glossary_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Resources::Glossary do
+  subject do
+    described_class.new({
+                          'glossary_id' => 'def3a26b-3e84-45b3-84ae-0c0aaf3525f7',
+                          'name' => 'Mein Glossar',
+                          'ready' => true,
+                          'source_lang' => 'EN',
+                          'target_lang' => 'DE',
+                          'creation_time' => '2021-08-03T14:16:18.329Z',
+                          'entry_count' => 1
+                        }, nil, nil)
+  end
+
+  describe '#initialize' do
+    context 'When building a basic object' do
+      it 'should create a resource' do
+        expect(subject).to be_a(described_class)
+      end
+
+      it 'should assign the attributes' do
+        expect(subject.id).to eq('def3a26b-3e84-45b3-84ae-0c0aaf3525f7')
+        expect(subject.name).to eq('Mein Glossar')
+        expect(subject.ready).to eq(true)
+        expect(subject.source_lang).to eq('EN')
+        expect(subject.target_lang).to eq('DE')
+        expect(subject.creation_time).to eq('2021-08-03T14:16:18.329Z')
+        expect(subject.entry_count).to eq(1)
+      end
+    end
+  end
+end

data/spec/resources/language_pair_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DeepL::Resources::LanguagePair do
+  subject { described_class.new('en', 'de', nil, nil) }
+
+  describe '#initialize' do
+    context 'When building a basic object' do
+      it 'should create a resource' do
+        expect(subject).to be_a(described_class)
+      end
+
+      it 'should assign the attributes' do
+        expect(subject.source_lang).to eq('en')
+        expect(subject.target_lang).to eq('de')
+      end
+    end
+  end
+end

data/spec/resources/language_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 describe DeepL::Resources::Language do
-  subject { described_class.new('EN', 'English', nil, nil) }
+  subject { described_class.new('EN', 'English', nil, nil, nil) }
 
   describe '#initialize' do
     context 'When building a basic object' do
@@ -15,6 +15,28 @@ describe DeepL::Resources::Language do
         expect(subject.code).to eq('EN')
         expect(subject.name).to eq('English')
       end
+
+      it 'should not define the supports formality method' do
+        expect { subject.supports_formality? }.to raise_error(DeepL::Exceptions::NotSupported)
+      end
+    end
+
+    context 'when building a target language object' do
+      subject { described_class.new('EN', 'English', true, nil, nil) }
+
+      it 'should create a resource' do
+        expect(subject).to be_a(described_class)
+      end
+
+      it 'should assign the attributes' do
+        expect(subject.code).to eq('EN')
+        expect(subject.name).to eq('English')
+      end
+
+      it 'should include the supports formality method' do
+        expect { subject.supports_formality? }.not_to raise_error
+        expect(subject.supports_formality?).to be_truthy
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -20,8 +20,8 @@ VCR.configure do |config|
   config.hook_into :webmock
   config.filter_sensitive_data('VALID_TOKEN') { ENV['DEEPL_AUTH_KEY'] }
   config.default_cassette_options = {
-    record: :new_episodes,
-    match_requests_on: %i[method uri body]
+    # record: :new_episodes,
+    match_requests_on: %i[method uri body headers]
   }
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deepl-rb
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.5.0
 platform: ruby
 authors:
 - Daniel Herzog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-17 00:00:00.000000000 Z
+date: 2022-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: juwelier
@@ -62,28 +62,49 @@ files:
 - lib/deepl/exceptions/bad_request.rb
 - lib/deepl/exceptions/error.rb
 - lib/deepl/exceptions/limit_exceeded.rb
+- lib/deepl/exceptions/not_found.rb
+- lib/deepl/exceptions/not_supported.rb
 - lib/deepl/exceptions/quota_exceeded.rb
 - lib/deepl/exceptions/request_error.rb
+- lib/deepl/glossary_api.rb
 - lib/deepl/requests/base.rb
+- lib/deepl/requests/glossary/create.rb
+- lib/deepl/requests/glossary/destroy.rb
+- lib/deepl/requests/glossary/entries.rb
+- lib/deepl/requests/glossary/find.rb
+- lib/deepl/requests/glossary/language_pairs.rb
+- lib/deepl/requests/glossary/list.rb
 - lib/deepl/requests/languages.rb
 - lib/deepl/requests/translate.rb
 - lib/deepl/requests/usage.rb
 - lib/deepl/resources/base.rb
+- lib/deepl/resources/glossary.rb
 - lib/deepl/resources/language.rb
+- lib/deepl/resources/language_pair.rb
 - lib/deepl/resources/text.rb
 - lib/deepl/resources/usage.rb
 - spec/api/api_spec.rb
 - spec/api/configuration_spec.rb
 - spec/api/deepl_spec.rb
+- spec/fixtures/vcr_cassettes/deepl_glossaries.yml
 - spec/fixtures/vcr_cassettes/deepl_languages.yml
 - spec/fixtures/vcr_cassettes/deepl_translate.yml
 - spec/fixtures/vcr_cassettes/deepl_usage.yml
+- spec/fixtures/vcr_cassettes/glossaries.yml
 - spec/fixtures/vcr_cassettes/languages.yml
 - spec/fixtures/vcr_cassettes/translate_texts.yml
 - spec/fixtures/vcr_cassettes/usage.yml
+- spec/requests/glossary/create_spec.rb
+- spec/requests/glossary/destroy_spec.rb
+- spec/requests/glossary/entries_spec.rb
+- spec/requests/glossary/find_spec.rb
+- spec/requests/glossary/language_pairs_spec.rb
+- spec/requests/glossary/list_spec.rb
 - spec/requests/languages_spec.rb
 - spec/requests/translate_spec.rb
 - spec/requests/usage_spec.rb
+- spec/resources/glossary_spec.rb
+- spec/resources/language_pair_spec.rb
 - spec/resources/language_spec.rb
 - spec/resources/text_spec.rb
 - spec/resources/usage_spec.rb
@@ -107,7 +128,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: A simple ruby wrapper for the DeepL API