google_translate_diff 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 00ebbfbeaac94fc00141bbb2bfddedcfb9e733a6
+  data.tar.gz: d73f0d12f6d2df80bd43614856113931c3209067
+SHA512:
+  metadata.gz: dd4fd53436d30887c3d7d3990ef84387fbfa5b8c4b355c7258f2a05346f490cdd9288158ab910f6ee18886e5f3096f2ac1e603aeea3e64a71d897a6917233968
+  data.tar.gz: 9e60481244ce4520439c0d0184ea6a8e0dcf587c0717be6000e94051fe1b8dd915bf30fedd5b5f4f0024227e5be03428ab29779065169c7eef9b02143d053366

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,12 @@
+Documentation:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/ClassAndModuleChildren:
+  EnforcedStyle: compact
+
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*

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,3 @@
+source "https://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,114 @@
+# GoogleTranslateDiff
+
+Google Translate API wrapper helps to translate only changes between revisions of long texts.
+
+<a href="https://evilmartians.com/?utm_source=google_translate_diff-gem">
+<img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54">
+</a>
+
+[![Build Status](https://travis-ci.org/gzigzigzeo/google_translate_diff.svg?branch=master)](https://travis-ci.org/gzigzigzeo/google_translate_diff) [![Code Climate](https://codeclimate.com/github/gzigzigzeo/google_translate_diff/badges/gpa.svg)](https://codeclimate.com/github/gzigzigzeo/google_translate_diff) [![Test Coverage](https://codeclimate.com/github/gzigzigzeo/google_translate_diff/badges/coverage.svg)](https://codeclimate.com/github/gzigzigzeo/google_translate_diff/coverage)
+
+## 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 'google_translate_diff'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install google_translate_diff
+
+## Usage
+
+```ruby
+require "google_translate_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/GoogleCloudPlatform/google-cloud-ruby/tree/master/google-cloud-translate
+ENV["TRANSLATE_KEY"] = "foobarkey"
+
+# I always use pool for redis
+pool = ConnectionPool.new(size: 10, timeout: 5) { Redis.new }
+
+# Pass any options (like app id)
+GoogleTranslateDiff.api = Google::Cloud::Translate.new
+
+GoogleTranslateDiff.cache_store =
+  GoogleTranslateDiff::RedisCacheStore.new(pool, timeout: 7.days, namespace: "t")
+
+# Optional
+GoogleTranslateDiff.rate_limiter =
+  GoogleTranslateDiff::RedisRateLimiter.new(
+    pool, threshold: 8000, interval: 60, namespace: "t"
+  )
+
+GoogleTranslateDiff.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:* `:from` is required param. Cache can not be checked without specifying exact language couple, that's the limitation.
+
+## Input
+
+`::translate` can receive string, array or deep hash and will return the same, but translated.
+
+```ruby
+GoogleTranslateDiff.translate("test", from: "en", to: "es")
+GoogleTranslateDiff.translate("test", "language", from: "en", to: "es")
+GoogleTranslateDiff.translate(
+  { title: "test", values: { type: "frequent" } }, from: "en", to: "es"
+)
+```
+
+See `GoogleTranslateDiff::Linearizer` for details.
+
+## HTML
+
+You can pass HTML as like as plain text:
+
+```ruby
+GoogleTranslateDiff.translate("<b>Black</b>", from: "en", to: "es")
+```
+
+## Very long texts
+
+Google API has a limitation: query can not be longer than approximately 4 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/gzigzigzeo/google_translate_diff.

data/Rakefile

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

data/google_translate_diff.gemspec

@@ -0,0 +1,50 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "google_translate_diff/version"
+
+# rubocop:disable Metrics/BlockLength
+Gem::Specification.new do |spec|
+  spec.name          = "google_translate_diff"
+  spec.version       = GoogleTranslateDiff::VERSION
+  spec.authors       = ["Victor Sokolov"]
+  spec.email         = ["gzigzigzeo@evilmartians.com"]
+
+  spec.summary       = %(
+Google Translate API wrapper for Ruby which helps to translate only changes
+between revisions of long texts.
+
+  )
+  spec.description = %(
+Google Translate API wrapper for Ruby which helps to translate only changes
+between revisions of long texts.
+  )
+  spec.homepage = "https://github.com/gzigzigzeo/google_translate_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 "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "codeclimate-test-reporter", "~> 1.0.0"
+  spec.add_development_dependency "simplecov"
+
+  spec.add_dependency "google-cloud-translate"
+  spec.add_dependency "ox"
+  spec.add_dependency "dry-initializer"
+  spec.add_dependency "punkt-segmenter"
+end
+# rubocop:enable Metrics/BlockLength

data/lib/google_translate_diff.rb

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

data/lib/google_translate_diff/cache.rb

@@ -0,0 +1,36 @@
+class GoogleTranslateDiff::Cache
+  extend Dry::Initializer::Mixin
+
+  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
+    GoogleTranslateDiff.cache_store
+  end
+end

data/lib/google_translate_diff/chunker.rb

@@ -0,0 +1,54 @@
+class GoogleTranslateDiff::Chunker
+  extend ::Dry::Initializer::Mixin
+
+  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)
+    URI.encode(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 = 120
+end

data/lib/google_translate_diff/linearizer.rb

@@ -0,0 +1,27 @@
+class GoogleTranslateDiff::Linearizer
+  class << self
+    def linearize(struct, array = [])
+      case struct
+      when Hash then
+        struct.each { |_k, v| linearize(v, array) }
+      when Array then
+        struct.each { |v| linearize(v, array) }
+      else
+        array << struct
+      end
+
+      array
+    end
+
+    def restore(struct, array)
+      case struct
+      when Hash then
+        struct.each_with_object({}) { |(k, v), h| h[k] = restore(v, array) }
+      when Array then
+        struct.map { |v| restore(v, array) }
+      else
+        array.shift
+      end
+    end
+  end
+end

data/lib/google_translate_diff/redis_cache_store.rb

@@ -0,0 +1,24 @@
+class GoogleTranslateDiff::RedisCacheStore
+  extend Dry::Initializer::Mixin
+
+  param :connection_pool
+
+  option :timeout, default: proc { 60 * 60 * 24 * 7 }
+  option :namespace, default: proc { GoogleTranslateDiff::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/google_translate_diff/redis_rate_limiter.rb

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

data/lib/google_translate_diff/request.rb

@@ -0,0 +1,148 @@
+class GoogleTranslateDiff::Request
+  extend Dry::Initializer::Mixin
+  extend Forwardable
+
+  param :values
+  param :options
+
+  def_delegators :GoogleTranslateDiff, :api, :cache_store, :rate_limiter
+  def_delegators :"GoogleTranslateDiff::Linearizer", :linearize, :restore
+
+  def call
+    validate_globals
+
+    return values if from == to || values.empty?
+
+    translation
+  end
+
+  private
+
+  def from
+    @from ||= options.fetch(:from)
+  end
+
+  def to
+    @to ||= options.fetch(:to)
+  end
+
+  def validate_globals
+    raise "Set GoogleTranslateDiff.api before calling ::translate" unless api
+    return if cache_store
+    raise "Set GoogleTranslateDiff.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|
+      GoogleTranslateDiff::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 ||= GoogleTranslateDiff::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)
+    GoogleTranslateDiff::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, **options)].flatten.map(&:text)
+  end
+
+  def cache
+    @cache ||= GoogleTranslateDiff::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/google_translate_diff/spacing.rb

@@ -0,0 +1,27 @@
+# Adds same count leading-trailing spaces left has to the right
+class GoogleTranslateDiff::Spacing
+  class << self
+    # GoogleTranslateDiff::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:]]+$/ui
+      return "" if pos.nil?
+      value[pos..-1]
+    end
+  end
+end

data/lib/google_translate_diff/tokenizer.rb

@@ -0,0 +1,74 @@
+class GoogleTranslateDiff::Tokenizer < ::Ox::Sax
+  def initialize(source)
+    @pos = nil
+    @prev = 1
+    @skip = false
+    @source = source
+    @tokens = []
+  end
+
+  attr_reader :texts, :tokens, :prev, :pos
+
+  def start_element(name)
+    @skip = true if name == :script
+  end
+
+  def end_element(name)
+    @skip = false if name == :script
+  end
+
+  def text(value)
+    return if @skip
+    value = fix_utf(value)
+    return if value.strip.empty?
+
+    token.tap { |t| @tokens << [fix_utf(t), :markup] if t }
+    @tokens.concat(sentences(value))
+
+    @prev = @pos + value.bytesize
+  end
+
+  def token
+    return if @prev == @pos
+    fix_utf(@source.byteslice((@prev - 1)..(@pos - 2)))
+  end
+
+  # Splits text by sentences
+  def sentences(value)
+    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
+
+  def cut_last_token
+    last_token = fix_utf(@source.byteslice((@prev - 1)..-1))
+    @tokens << [last_token, :markup] if last_token != ""
+  end
+
+  def fix_utf(value)
+    value.encode(
+      "UTF-8", undef: :replace, invalid: :replace, replace: " "
+    )
+  end
+
+  class << self
+    def tokenize(value)
+      return [] if value.nil?
+      tokenizer = new(value).tap do |h|
+        Ox.sax_parse(h, StringIO.new(value))
+        h.cut_last_token
+      end
+      tokenizer.tokens
+    end
+  end
+end

data/lib/google_translate_diff/version.rb

@@ -0,0 +1,3 @@
+module GoogleTranslateDiff
+  VERSION = "1.0.1".freeze
+end

metadata

@@ -0,0 +1,204 @@
+--- !ruby/object:Gem::Specification
+name: google_translate_diff
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Victor Sokolov
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-03-27 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: 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: 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: 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: google-cloud-translate
+  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: 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: 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'
+description: "\nGoogle Translate API wrapper for Ruby which helps to translate only
+  changes\nbetween revisions of long texts.\n  "
+email:
+- gzigzigzeo@evilmartians.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- google_translate_diff.gemspec
+- lib/google_translate_diff.rb
+- lib/google_translate_diff/cache.rb
+- lib/google_translate_diff/chunker.rb
+- lib/google_translate_diff/linearizer.rb
+- lib/google_translate_diff/redis_cache_store.rb
+- lib/google_translate_diff/redis_rate_limiter.rb
+- lib/google_translate_diff/request.rb
+- lib/google_translate_diff/spacing.rb
+- lib/google_translate_diff/tokenizer.rb
+- lib/google_translate_diff/version.rb
+homepage: https://github.com/gzigzigzeo/google_translate_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: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: Google Translate API wrapper for Ruby which helps to translate only changes
+  between revisions of long texts.
+test_files: []