abbyy-cloud 0.0.3 → 0.0.4

data/lib/abbyy/cloud/models/translation.rb

@@ -3,7 +3,7 @@ class ABBYY::Cloud
   module Models
     # Result of the order translation
     class Translation < Struct
-      attribute :id,          Types::OrderId
+      attribute :id,          Types::Strict::String
       attribute :translation, Types::Strict::String
     end
   end

data/lib/abbyy/cloud/models/translation_segment.rb

@@ -0,0 +1,16 @@
+require_relative "transfer_data"
+
+class ABBYY::Cloud
+  module Models
+    # A segment of the translation
+    class TranslationSegment < Struct
+      attribute :id,   Types::Strict::String
+      attribute :text, Types::Strict::String
+      attribute :tags_transfer_data,
+                Types::Array.member(Types::TransferData).default([])
+    end
+
+    # Registers type Types::TranslationSegment
+    Types.register_type TranslationSegment
+  end
+end

data/lib/abbyy/cloud/models/unit_price.rb

@@ -0,0 +1,13 @@
+class ABBYY::Cloud
+  module Models
+    # Price details
+    class UnitPrice < Struct
+      attribute :unit_type, Types::UnitType
+      attribute :currency,  Types::Currency
+      attribute :amount,    Types::Coercible::Float
+    end
+
+    # Registers type Types::UnitPrice
+    Types.register_type UnitPrice
+  end
+end

data/lib/abbyy/cloud/namespaces/machine_translations.rb

@@ -1,17 +1,63 @@
+require_relative "base"
+
 class ABBYY::Cloud
   module Namespaces
     # Namespace for operations with machine translations
     # @see [https://api.abbyy.cloud/swagger/ui/index#!/MachineTranslation]
     class MachineTranslations < Base
       # Returns list of all available engines
+      # @return [Array<ABBYY::Cloud::Models::Engine>]
       def engines
         Operations::Engines.new(settings).call
       end
 
-      # Returns settigns for the engine selected by its name
+      # Returns engine object selected by its name
+      # @return [ABBYY::Cloud::Models::Engine]
       def engine(name)
         engines.find { |engine| engine.name == name }
       end
+
+      # Returns engine object for the default engine
+      # @return [ABBYY::Cloud::Models::Engine]
+      def default_engine
+        engine(settings.engine)
+      end
+
+      # Instantly (synchronously) translates the text
+      #
+      # @example
+      #   translate "Hello world!", from: "en", to: "fr_FR"
+      #
+      # @param  [String] text
+      # @option [ABBYY::Cloud::Types::Locale] :from Source language
+      # @option [ABBYY::Cloud::Types::Locale] :to   Target language
+      # @return [ABBYY::Cloud::Models::Translation]
+      #
+      def translate(text, from:, to:, **opts)
+        Operations::Translate.new(settings).call source_text:     text,
+                                                 source_language: from,
+                                                 target_language: to,
+                                                 engine: settings.engine,
+                                                 **opts
+      end
+
+      # Instantly (synchronously) translates array of texts
+      #
+      # @example
+      #   translate ["Hello", "world"], from: "en", to: "fr_FR"
+      #
+      # @param  [Array<String>] texts
+      # @option [ABBYY::Cloud::Types::Locale] :from Source language
+      # @option [ABBYY::Cloud::Types::Locale] :to   Target language
+      # @return [ABBYY::Cloud::Models::Translation]
+      #
+      def translate_segments(texts, from:, to:, **opts)
+        sources = texts.map { |text| { text: text } }
+        Operations::TranslateSegments
+          .new(settings)
+          .call sources: sources, from: from, to: to, engine: settings.engine,
+                **opts
+      end
     end
   end
 end

data/lib/abbyy/cloud/namespaces/prices.rb

@@ -0,0 +1,29 @@
+require_relative "base"
+
+class ABBYY::Cloud
+  module Namespaces
+    # Namespace for operations with prices
+    # @see [https://api.abbyy.cloud/swagger/ui/index#!/Prices] ABBYY Cloud API
+    class Prices < Base
+      MAX_PER_REQUEST = 1_000
+
+      # Returns prices data filtered by type of translated object,
+      # source and target language.
+      #
+      # If take option is NOT set, the method makes as many requests
+      # as necessary to get all prices.
+      #
+      def details(skip: 0, take: nil, **opts)
+        take_now   = (take && take <= MAX_PER_REQUEST) ? take : MAX_PER_REQUEST
+        take_later = take - take_now if take
+        skip_later = skip + take_now
+
+        items = Operations::Prices.new(settings)
+                                  .call(skip: skip, take: take_now, **opts)
+
+        return items if (items.count < take_now) || take_later.zero?
+        items + details(skip: skip_later, take: take_later, **opts)
+      end
+    end
+  end
+end

data/lib/abbyy/cloud/operations/base.rb

@@ -27,6 +27,10 @@ class ABBYY::Cloud
           provide_struct :@request_body, struct, &block
         end
 
+        def request_query(struct = nil, &block)
+          provide_struct :@request_query, struct, &block
+        end
+
         def response_body(struct = nil, &block)
           provide_struct :@response_body, struct, &block
         end
@@ -44,20 +48,24 @@ class ABBYY::Cloud
         end
       end
 
+      include Dry::Initializer.define -> do
+        param :settings
+      end
+
+      def_delegators :settings, :connection
       def_delegators :"self.class",
                      :link,
                      :http_method,
                      :path,
                      :request_body,
+                     :request_query,
                      :response_body
 
-      include Dry::Initializer.define -> do
-        param :settings
-      end
-
       def call(**data)
-        body = prepare_request_body(data)
-        res  = settings.connection.call(http_method, path, body: body)
+        body  = prepare_request_body(data)
+        query = prepare_request_query(data)
+        res   = connection.call(http_method, path, body: body, query: query)
+
         handle_response_body(res)
       end
 
@@ -69,6 +77,12 @@ class ABBYY::Cloud
         raise ArgumentError.new(link, data, error.message)
       end
 
+      def prepare_request_query(data)
+        request_query[data]
+      rescue => error
+        raise ArgumentError.new(link, data, error.message)
+      end
+
       def handle_response_body(data)
         response_body[data]
       rescue => error

data/lib/abbyy/cloud/operations/engines.rb

@@ -1,10 +1,12 @@
+require_relative "base"
+
 class ABBYY::Cloud
   module Operations
     class Engines < Base
       # rubocop: disable Metrics/LineLength
       link "https://api.abbyy.cloud/swagger/ui/index#!/MachineTranslation/MachineTranslation_Engines"
       # rubocop: enable Metrics/LineLength
-      path "mt/engines"
+      path "v0/mt/engines"
       http_method "get"
 
       response_body Types::Array.member(Types::Engine)

data/lib/abbyy/cloud/operations/prices.rb

@@ -0,0 +1,23 @@
+require_relative "base"
+
+class ABBYY::Cloud
+  module Operations
+    class Prices < Base
+      # rubocop: disable Metrics/LineLength
+      link "https://api.abbyy.cloud/swagger/ui/index#!/Prices/Prices_GetAccountPrices"
+      # rubocop: enable Metrics/LineLength
+      path "v0/prices/details"
+      http_method "get"
+
+      request_query do
+        attribute :skip, Types::Strict::Int
+        attribute :take, Types::Strict::Int
+        attribute :type, Types::Strict::String.optional
+        attribute :from, Types::Locale.optional
+        attribute :to,   Types::Locale.optional
+      end
+
+      response_body Types::Array.member(Types::Price)
+    end
+  end
+end

data/lib/abbyy/cloud/operations/translate.rb

@@ -1,14 +1,16 @@
+require_relative "base"
+
 class ABBYY::Cloud
   module Operations
     class Translate < Base
       link "https://api.abbyy.cloud/swagger/ui/index#!/Order/Order_Translate"
-      path "order/mt/sync"
+      path "v0/order/mt/sync"
       http_method "post"
 
       request_body do
         attribute :engine,          Types::Strict::String
-        attribute :source_language, Types::Language
-        attribute :target_language, Types::Language
+        attribute :source_language, Types::Locale
+        attribute :target_language, Types::Locale
         attribute :source_text,     Types::Strict::String
       end
 

data/lib/abbyy/cloud/operations/translate_segments.rb

@@ -0,0 +1,22 @@
+require_relative "base"
+
+class ABBYY::Cloud
+  module Operations
+    class TranslateSegments < Base
+      # rubocop: disable Metrics/LineLength
+      link "https://api.abbyy.cloud/swagger/ui/index#!/Order/Order_TranslateSegments"
+      # rubocop: enable Metrics/LineLength
+      path "v1/order/mt/sync"
+      http_method "post"
+
+      request_body do
+        attribute :engine,  Types::Strict::String
+        attribute :from,    Types::Locale
+        attribute :to,      Types::Locale
+        attribute :sources, Types::Array.member(Types::SourceSegment)
+      end
+
+      response_body Types::Array.member(Types::TranslationSegment)
+    end
+  end
+end

data/lib/abbyy/cloud/settings.rb

@@ -3,14 +3,13 @@
 class ABBYY::Cloud
   class Settings
     include Dry::Initializer.define -> do
-      option :id,      type: Types::AuthId
-      option :token,   type: Types::AuthToken
-      option :version, type: Types::Version, default: proc { 0 }
-      option :engine,  type: Types::Strict::String, default: proc { "Sandbox" }
+      option :id,     type: Types::Strict::String
+      option :token,  type: Types::Strict::String
+      option :engine, type: Types::Strict::String, default: proc { "Sandbox" }
     end
 
     def connection
-      @connection ||= Connection.new(version: version, id: id, token: token)
+      @connection ||= Connection.new(id: id, token: token)
     end
   end
 end

data/lib/abbyy/cloud/types.rb

@@ -2,27 +2,31 @@ module ABBYY::Cloud::Types
   include Dry::Types.module
 
   VERSIONS = [0].freeze
-  LANGUAGE = /\A[A-Za-z]{2,}(-[A-Za-z]+)*\z/
+  UNIT_TYPES = %w(Chars Words Pages Documents).freeze
+  DISCOUNT_TYPES = \
+    %w(TMTextMatch TMTaggedTextMatch TMHalfContextMatch TMFullContextMatch)
+    .freeze
 
   # Gem-specific primitive types
-  AuthId    = Strict::String
-  AuthToken = Strict::String
-  Language  = Strict::String.constrained(format: LANGUAGE)
-  OrderId   = Strict::String
-  Version   = Coercible::Int.constrained(included_in: VERSIONS)
+  Version      = Coercible::Int.constrained(included_in: VERSIONS)
+  UnitType     = Strict::String.constrained(included_in: UNIT_TYPES)
+  DiscountType = Strict::String.constrained(included_in: DISCOUNT_TYPES)
+  Currency     = Strict::String.constrained(format: /\A[A-Z]{3}\z/)
 
   # Registers new coercible type from a struct class
-  def self.register_type(struct, as: nil)
-    type_name  = as || struct.name.split("::").last.downcase
+  def self.register_type(struct, as: nil, constructor: :new)
+    type_name  = Inflecto.underscore(as || struct.name.split("::").last)
     definition = Dry::Types::Definition.new(struct).constructor do |value|
       case value
-      when nil    then nil
+      when nil    then raise
       when struct then value
-      else struct[value]
+      else struct.send(constructor, value)
       end
     end
 
     Dry::Types.register type_name, definition
     Dry::Types.define_constants self, [type_name]
   end
+
+  register_type ::Time, as: "coercible.time", constructor: :parse
 end

data/spec/abbyy/cloud/connection_spec.rb

@@ -1,5 +1,5 @@
 RSpec.describe ABBYY::Cloud::Connection do
-  let(:connection) { described_class.new version: 0, id: "baz", token: "qux" }
+  let(:connection) { described_class.new id: "baz", token: "qux" }
 
   subject do
     connection.call :post,

data/spec/abbyy/cloud/models/discount_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe ABBYY::Cloud::Models::Discount do
+  let(:data) { { discount_type: "TMTextMatch", discount: 0.01 } }
+
+  subject { described_class.new(data) }
+
+  it { is_expected.to be_kind_of ABBYY::Cloud::Struct }
+  its(:to_h) { is_expected.to eq data }
+
+  context "with invalid discount_type:" do
+    before { data[:discount_type] = "Unknown" }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "without discount_type:" do
+    before { data.delete :discount_type }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "without discount:" do
+    before { data.delete :discount }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+end

data/spec/abbyy/cloud/models/locale_spec.rb

@@ -0,0 +1,55 @@
+RSpec.describe ABBYY::Cloud::Models::Locale do
+  it "accepts simple language locales" do
+    %w(en sjp yds).each do |locale|
+      expect(described_class[locale]).to eq locale
+    end
+  end
+
+  it "accepts scripted locales" do
+    %w(ar-Aran).each do |locale|
+      expect(described_class[locale]).to eq locale
+    end
+  end
+
+  it "accepts regional locales" do
+    %w(en-GB igb-AA en-018).each do |locale|
+      expect(described_class[locale]).to eq locale
+    end
+  end
+
+  it "accepts scripted regional locales" do
+    %w(ar-Aran-YE ar-Aran-002).each do |locale|
+      expect(described_class[locale]).to eq locale
+    end
+  end
+
+  it "accepts scripted regional subtagged locales" do
+    %w(fr-Aran-FR-1606nict de-1996 de-DE-1996).each do |locale|
+      expect(described_class[locale]).to eq locale
+    end
+  end
+
+  it "accepts grandfarthered locales" do
+    %w(cel-gaulish i-ami en-GB-oed sgn-BE-NL).each do |locale|
+      expect(described_class[locale]).to eq locale
+    end
+  end
+
+  it "accepts redundant locales" do
+    %w(bs-Latn de-AT-1901 zh-Hans-TW).each do |locale|
+      expect(described_class[locale]).to eq locale
+    end
+  end
+
+  it "accepts private-use locales" do
+    %w(en-x-it).each do |locale|
+      expect(described_class[locale]).to eq locale
+    end
+  end
+
+  it "declines locales that mismatch IANA/IETF standards" do
+    %w(i en_EN).each do |locale|
+      expect { described_class[locale] }.to raise_error(StandardError)
+    end
+  end
+end

data/spec/abbyy/cloud/models/price_spec.rb

@@ -0,0 +1,107 @@
+RSpec.describe ABBYY::Cloud::Models::Price do
+  let(:data) do
+    {
+      id:          "foo",
+      account_id:  "bar",
+      type:        "qux",
+      from:        "ru",
+      to:          "en",
+      unit_prices: [{ unit_type: "Words", currency: "USD", amount: 0.03 }],
+      discounts:   [{ discount_type: "TMTextMatch", discount: 0.01 }],
+      created:     Time.now
+    }
+  end
+
+  subject { described_class.new(data) }
+
+  it { is_expected.to be_kind_of ABBYY::Cloud::Struct }
+  its(:to_h) { is_expected.to eq data }
+
+  context "without id:" do
+    before { data.delete :id }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "without account_id:" do
+    before { data.delete :account_id }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "without type:" do
+    before { data.delete :type }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "without source language:" do
+    before { data.delete :from }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "without target language:" do
+    before { data.delete :to }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "with invalid unit_prices:" do
+    before { data[:unit_prices] = "foo" }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "with invalid unit_price:" do
+    before { data[:unit_prices] = [{ id: "foo" }] }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "without unit_prices:" do
+    before { data.delete :unit_prices }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "with invalid discounts:" do
+    before { data[:discounts] = "foo" }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "with invalid discount:" do
+    before { data[:discounts] = [{ id: "foo" }] }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+
+  context "without discounts:" do
+    before { data.delete :discounts }
+
+    it "fails" do
+      expect { subject }.to raise_error(StandardError)
+    end
+  end
+end