deepl-rb 2.2.1 → 2.5.3

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    module Glossary
+      class Create < Base
+        attr_reader :name, :source_lang, :target_lang, :entries, :entries_format
+
+        def initialize(api, name, source_lang, target_lang, entries, options = {})
+          super(api, options)
+          @name = name
+          @source_lang = source_lang
+          @target_lang = target_lang
+          @entries = entries
+          @entries_format = delete_option(:entries_format) || 'tsv'
+        end
+
+        def request
+          payload = {
+            name: name, source_lang: source_lang, target_lang: target_lang, entries: entries_to_tsv,
+            entries_format: entries_format
+          }
+          build_glossary(*post(payload))
+        end
+
+        private
+
+        def entries_to_tsv
+          return entries if entries.is_a?(String)
+
+          entries.reduce('') { |tsv, entry| "#{tsv}#{entry.first}\t#{entry.last}\n" }
+        end
+
+        def build_glossary(request, response)
+          glossary = JSON.parse(response.body)
+          Resources::Glossary.new(glossary, request, response)
+        end
+
+        def path
+          'glossaries'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    module Glossary
+      class Destroy < Base
+        attr_reader :id
+
+        def initialize(api, id, options = {})
+          super(api, options)
+          @id = id
+        end
+
+        def request
+          build_response(*delete)
+        end
+
+        private
+
+        def build_response(_, _)
+          id
+        end
+
+        def path
+          "glossaries/#{id}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    module Glossary
+      class Entries < Base
+        attr_reader :id
+
+        def initialize(api, id, options = {})
+          super(api, options)
+          @id = id
+        end
+
+        def request
+          build_entries(*get)
+        end
+
+        private
+
+        def build_entries(_, response)
+          response.body.split("\n").map { |entry| entry.split("\t") }
+        end
+
+        def path
+          "glossaries/#{id}/entries"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    module Glossary
+      class Find < Base
+        attr_reader :id
+
+        def initialize(api, id, options = {})
+          super(api, options)
+          @id = id
+        end
+
+        def request
+          build_glossary(*get)
+        end
+
+        private
+
+        def build_glossary(request, response)
+          glossary = JSON.parse(response.body)
+          Resources::Glossary.new(glossary, request, response)
+        end
+
+        def path
+          "glossaries/#{id}"
+        end
+      end
+    end
+  end
+end

data/lib/deepl/requests/glossary/language_pairs.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    module Glossary
+      class LanguagePairs < Base
+        def initialize(api, options = {})
+          super(api, options)
+        end
+
+        def request
+          build_language_pair_list(*get)
+        end
+
+        private
+
+        def build_language_pair_list(request, response)
+          data = JSON.parse(response.body)
+          data['supported_languages'].map do |language_pair|
+            Resources::LanguagePair.new(language_pair['source_lang'], language_pair['target_lang'],
+                                        request, response)
+          end
+        end
+
+        def path
+          'glossary-language-pairs'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    module Glossary
+      class List < Base
+        def initialize(api, options = {})
+          super(api, options)
+        end
+
+        def request
+          build_glossary_list(*get)
+        end
+
+        private
+
+        def build_glossary_list(request, response)
+          data = JSON.parse(response.body)
+          data['glossaries'].map do |glossary|
+            Resources::Glossary.new(glossary, request, response)
+          end
+        end
+
+        def path
+          'glossaries'
+        end
+      end
+    end
+  end
+end

data/lib/deepl/requests/languages.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module DeepL
+  module Requests
+    class Languages < Base
+      def initialize(api, options = {})
+        super(api, options)
+      end
+
+      def request
+        build_languages(*get)
+      end
+
+      private
+
+      def build_languages(request, response)
+        data = JSON.parse(response.body)
+        data.map do |language|
+          Resources::Language.new(language['language'], language['name'],
+                                  language['supports_formality'],
+                                  request, response)
+        end
+      end
+
+      def path
+        'languages'
+      end
+    end
+  end
+end

data/lib/deepl/requests/translate.rb

@@ -1,16 +1,21 @@
+# frozen_string_literal: true
+
 module DeepL
   module Requests
     class Translate < Base
       BOOLEAN_CONVERSION = { true => '1', false => '0' }.freeze
-      ARRAY_CONVERSION = ->(value) { value.is_a?(Array) ? value.join(', ') : value }.freeze
+      ARRAY_CONVERSION = ->(value) { value.is_a?(Array) ? value.join(',') : value }.freeze
       OPTIONS_CONVERSIONS = {
         split_sentences: BOOLEAN_CONVERSION,
         preserve_formatting: BOOLEAN_CONVERSION,
+        outline_detection: BOOLEAN_CONVERSION,
+        splitting_tags: ARRAY_CONVERSION,
         non_splitting_tags: ARRAY_CONVERSION,
         ignore_tags: ARRAY_CONVERSION
       }.freeze
 
-      attr_reader :text, :source_lang, :target_lang, :ignore_tags, :non_splitting_tags
+      attr_reader :text, :source_lang, :target_lang, :ignore_tags, :splitting_tags,
+                  :non_splitting_tags
 
       def initialize(api, text, source_lang, target_lang, options = {})
         super(api, options)
@@ -31,6 +36,7 @@ module DeepL
       def tweak_parameters!
         OPTIONS_CONVERSIONS.each do |param, converter|
           next unless option?(param) && converter[option(param)]
+
           set_option(param, converter[option(param)])
         end
       end

data/lib/deepl/requests/usage.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DeepL
   module Requests
     class Usage < Base

data/lib/deepl/resources/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DeepL
   module Resources
     class Base

data/lib/deepl/resources/glossary.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module DeepL
+  module Resources
+    class Glossary < Base
+      attr_reader :id, :name, :ready, :source_lang, :target_lang, :creation_time, :entry_count
+
+      def initialize(glossary, *args)
+        super(*args)
+
+        @id = glossary['glossary_id']
+        @name = glossary['name']
+        @ready = glossary['ready']
+        @source_lang = glossary['source_lang']
+        @target_lang = glossary['target_lang']
+        @creation_time = glossary['creation_time']
+        @entry_count = glossary['entry_count']
+      end
+
+      def to_s
+        "#{id} - #{name}"
+      end
+    end
+  end
+end

data/lib/deepl/resources/language.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DeepL
+  module Resources
+    class Language < Base
+      attr_reader :code, :name
+
+      def initialize(code, name, supports_formality, *args)
+        super(*args)
+
+        @code = code
+        @name = name
+        @supports_formality = supports_formality
+      end
+
+      def to_s
+        "#{code} - #{name}"
+      end
+
+      def supports_formality?
+        return @supports_formality unless @supports_formality.nil?
+
+        raise Exceptions::NotSupported, 'Support formality is only available on target languages'
+      end
+    end
+  end
+end

data/lib/deepl/resources/language_pair.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DeepL
+  module Resources
+    class LanguagePair < Base
+      attr_reader :source_lang, :target_lang
+
+      def initialize(source_lang, target_lang, *args)
+        super(*args)
+
+        @source_lang = source_lang
+        @target_lang = target_lang
+      end
+
+      def to_s
+        "#{source_lang} - #{target_lang}"
+      end
+    end
+  end
+end

data/lib/deepl/resources/text.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DeepL
   module Resources
     class Text < Base

data/lib/deepl/resources/usage.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DeepL
   module Resources
     class Usage < Base

data/lib/deepl/utils/exception_builder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module DeepL
+  module Utils
+    class ExceptionBuilder
+      attr_reader :request, :response
+
+      ERROR_CODE_CLASS_MAP = {
+        '400' => Exceptions::BadRequest,
+        '401' => Exceptions::AuthorizationFailed,
+        '403' => Exceptions::AuthorizationFailed,
+        '404' => Exceptions::NotFound,
+        '413' => Exceptions::RequestEntityTooLarge,
+        '429' => Exceptions::LimitExceeded,
+        '456' => Exceptions::QuotaExceeded
+      }.freeze
+
+      def initialize(request, response)
+        @request = request
+        @response = response
+      end
+
+      def build
+        error_class = ERROR_CODE_CLASS_MAP[response.code.to_s] || Exceptions::RequestError
+        error_class.new(request, response)
+      end
+    end
+  end
+end

data/lib/deepl.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -- Dependencies
 require 'json'
 require 'net/http'
@@ -9,20 +11,37 @@ require 'deepl/exceptions/authorization_failed'
 require 'deepl/exceptions/bad_request'
 require 'deepl/exceptions/limit_exceeded'
 require 'deepl/exceptions/quota_exceeded'
+require 'deepl/exceptions/not_found'
+require 'deepl/exceptions/not_supported'
+require 'deepl/exceptions/request_entity_too_large'
 
 # -- Requests
 require 'deepl/requests/base'
+require 'deepl/requests/glossary/create'
+require 'deepl/requests/glossary/destroy'
+require 'deepl/requests/glossary/entries'
+require 'deepl/requests/glossary/find'
+require 'deepl/requests/glossary/language_pairs'
+require 'deepl/requests/glossary/list'
+require 'deepl/requests/languages'
 require 'deepl/requests/translate'
 require 'deepl/requests/usage'
 
 # -- Responses and resources
 require 'deepl/resources/base'
+require 'deepl/resources/glossary'
+require 'deepl/resources/language'
+require 'deepl/resources/language_pair'
 require 'deepl/resources/text'
 require 'deepl/resources/usage'
 
+# -- Utils
+require 'deepl/utils/exception_builder'
+
 # -- Other wrappers
 require 'deepl/api'
 require 'deepl/configuration'
+require 'deepl/glossary_api'
 
 # -- Gem interface
 module DeepL
@@ -34,11 +53,20 @@ module DeepL
     @api ||= API.new(configuration)
   end
 
+  def languages(options = {})
+    Requests::Languages.new(api, options).request
+  end
+
   def translate(text, source_lang, target_lang, options = {})
     configure if @configuration.nil?
     Requests::Translate.new(api, text, source_lang, target_lang, options).request
   end
 
+  def glossaries(options = {})
+    configure if @configuration.nil?
+    GlossaryApi.new(api, options)
+  end
+
   def usage(options = {})
     configure if @configuration.nil?
     Requests::Usage.new(api, options).request

data/spec/api/api_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe DeepL::API do

data/spec/api/configuration_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe DeepL::Configuration do
@@ -7,14 +9,14 @@ describe DeepL::Configuration do
   describe '#initialize' do
     context 'When using default configuration attributes' do
       it 'should use default attributes' do
-        expect(subject.auth_key).to eq(ENV['DEEPL_AUTH_KEY'])
+        expect(subject.auth_key).to eq(ENV.fetch('DEEPL_AUTH_KEY', nil))
         expect(subject.host).to eq('https://api.deepl.com')
         expect(subject.version).to eq('v2')
       end
     end
 
     context 'When using custom configuration attributes' do
-      let(:attributes) { { auth_key: 'SAMPLE', host: 'http://www.example.org', version: 'v1' } }
+      let(:attributes) { { auth_key: 'SAMPLE', host: 'https://api-free.deepl.com', version: 'v1' } }
 
       it 'should use custom attributes' do
         expect(subject.auth_key).to eq(attributes[:auth_key])