globalize-automatic 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 735aec99e5cfd71d44624e9eddbc04f9c5f7946d
+  data.tar.gz: 570d8ecb6a353dc1bebeeff4a43888d4b701b90d
+SHA512:
+  metadata.gz: f9f3068d5461d17d96fc53315cf17a875f052a3b1b567515982d5dcc1a5d56a735ea6dab3b05264775bb0068a55d87ce14bae8e1b1ee7c851bc1ecd9eceeb1e9
+  data.tar.gz: 6ed69374b69a9564e233d4da95bc2d2cec43f86a7457a0bdb9856574dd1e21ed99a10f840ecdd54d67a0be7b765092cd3f2d74eed4fbcfad128c969bb2aace2a

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Yuichi Takeuchi
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,249 @@
+Globalize Automatic
+-
+
+## Installation
+
+```ruby
+gem install globalize-automatic
+```
+
+### Rails 5.0
+
+In your Gemfile
+
+```ruby
+gem 'globalize-automatic', github: 'takeyuweb/globalize-automatic', branch: 'rails-5-0'
+```
+
+and
+
+```bash
+bundle install
+```
+
+## Configuration
+
+```ruby
+# config/initializers/globalize_automatic.rb
+require 'globalize-automatic'
+Globalize::Automatic.translator = 
+  Globalize::Automatic::Translator::EasyTranslate.new
+
+# EasyTranslate configuration
+EasyTranslate.api_key = 'xxx'
+```
+
+## Example
+
+### 宣言
+
+```ruby
+class Post
+  # Automatically translated from English.
+  translates :title, :text, automatic: :en
+end
+```
+
+```ruby
+class Post
+  # Automatically translated from English or Japanese. (English preferred)
+  translates :title, :text, automatic: %i(en ja)
+end
+```
+
+```ruby
+class Post
+  # Automatically translated from English
+  translates :title, :text, automatic: { from: :en, to: %i(ja fr vi) }
+end
+```
+
+```ruby
+class CreatePostAutomatics < ActiveRecord::Migration
+  def up
+    Post.create_translation_table! title: :string, text: :text
+    Post.create_automatic_translation_table! :title, :text
+  end
+    
+  def down
+    Post.drop_translation_table!
+    Post.drop_automatic_translation_table!
+  end
+end
+```
+
+#### 自動翻訳対象を追加
+
+```ruby
+class AddPostAutomatics < ActiveRecord::Migration
+  def up
+    Post.add_translation_fields! description: :text
+    Post.add_automatic_translation_fields! :description
+  end
+    
+  def down
+    remove_column :post_automatic_translations, :description
+    remove_column :post_automatic_translations, :description_automatically
+  end
+end
+```
+
+### 更新
+
+#### 自動翻訳
+
+```ruby
+I18n.locale = :en
+post.title = 'globalize'
+post.save!
+
+post.title_ja_automatic # => false
+post.title_vi_automatic # => true
+
+post.reload
+
+I18n.locale = :ja
+post.title # => nil
+I18n.locale = :vi
+post.title # => 'โลกาภิวัฒน์'
+```
+
+```ruby
+post.attributes = {
+   title_en: 'globalize',
+   title_ja_automatic: true
+}
+post.save!
+
+post.reload
+
+I18n.locale = :en
+post.title # => 'globalize'
+I18n.locale = :ja
+post.title # => '国際化'
+```
+
+#### 自動翻訳無効化
+
+```ruby
+post.attributes = {
+   title_en: 'globalize',
+   title_fr_automatic: false,
+   title_fr: 'Hoge'
+}
+post.save!
+
+post.reload
+
+I18n.locale = :en
+post.title # => 'globalize'
+I18n.locale = :vi
+post.title # => 'โลกาภิวัฒน์'
+I18n.locale = :fr
+post.title # => 'hoge'
+```
+
+### 自動翻訳の原文優先順位
+
+```ruby
+class Post
+  # Automatically translated from English or Japanese. (English preferred)
+  translates :title, :text, automatic: %i(en ja)
+end
+
+post = Post.new
+post.attributes = {
+    title_en: 'English',
+    title_ja: '日本語'
+}
+post.save!
+
+post.reload
+
+I18n.locale = :fr
+post.title # => 'Anglais' # It means 'English'.
+```
+
+```ruby
+class Post
+  # Automatically translated from English or Japanese. (English preferred)
+  translates :title, :text, automatic: %i(en ja)
+end
+
+post = Post.new
+post.attributes = {
+    title_en: nil,
+    title_ja: '日本語'
+}
+post.save!
+
+post.reload
+
+I18n.locale = :fr
+post.title # => 'Japonais' # It means '日本語'.
+```
+
+### 取得
+
+#### 翻訳文属性名
+
+[globalize-accessors](https://github.com/globalize/globalize-accessors)
+
+```ruby
+Post.globalize_attribute_names # => [:title_ja, :title_en, :title_fr, :title_vi, :text_ja, :text_en, :text_fr, :text_vi]
+```
+
+#### 自動翻訳有効/無効属性名
+
+```ruby
+Post.automatic_translation_attribute_names # => [:title_ja_automatically, :title_en_automatically, :title_fr_automatically, :title_vi_automatically, :text_ja_automatically, :text_en_automatically, :text_fr_automatically, :text_vi_automatically]
+```
+
+strong parameters
+
+```ruby
+permitted = Post.globalize_attribute_names + Post.automatic_translation_attribute_names
+params.require(:post).permit(*permitted)
+```
+
+### 非同期
+
+ActiveJobを利用による非同期翻訳
+
+```ruby
+# config/initializers/globalize_automatic.rb
+Globalize::Automatic.asynchronously = true
+```
+
+### 他の翻訳ライブラリやサービスへの対応
+
+Translatorクラスを書けば対応できます。
+
+```ruby
+class YourTranslator < Globalize::Automatic::Translator
+  def translate(text, from, to)
+    # 適当な翻訳処理を行って訳文を返す
+    return translated
+  end
+end
+
+Globalize::Automatic.translator = YourTranslator::EasyTranslate.new
+```
+
+## TODO
+
+- EasyTranslate依存の切り出し
+  - 他の翻訳ライブラリやサービスへの対応。
+    - Microsoft Translator
+    - Gengo etc
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/takeyuweb/globalize_automatic. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the Contributor Covenant code of conduct.
+
+## Licence
+
+Copyright (c) 2017 Yuichi Takeuchi released under the MIT license
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,23 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'GlobalizeAutomatic'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+Bundler::GemHelper.install_tasks
+

data/lib/globalize-automatic.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'globalize/automatic'

data/lib/globalize/automatic.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require 'globalize'
+require 'globalize-accessors'
+require 'globalize/automatic/translation'
+require 'globalize/automatic/translation_job'
+require 'globalize/automatic/translator/easy_translate'
+require 'after_commit_action'
+
+module Globalize::Automatic
+  mattr_accessor :asynchronously, :translator
+
+  module TranslatedExtension
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :automatic_translation_attribute_names,
+                      :automatic_translation_field_locales,
+                      :automatic_translated_field_locales
+      self.automatic_translation_attribute_names = []
+      self.automatic_translation_field_locales = Hash.new { [] }
+      self.automatic_translated_field_locales = Hash.new { [] }
+    end
+
+    class_methods do
+      def automatic_translation_class
+        return @automatic_translation_class if defined?(@automatic_translation_class)
+        if self.const_defined?(:AutomaticTranslation, false)
+          klass = self.const_get(AutomaticTranslation, false)
+        else
+          klass = Class.new(Globalize::Automatic::Translation)
+          self.const_set(:AutomaticTranslation, klass)
+        end
+        foreign_key = name.foreign_key
+        klass.belongs_to :automatic_translated_model,
+                         class_name: name,
+                         foreign_key: foreign_key,
+                         inverse_of: :automatic_translations
+        klass.define_singleton_method(:automatic_translated_model_foreign_key) do
+          foreign_key
+        end
+        @automatic_translation_class = klass
+      end
+
+      # 翻訳元フィールドと言語
+      def add_automatic_translation_field_locales!(fields, locales)
+        fields.each do |field|
+          automatic_translation_field_locales[field] = locales
+        end
+      end
+
+      # 翻訳先フィールドと言語
+      def add_automatic_translated_field_locales!(fields, locales)
+        fields.each do |field|
+          automatic_translated_field_locales[field] = locales
+        end
+      end
+
+      # field が locale で自動翻訳元指定されているか
+      def translate_field_automatically?(field, locale)
+        automatic_translation_field_locales[field].include?(locale)
+      end
+
+      # field が locale で自動翻訳先指定されているか
+      def translated_field_automatically?(field, locale)
+        automatic_translated_field_locales[field].include?(locale)
+      end
+
+      public
+      def create_automatic_translation_table!(*fields)
+        automatic_translation_class.create_table!(*fields)
+      end
+
+      def drop_automatic_translation_table!
+        automatic_translation_class.drop_table!
+      end
+
+      def add_automatic_translation_fields!(*fields)
+        automatic_translation_class.add_fields!(*fields)
+      end
+
+    end
+
+    def automatic_translation_for(locale)
+      automatic_translations.where(locale: locale).
+          first_or_initialize(default_translation_automatically(locale))
+    end
+
+    # from_locale から attribute_names を自動翻訳
+    # 自動翻訳が対象でない場合なにもしない
+    def run_automatic_translation(from_locale: , attribute_names:)
+      attribute_names.each do |attr_name|
+        # 自動翻訳対象以外
+        next unless automatic_translation_field_locales[attr_name].include?(from_locale)
+        # 自動翻訳先としては無効化されている
+        next if automatic_translation_for(from_locale)[:"#{attr_name}_automatically"]
+        automatic_translated_field_locales[attr_name].each do |to_locale|
+          next if to_locale == from_locale
+          automatic_translation_for(to_locale).translate(attr_name)
+        end
+      end
+      true
+    end
+
+    # 自動翻訳元言語
+    # attr_nameの自動変換が有効なとき
+    # 現在設定されている中で一番優先度の高い翻訳元localeを返す
+    # どの言語も設定されてない場合は一番優先度の高いもの
+    # 自動翻訳元でない場合nil
+    def automatic_translation_locale(attr_name)
+      locales = automatic_translation_field_locales[attr_name]
+      locales.each do |locale|
+        return locale unless translation_for(locale)[attr_name].blank?
+      end
+      locales.first
+    end
+
+    private
+    def default_translation_automatically(locale)
+      # 自動翻訳元指定されていなくて、
+      # 自動翻訳先指定されているものを
+      # デフォルトで自動翻訳ONにする
+      translated_attribute_names.inject({}) do |defaults, attr_name|
+        defaults[:"#{attr_name}_automatically"] =
+            self.class.translated_field_automatically?(attr_name, locale) &&
+                !self.class.translate_field_automatically?(attr_name, locale)
+        defaults
+      end
+    end
+
+  end
+
+  module TranslationExtension
+    extend ActiveSupport::Concern
+    included do
+      include AfterCommitAction unless include?(AfterCommitAction)
+      after_save :after_save
+    end
+
+    private
+    def after_save
+      changed_attr_names =
+          globalized_model.translated_attribute_names & changes.keys.map(&:to_sym)
+
+      execute_after_commit do
+        globalized_model.run_automatic_translation(from_locale: locale,
+                                                   attribute_names: changed_attr_names)
+        true
+      end
+      true
+    end
+  end
+
+  module_function
+
+  def setup_automatic_translation!(klass, attr_names, options)
+    automatic_options = validate_options(parse_options(options))
+    locales = (automatic_options[:from] + automatic_options[:to]).uniq
+    klass.globalize_accessors locales: locales, attributes: attr_names
+    unless klass.include?(Globalize::Automatic::TranslatedExtension)
+      klass.include Globalize::Automatic::TranslatedExtension
+
+      klass.has_many :automatic_translations,
+                     dependent: :destroy,
+                     autosave: true,
+                     class_name: klass.automatic_translation_class.name,
+                     foreign_key: klass.name.foreign_key,
+                     inverse_of: :automatic_translated_model
+      automatic_table_name = "#{klass.table_name.singularize}_automatic_translations"
+      klass.automatic_translation_class.table_name = automatic_table_name
+      klass.automatic_translation_class.define_singleton_method(:table_name) { automatic_table_name }
+    end
+
+    klass.add_automatic_translation_field_locales!(attr_names, automatic_options[:from])
+    klass.add_automatic_translated_field_locales!(attr_names, automatic_options[:to])
+
+    attr_names.each do |attr_name|
+      locales.each do |locale|
+        klass.class_eval(<<"EVAL")
+        def #{attr_name}_#{locale.to_s.underscore}_automatically
+          automatic_translation_for(#{locale.inspect}).#{attr_name}_automatically
+        end
+
+        def #{attr_name}_#{locale.to_s.underscore}_automatically=(automatically)
+          automatic_translation_for(#{locale.inspect}).#{attr_name}_automatically = automatically
+        end
+ 
+        self.automatic_translation_attribute_names.push(:#{attr_name}_#{locale.to_s.underscore}_automatically)
+EVAL
+      end
+    end
+
+    unless klass.translation_class.include?(Globalize::Automatic::TranslationExtension)
+      klass.translation_class.include Globalize::Automatic::TranslationExtension
+    end
+  end
+
+  def parse_options(options)
+    case options
+      when Hash
+        from_locales = normalize_locales(options[:from])
+        to_locales = normalize_locales(options[:to])
+      else
+        from_locales = normalize_locales(options)
+        to_locales = I18n.available_locales
+    end
+    {from: from_locales, to: to_locales}
+  end
+
+  def normalize_locales(locales)
+    [locales].flatten.compact.map(&:to_sym)
+  end
+
+  def validate_options(options)
+    if options[:from].empty?
+      raise ArgumentError.new('missing :from option')
+    elsif options[:to].empty?
+      raise ArgumentError.new('missing :to option')
+    else
+      options
+    end
+  end
+end
+Globalize::Automatic.asynchronously = false
+Globalize::Automatic.translator = Globalize::Automatic::Translator::EasyTranslate.new
+
+Globalize::ActiveRecord::ActMacro.module_eval do
+
+  def translates_with_automatic(*attr_names)
+    translates_without_automatic(*attr_names).tap do
+      options = attr_names.extract_options!
+      automatic_options = options.delete(:automatic)
+      if automatic_options.present?
+        Globalize::Automatic.setup_automatic_translation!(self, attr_names, automatic_options)
+      end
+    end
+  end
+
+  alias_method_chain :translates, :automatic
+
+end

data/lib/globalize/automatic/translation.rb

@@ -0,0 +1,78 @@
+class Globalize::Automatic::Translation < ActiveRecord::Base
+  self.abstract_class = true
+
+  def from_locale(attr_name)
+    automatic_translated_model.automatic_translation_locale(attr_name)
+  end
+
+  def translation_from(attr_name)
+    translation_for(from_locale(attr_name))
+  end
+
+  def translation_to
+    translation_for(locale)
+  end
+
+  def translation_for(target_locale)
+    automatic_translated_model.translation_for(target_locale)
+  end
+
+  def translate(attr_name)
+    if automatically_for?(attr_name)
+      Globalize::Automatic.asynchronously ?
+          Globalize::Automatic::TranslationJob.perform_later(self, attr_name) :
+          Globalize::Automatic::TranslationJob.perform_now(self, attr_name)
+    end
+  end
+
+  def resolve(attr_name, translated)
+    obj = translation_to
+    obj.transaction do
+      obj.lock!
+      obj[attr_name] = translated
+      obj.save!(validate: false)
+    end
+  end
+
+  def reject(attr_name, error); end
+
+  private
+  def automatically_for?(attr_name)
+    self[self.class.automatically_column_name(attr_name)]
+  end
+
+  class << self
+    def create_table!(*fields)
+      connection.create_table(table_name) do |t|
+        t.references automatic_translated_model_foreign_key.sub(/_id$/, ''), null: false, index: false
+        t.string :locale, null: false
+        fields.each do |field|
+          t.boolean *automatically_column_args(field)
+        end
+        t.timestamps null: false
+      end
+    end
+
+    def drop_table!
+      connection.drop_table(table_name)
+    end
+
+    def add_fields!(*fields)
+      connection.change_table(table_name) do |t|
+        fields.each do |field|
+          t.boolean *automatically_column_args(field)
+        end
+      end
+    end
+
+    def automatically_column_name(field)
+      :"#{field}_automatically"
+    end
+
+    private
+    def automatically_column_args(field)
+      args = [automatically_column_name(field), default: false, null: false]
+    end
+  end
+
+end

data/lib/globalize/automatic/translation_job.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Globalize::Automatic::TranslationJob < ActiveJob::Base
+  queue_as :default
+
+  def perform(automatic_translation, attr_name)
+    Globalize::Automatic.translator.run(automatic_translation, attr_name)
+  end
+
+end

data/lib/globalize/automatic/translator.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class Globalize::Automatic::Translator
+
+  def run(automatic_translation, attr_name)
+    translation = automatic_translation.translation_from(attr_name)
+    text = translation[attr_name]
+    from = translation.locale
+    to = automatic_translation.locale
+    _text, _from, _to = before_translate(text, from, to)
+    translated = translate(_text, _from, _to)
+    _text, _from, _to, _translated = after_translate(_text, _from, _to, translated)
+    automatic_translation.resolve(attr_name, _translated)
+  end
+
+  def translate(text, from, to); end
+
+  def before_translate(text, from, to)
+    [text, from, to]
+  end
+
+  def after_translate(text, from, to, result)
+    [text, from, to, result]
+  end
+
+end

data/lib/globalize/automatic/translator/easy_translate.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'globalize/automatic/translator'
+require 'easy_translate'
+
+class Globalize::Automatic::Translator::EasyTranslate < Globalize::Automatic::Translator
+
+  def translate(text, from, to)
+    ::EasyTranslate.translate(text, from: from, to: to)
+  end
+
+end

data/lib/globalize/automatic/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Globalize
+  module Automatic
+    VERSION = '0.0.1'
+  end
+end

metadata

@@ -0,0 +1,180 @@
+--- !ruby/object:Gem::Specification
+name: globalize-automatic
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Yuichi Takeuchi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: globalize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: globalize-accessors
+  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: after_commit_action
+  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: easy_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: activerecord
+  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: activejob
+  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: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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: rspec-rails
+  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'
+description: Provides support for using automatic translation gems with Globalize.
+email:
+- info@takeyu-web.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/globalize-automatic.rb
+- lib/globalize/automatic.rb
+- lib/globalize/automatic/translation.rb
+- lib/globalize/automatic/translation_job.rb
+- lib/globalize/automatic/translator.rb
+- lib/globalize/automatic/translator/easy_translate.rb
+- lib/globalize/automatic/version.rb
+homepage: https://github.com/takeyuweb/globalize-automatic/
+licenses:
+- MIT
+metadata: {}
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Adapter for using automatic translation gems with Globalize
+test_files: []