deepl_diff 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 601d9219d37903d18d03a30e85fee9ce783522fbfb75d616f2873ef4ca6da950
+  data.tar.gz: a0b23c609b7f6f48b74a83a818d96d3bb13665568f3563a6e67fe2c16fb42f44
+SHA512:
+  metadata.gz: a739f33576f117fde32e6c6fd9527835a2f6aeb3fbdd4b3265aa4e0c913e519bc0f8bd536ed2abdcee50721823e75286aed909cbfc59fc889cea40538c83847c
+  data.tar.gz: 87beae80de1cf85db6308cc613e71b428b0008a4b797ef276ef4d16abd65f162aea2cfd09b454ddd6f2fb438ae3939af7c48c42e850f3f4772c2184be1c35839

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+test.rb

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,15 @@
+Documentation:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/ClassAndModuleChildren:
+  EnforcedStyle: compact
+
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*
+
+Metrics/LineLength:
+  Max: 120

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+sudo: false
+rvm:
+  - 2.3.3
+cache: bundler
+
+addons:
+  code_climate:
+    repo_token: "49b1afe0298c521f3d73377db0d20d1d4b9749ad533126bf3ed105fe9612eb0e"
+    
+after_success:
+  - bundle exec codeclimate-test-reporter

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,117 @@
+# DeepLDiff
+
+DeepL API wrapper helps to translate only changes between revisions of long texts.
+
+
+
+
+**DeepLDiff** based on [GoogleTranslateDiff](https://github.com/gzigzigzeo/google_translate_diff)
+## Use case
+
+Assume your project contains a significant amount of products descriptions which:
+- Require retranslation each time user edits them.
+- Have a lot of equal parts (like return policy).
+- Change frequently.
+
+If your user changes a single word within the long description, you will be charged for the retranslation of the whole text.
+
+Much better approach is to try to translate every repeated structural element (sentence) in your texts array just once to save money. This gem helps to make it done.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'deepl_diff'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install deepl_diff
+
+## Usage
+
+```ruby
+require "deepl_diff"
+
+# This dependencies are not included, as you might need to roll your own cache based on different store
+require "redis"
+require "connection_pool"
+require "redis-namespace"
+require "ratelimit" # Optional, if you will use
+
+# Setup https://github.com/wikiti/deepl-rb
+DeepL.configure do |config|
+  config.auth_key = 'your-api-token'
+  config.host = 'https://api-free.deepl.com' # Default value is 'https://api.deepl.com'
+  config.version = 'v1' # Default value is 'v2'
+end
+
+# I always use pool for redis
+pool = ConnectionPool.new(size: 10, timeout: 5) { Redis.new }
+
+# Pass DeepL for DeepLDiff
+DeepLDiff.api = DeepL
+
+DeepLDiff.cache_store =
+  DeepLDiff::RedisCacheStore.new(pool, timeout: 7.days, namespace: "t")
+
+# Optional
+DeepLDiff.rate_limiter =
+  DeepLDiff::RedisRateLimiter.new(
+    pool, threshold: 8000, interval: 60, namespace: "t"
+  )
+
+DeepLDiff.translate("test translations", from: "en", to: "es")
+```
+
+## How it works
+
+- Text nodes are extracted from HTML.
+- Every text node is split into sentences (using `punkt-segmenter` gem).
+- Cache is checked for the presence of each sentence (using language couple and a hash of string).
+- Missing sentences are translated via API and cached.
+- Original HTML is recombined from translations and cache data.
+
+*NOTE:* if `:from` is not specified or equal to nil, then the DeepL API will be called twice, the first time a sample of text up to 100 characters long will be transferred to determine the language, and the second time the entire text will be transferred.
+        Try to specify `:from` explicitly
+
+## Input
+
+`::translate` can receive string, array or deep hash and will return the same, but translated.
+
+```ruby
+DeepLDiff.translate("test", from: "en", to: "es")
+DeepLDiff.translate(%w[test language], from: "en", to: "es")
+DeepLDiff.translate(
+  { title: "test", values: { type: "frequent" } }, from: "en", to: "es"
+)
+```
+
+See `DeepLDiff::Linearizer` for details.
+
+## HTML
+
+You can pass HTML as like as plain text:
+
+```ruby
+DeepLDiff.translate("<b>Black</b>", from: "en", to: "es")
+```
+
+## Very long texts
+
+DeepL API has a limitation: query can not be longer than approximately 128 KB. If your text is really that long, multiple queries will be used to translate it automatically.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/wikiti/deepl-rb.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/deepl_diff.gemspec

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "deepl_diff/version"
+
+# rubocop:disable Metrics/BlockLength
+Gem::Specification.new do |spec|
+  spec.name          = "deepl_diff"
+  spec.version       = DeepLDiff::VERSION
+  spec.authors       = ["Islam Gagiev"]
+  spec.email         = ["omniacinis@gmail.com"]
+
+  spec.summary       = %(
+DeepL API wrapper for Ruby which helps to translate only changes
+between revisions of long texts.
+
+  )
+  spec.description = %(
+DeepL API wrapper for Ruby which helps to translate only changes
+between revisions of long texts.
+  )
+  spec.homepage = "https://github.com/Halvanhelv/deepl_diff"
+
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "codeclimate-test-reporter", "~> 1.0.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "simplecov"
+
+  spec.add_dependency "connection_pool"
+  spec.add_dependency "deepl-rb"
+  spec.add_dependency "dry-initializer"
+  spec.add_dependency "ox"
+  spec.add_dependency "punkt-segmenter"
+  spec.add_dependency "ratelimit"
+  spec.add_dependency "redis"
+  spec.add_dependency "redis-namespace"
+end
+# rubocop:enable Metrics/BlockLength

data/lib/deepl_diff/cache.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class DeepLDiff::Cache
+  extend Dry::Initializer
+
+  param :from
+  param :to
+
+  def cached_and_missing(values)
+    keys = values.map { |v| key(v) }
+    cached = cache_store.read_multi(keys)
+    missing = values.map.with_index { |v, i| v if cached[i].nil? }.compact
+
+    [cached, missing]
+  end
+
+  def store(values, cached, updates)
+    cached.map.with_index do |value, index|
+      value || store_value(values[index], updates.shift)
+    end
+  end
+
+  private
+
+  def store_value(value, translation)
+    cache_store.write(key(value), translation)
+    translation
+  end
+
+  def key(value)
+    hash = Digest::MD5.hexdigest(value.strip) # No matter how much spaces
+    "#{from}:#{to}:#{hash}"
+  end
+
+  def cache_store
+    DeepLDiff.cache_store
+  end
+end

data/lib/deepl_diff/chunker.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+class DeepLDiff::Chunker
+  extend ::Dry::Initializer
+
+  class Error < StandardError; end
+
+  Chunk = Struct.new(:values, :size)
+
+  param :values
+  option :limit, default: proc { MAX_CHUNK_SIZE }
+  option :count_limit, default: proc { COUNT_LIMIT }
+
+  def call
+    chunks.map(&:values)
+  end
+
+  def chunks
+    values.each_with_object([]) do |value, chunks|
+      validate_value_size(value)
+
+      tail = chunks.last
+
+      if next_chunk?(tail, value)
+        chunks << Chunk.new([], 0)
+        tail = chunks.last
+      end
+
+      update_chunk(tail, value)
+    end
+  end
+
+  private
+
+  def next_chunk?(tail, value)
+    tail.nil? ||
+      (size(value) + tail.size > limit) ||
+      tail.values.size > count_limit
+  end
+
+  def size(text)
+    CGI.escape(text).size
+  end
+
+  def update_chunk(chunk, value)
+    chunk.values << value
+    chunk.size = chunk.size + value.size
+  end
+
+  def validate_value_size(value)
+    raise Error, "Too long part #{value.size} > #{limit}" if value.size > limit
+  end
+
+  MAX_CHUNK_SIZE = 1700
+  COUNT_LIMIT = 300
+end

data/lib/deepl_diff/linearizer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class DeepLDiff::Linearizer
+  class << self
+    def linearize(struct, array = [])
+      case struct
+      when Hash
+        struct.each { |_k, v| linearize(v, array) }
+      when Array
+        struct.each { |v| linearize(v, array) }
+      else
+        array << struct
+      end
+
+      array
+    end
+
+    def restore(struct, array)
+      case struct
+      when Hash
+        struct.transform_values { |v| restore(v, array) }
+      when Array
+        struct.map { |v| restore(v, array) }
+      else
+        array.shift
+      end
+    end
+  end
+end

data/lib/deepl_diff/redis_cache_store.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class DeepLDiff::RedisCacheStore
+  extend Dry::Initializer
+
+  param :connection_pool
+
+  option :timeout, default: proc { 60 * 60 * 24 * 7 }
+  option :namespace, default: proc { DeepLDiff::CACHE_NAMESPACE }
+
+  def read_multi(keys)
+    redis { |redis| redis.mget(*keys) }
+  end
+
+  def write(key, value)
+    redis { |redis| redis.setex(key, timeout, value) }
+  end
+
+  private
+
+  def redis
+    connection_pool.with do |redis|
+      yield Redis::Namespace.new(namespace, redis: redis)
+    end
+  end
+end

data/lib/deepl_diff/redis_rate_limiter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class DeepLDiff::RedisRateLimiter
+  extend Dry::Initializer
+
+  class RateLimitExceeded < StandardError; end
+
+  param :connection_pool
+  param :threshold, default: proc { 8000 }
+  param :interval,  default: proc { 60 }
+
+  option :namespace, default: proc { DeepLDiff::CACHE_NAMESPACE }
+
+  def check(size)
+    connection_pool.with do |redis|
+      rate_limit = Ratelimit.new(namespace, redis: redis)
+      raise RateLimitExceeded if rate_limit.exceeded?("call", threshold: threshold, interval: interval)
+
+      rate_limit.add size
+    end
+  end
+end

data/lib/deepl_diff/request.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+class DeepLDiff::Request
+  extend Dry::Initializer
+  extend Forwardable
+
+  param :values
+  param :options
+
+  def_delegators :DeepLDiff, :api, :cache_store, :rate_limiter
+  def_delegators :"DeepLDiff::Linearizer", :linearize, :restore
+
+  def call
+    validate_globals
+
+    return values if from == to || values.empty?
+
+    translation
+  end
+
+  private
+
+  def from
+    @from ||= options.delete(:from) || detect_language
+  end
+
+  def to
+    @to ||= options.delete(:to) { nil }
+  end
+
+  def detect_language
+    api.translate(text_tokens_texts.join(" ")[0..100], nil, to)
+       .detected_source_language.downcase
+  end
+
+  def validate_globals
+    raise "Set DeepLDiff.api before calling ::translate" unless api
+    return if cache_store
+
+    raise "Set DeepLDiff.cache_store before calling ::translate"
+  end
+
+  # Extracts flat text array
+  # => "Name", "<b>Good</b> boy"
+  #
+  # #values might be something like { name: "Name", bio: "<b>Good</b> boy" }
+  def texts
+    @texts ||= linearize(values)
+  end
+
+  # Converts each array item to token list
+  # => [..., [["<b>", :markup], ["Good", :text], ...]]
+  def tokens
+    @tokens ||= texts.map do |value|
+      DeepLDiff::Tokenizer.tokenize(value)
+    end
+  end
+
+  # Extracts text tokens from token list
+  # => { ..., "1_1" => "Good", 1_3 => "Boy", ... }
+  def text_tokens
+    @text_tokens ||= extract_text_tokens.to_h
+  end
+
+  def extract_text_tokens
+    tokens.each_with_object([]).with_index do |(group, result), group_index|
+      group.each_with_index do |(value, type), index|
+        result << ["#{group_index}_#{index}", value] if type == :text
+      end
+    end
+  end
+
+  # Extracts values from text tokens
+  # => [ ..., "Good", "Boy", ... ]
+  def text_tokens_texts
+    @text_tokens_texts ||= linearize(text_tokens).map(&:to_s).map(&:strip)
+  end
+
+  # Splits things requires translations to per-request chunks
+  # (groups less 2k sym)
+  # => [[ ..., "Good", "Boy", ... ]]
+  def chunks
+    @chunks ||= DeepLDiff::Chunker.new(text_tokens_texts).call
+  end
+
+  # Translates/loads from cache values from each chunk
+  # => [[ ..., "Horoshiy", "Malchik", ... ]]
+  def chunks_translated
+    @chunks_translated ||= chunks.map do |chunk|
+      cached, missing = cache.cached_and_missing(chunk)
+      if missing.empty?
+        cached
+      else
+        cache.store(chunk, cached, call_api(missing))
+      end
+    end
+  end
+
+  # Restores indexes for translated tokens
+  # => { ..., "1_1" => "Horoshiy", 1_3 => "Malchik", ... }
+  def text_tokens_translated
+    @text_tokens_texts_translated ||=
+      restore(text_tokens, chunks_translated.flatten)
+  end
+
+  # Restores tokens translated + adds same spacing as in source token
+  # => [[..., [ "Horoshiy", :text ], ...]]
+  # rubocop:disable Metrics/AbcSize
+  def tokens_translated
+    @tokens_translated ||= tokens.dup.tap do |tokens|
+      text_tokens_translated.each do |index, value|
+        group_index, index = index.split("_")
+        tokens[group_index.to_i][index.to_i][0] =
+          restore_spacing(tokens[group_index.to_i][index.to_i][0], value)
+      end
+    end
+  end
+  # rubocop:enable Metrics/AbcSize
+
+  def restore_spacing(source_value, value)
+    DeepLDiff::Spacing.restore(source_value, value)
+  end
+
+  # Restores texts from tokens
+  # [..., "<b>Horoshiy</b> Malchik", ...]
+  def texts_translated
+    @texts_translated ||= tokens_translated.map do |group|
+      group.map { |value, type| type == :text ? value : fix_ascii(value) }.join
+    end
+  end
+
+  # Final result
+  def translation
+    @translation ||= restore(values, texts_translated)
+  end
+
+  def call_api(values)
+    check_rate_limit(values)
+    [api.translate(values, from, to, **options)].flatten.map(&:text)
+  end
+
+  def cache
+    @cache ||= DeepLDiff::Cache.new(from, to)
+  end
+
+  def check_rate_limit(values)
+    return if rate_limiter.nil?
+
+    size = values.map(&:size).inject(0) { |sum, x| sum + x }
+    rate_limiter.check(size)
+  end
+
+  # Markup should not contain control characters
+  def fix_ascii(value)
+    value.gsub(/[\u0000-\u001F]/, " ")
+  end
+end

data/lib/deepl_diff/spacing.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Adds same count leading-trailing spaces left has to the right
+class DeepLDiff::Spacing
+  class << self
+    # DeepLDiff::Spacing.restore("  a ", "Z") # => "   Z "
+    def restore(left, right)
+      leading(left) + right.strip + trailing(left)
+    end
+
+    private
+
+    def spaces(count)
+      ([" "] * count).join
+    end
+
+    def leading(value)
+      pos = value =~ /[^[:space:]]+/ui
+      return "" if pos.nil? || pos.zero?
+
+      value[0..(pos - 1)]
+    end
+
+    def trailing(value)
+      pos = value =~ /[[:space:]]+\z/ui
+      return "" if pos.nil?
+
+      value[pos..]
+    end
+  end
+end

data/lib/deepl_diff/tokenizer.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+class DeepLDiff::Tokenizer < ::Ox::Sax
+  def initialize(source)
+    @pos = nil
+    @source = source
+    @tokens = nil
+    @context = []
+    @sequence = []
+    @indicies = []
+  end
+
+  def instruct(target)
+    start_markup(target)
+  end
+
+  def end_instruct(target)
+    end_markup(target)
+  end
+
+  def start_element(name)
+    start_markup(name)
+  end
+
+  def end_element(name)
+    end_markup(name)
+  end
+
+  def attr(name, value)
+    return unless @context.last == :span
+    return unless name == :class && value == "notranslate"
+    return if notranslate?
+
+    @sequence[-1] = :notranslate
+  end
+
+  def text(value)
+    return if value == ""
+
+    @sequence << (SKIP.include?(@context.last) ? :markup : :text)
+    @indicies << @pos - 1
+  end
+
+  def tokens
+    @tokens ||= token_sequences_joined
+                .tap { |tokens| make_sentences_from_last_token(tokens) }
+  end
+
+  private
+
+  def token_sequences_joined
+    raw_tokens.each_with_object([]) do |token, tokens|
+      if tokens.empty? # Initial state
+        tokens << token
+      elsif tokens.last[1] == token[1]
+        # Join series of tokens of the same type into one
+        tokens.last[0].concat(token[0])
+      else
+        # If token before :markup is :text we need to split it into sentences
+        make_sentences_from_last_token(tokens)
+        tokens << token
+      end
+    end
+  end
+
+  def make_sentences_from_last_token(tokens)
+    return if tokens.empty?
+
+    tokens.concat(sentences(tokens.pop[0])) if tokens.last[1] == :text
+  end
+
+  # rubocop: disable Metrics/MethodLength
+  def sentences(value)
+    return [] if value.strip.empty?
+
+    boundaries =
+      Punkt::SentenceTokenizer
+      .new(value)
+      .sentences_from_text(value)
+
+    return [[value, :text]] if boundaries.size == 1
+
+    boundaries.map.with_index do |(left, right), index|
+      next_boundary = boundaries[index + 1]
+      right = next_boundary[0] - 1 if next_boundary
+
+      [value[left..right], :text]
+    end
+  end
+  # rubocop:enable Metrics/MethodLength
+
+  # Whether the sequence is between `:notranslate` and `:end_notranslate`
+  def notranslate?
+    @sequence.select { |item| item[/notranslate/] }.last == :notranslate
+  end
+
+  # Returns the item for last opened span
+  def end_span
+    return :markup unless notranslate?
+
+    opened_spans = @sequence
+                   .reverse
+                   .take_while { |item| item != :notranslate }
+                   .map { |item| { span: 1, end_span: -1 }.fetch(item, 0) }
+                   .reduce(0, :+)
+
+    opened_spans.positive? ? :end_span : :end_notranslate
+  end
+
+  def raw_tokens
+    @raw_tokens ||= @indicies.map.with_index do |i, n|
+      first = i
+      last = (@indicies[n + 1] || 0) - 1
+      value = fix_utf(@source.byteslice(first..last))
+      type = @sequence[n]
+      type = :text if INNER_SPANS.include?(type)
+      [value, type]
+    end
+  end
+
+  def fix_utf(value)
+    value.encode("UTF-8", undef: :replace, invalid: :replace, replace: " ")
+  end
+
+  def start_markup(name)
+    @context << name
+    @sequence << (if notranslate?
+                    name == :span ? :span : :text
+                  else
+                    :markup
+                  end)
+    @indicies << @pos - 1
+  end
+
+  def end_markup(name)
+    @context.pop
+    @sequence << (if notranslate?
+                    name == :span ? end_span : :text
+                  else
+                    :markup
+                  end)
+    @indicies << @pos - 1 unless @pos == @source.bytesize
+  end
+
+  class << self
+    def tokenize(value)
+      return [] if value.nil?
+
+      tokenizer = new(value).tap do |h|
+        Ox.sax_parse(h, StringIO.new(value), HTML_OPTIONS)
+      end
+      tokenizer.tokens
+    end
+  end
+
+  SKIP = %i[script style].freeze
+  INNER_SPANS = %i[notranslate span end_span end_notranslate].freeze
+  HTML_OPTIONS = { smart: true, skip: :skip_none }.freeze
+end

data/lib/deepl_diff/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DeepLDiff
+  VERSION = "1.0.2"
+end

data/lib/deepl_diff.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "ox"
+require "punkt-segmenter"
+require "dry/initializer"
+require "deepl"
+
+require "deepl_diff/version"
+require "deepl_diff/tokenizer"
+require "deepl_diff/linearizer"
+require "deepl_diff/chunker"
+require "deepl_diff/spacing"
+require "deepl_diff/cache"
+require "deepl_diff/redis_cache_store"
+require "deepl_diff/redis_rate_limiter"
+require "deepl_diff/request"
+
+module DeepLDiff
+  class << self
+    attr_accessor :api, :cache_store, :rate_limiter
+
+    def translate(*args)
+      Request.new(*args).call
+    end
+  end
+
+  CACHE_NAMESPACE = "deepl-diff"
+end

metadata

@@ -0,0 +1,259 @@
+--- !ruby/object:Gem::Specification
+name: deepl_diff
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+platform: ruby
+authors:
+- Islam Gagiev
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-02-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: deepl-rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-initializer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ox
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: punkt-segmenter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ratelimit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "\nDeepL API wrapper for Ruby which helps to translate only changes\nbetween
+  revisions of long texts.\n  "
+email:
+- omniacinis@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- deepl_diff.gemspec
+- lib/deepl_diff.rb
+- lib/deepl_diff/cache.rb
+- lib/deepl_diff/chunker.rb
+- lib/deepl_diff/linearizer.rb
+- lib/deepl_diff/redis_cache_store.rb
+- lib/deepl_diff/redis_rate_limiter.rb
+- lib/deepl_diff/request.rb
+- lib/deepl_diff/spacing.rb
+- lib/deepl_diff/tokenizer.rb
+- lib/deepl_diff/version.rb
+homepage: https://github.com/Halvanhelv/deepl_diff
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: DeepL API wrapper for Ruby which helps to translate only changes between
+  revisions of long texts.
+test_files: []