yatapp 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5200403a78e7acd711275d6dada838fbe57d416c
-  data.tar.gz: cc684aa48838a2d86f59d0d6ab724c38ac3405f6
+  metadata.gz: c4e4df0058b393f148836a6d4823cc6f9fa5ba2b
+  data.tar.gz: 1454817ed2b8790839ee1dda1cccd44d29653f08
 SHA512:
-  metadata.gz: 663eeb97eeb640dc86a1d957b144e33045e03f07749a056d6958a3db67972e3f643c8dc2a2e95be358a883e9ec8b6a1b516fd71ade2e55b822fa099c3a705cbd
-  data.tar.gz: bd522fccdabdd2c0cf63924a3f9571ad15522a265f69d87254f28ca017266af76919a72cfe38b954a84230500b1367dca717b80cf5b6314a36db6a45c0618b10
+  metadata.gz: '0638437c0d6046cdaae8d5598a6a091a8e7e9a70bd19cbe1b90316a4ec622b166b37aca927d3c8a341cfc10208dac7202b60bc15a9f986dc8cd43c8e4da399e4'
+  data.tar.gz: 56c4ca50d7f120ad2568ff79ae4013bfd91a6adb54842efc860d54e1ee2e0e7cf7af38dd43b462f5f512f452446ffe587f1a031062a4270db828bd0e8d12c8c7

data/.gitignore

@@ -9,3 +9,4 @@
 /tmp/
 *.yata.yaml
 *.yata.yml
+.DS_Store

data/README.md

@@ -18,40 +18,109 @@ Or install it yourself as:
 
     $ gem install yatapp
 
-## Usage in Rails
-Before using Yata integration gem you need to configure it.
-We recommend adding the following lines to freshly created initialiser
-in your rails project:
+## Configuration
 
+Gem can be used in two ways:
+* integration through API
+* websocket integration
+
+### Configuration Parameters
+
+* `api_access_token` - access key to Yata (Organizations Settings > Security > API token)
+* `project_id` - project id you wish to fetch from (Organizations Settings > Security> Projects > Id)
+* `languages` - supported locales, add any locale you wish. Default: `[:en]`
+* `translation_format` - format you wish to get files in, available for now are (yaml, js, json, properties, xml, strings and plist). Default: `json`
+* `save_to_path` - you can define where files should be saved. Default: `/config/locales/`
+* `root` - add locale as root to file with translations. Default: `false`
+
+First two parameters are required and the rest is optional.
+
+Translations with root set to `false`:
+
+```yaml
+  # en.yml
+
+  hello: Hello
+  hello_name: Hello %{name}
+```
+
+Translations with root set to `true`:
+```yaml
+  # en.yml
+
+  en:
+    hello: Hello
+    hello_name: Hello %{name}
+```
+
+### API Integration
+
+Recommended configuration:
 
 ```ruby
+# config/initializers/yatapp.rb
 
 include Yatapp
 
 Yatapp.configure do |c|
-  c.api_access_token = ENV['YATA_API_KEY'] # access key to Yata
+  c.api_access_token = ENV['YATA_API_KEY']
+  c.project_id = ENV['YATA_PROJECT_ID']
+  c.languages  = ['en', 'de', 'en_US']
+  c.translations_format = 'json'
 end
+```
 
-yata_project do
-  project_id 'your-project-id' # project id you wish to fetch from (you can find it under settings of your organization)
-  languages  ['en', 'de']      # add any languages you wish by language code
-  translations_format 'json'   # format you wish to get files in, available for now are (yaml, js and json)
-end
+To save file in a different location from default or add a locale as a root, add to configuration two lines as in example below:
+
+```ruby
+  # config/initializers/yatapp.rb
+
+  include Yatapp
+
+  Yatapp.configure do |c|
+    c.api_access_token = ENV['YATA_API_KEY']
+    c.project_id = ENV['YATA_PROJECT_ID']
+    c.languages  = ['en', 'de', 'en_US']
+    c.translations_format = 'json'
+    c.save_to_path = '/public/locales/'
+    c.root = true
+  end
+```
+
+From now on your translations will be saved in `/public/locales/` directory and translations will have locale as a root.
+
+
+API integration allows you to download all translations using rake task:
+
+```bash
+$ rake yata:fetch_translations
+```
+
+### Websocket Integration
+
+Websocket integration connects to Yata server and stays open. All changes in translations are auto-fetched to the app.
 
-# another example of the same project, fetching js translation and saving it at custom path
-# (in this case to support rails assets pipe line)
-# please notice that if 'save_to_path' is not specified gem will save translations to the local directory
-# or in case of rails application into 'config/locales' directory
+When app connects to the Yata server for the first time it downloads all translation and saves them to the i18n store. Then all actions on translations like create, update and delete are broadcasting information and i18n store is updated.
 
-yata_project do
-  project_id 'your-project-id'            # project id you wish to fetch from (you can find it under settings of your organization)
-  languages  ['en', 'de']                 # add any languages you wish by language code
-  translations_format 'js'                # format you wish to get files in, available for now are (yaml, js and json)
-  save_to_path "app/assets/javascripts/"
+Add this line to configuration if you want to enable websocket integration.
+
+``` ruby
+# config/initializers/yatapp.rb
+
+include Yatapp
+
+Yatapp.configure do |c|
+  c.api_access_token = ENV['YATA_API_KEY']
+  c.project_id = ENV['YATA_PROJECT_ID']
+  c.languages  = ['en', 'de', 'en_US']
 end
 
+Yatapp.start_websocket
+
 ```
 
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/tasks/yata.rake

@@ -1,6 +1,6 @@
 namespace :yata do
   desc "gets all the languages translations"
   task :fetch_translations => :environment do
-    get_translations
+    Yatapp.get_translations
   end
 end

data/lib/yatapp.rb

@@ -2,55 +2,27 @@ require "yatapp/version"
 require "yatapp/configuration"
 require "yatapp/yata_api_caller"
 require 'yatapp/railtie' if defined?(Rails)
+require "yatapp/inbox.rb"
+require "yatapp/socket.rb"
 
 module Yatapp
   extend Configuration
 
   class << self
-    def included(includer)
-      includer.send(:include, Methods)
-      includer.extend(Methods)
-    end
-
-    def api_caller
-      @api_caller ||= YataApiCaller.new
-    end
-
-    def all_projects
-      @all_projects ||= []
-    end
-
-    def all_projects_add(project)
-      @all_projects ||= []
-      @all_projects << project
-    end
-  end
-
-  module Methods
-    def yata_project
-      @current_project = YataApiCaller.new
-      yield
-      Yatapp.all_projects_add(@current_project)
-    end
-
-    def languages(languages)
-      @current_project.set_languages(languages)
-    end
-
-    def save_to_path(path)
-      @current_project.set_save_to_path(path)
+    def get_translations
+      api_caller.get_translations
     end
 
-    def project_id(project_id)
-      @current_project.set_project_id(project_id)
+    def download_translations
+      api_caller.download_translations
     end
 
-    def translations_format(frmt)
-      @current_project.set_translation_format(frmt)
+    def start_websocket
+      Phoenix::Socket.new unless File.basename($0) == 'rake'
     end
 
-    def get_translations
-      Yatapp.all_projects.map { |p| p.get_translations }
+    def api_caller
+      @api_caller ||= YataApiCaller.new
     end
   end
 end

data/lib/yatapp/configuration.rb

@@ -3,7 +3,11 @@ module Yatapp
     CONFIGURATION_OPTIONS = [
       :languages,
       :api_access_token,
-      :project
+      :project_id,
+      :languages,
+      :translation_format,
+      :root,
+      :save_to_path
     ].freeze
 
     attr_accessor *CONFIGURATION_OPTIONS

data/lib/yatapp/inbox.rb

@@ -0,0 +1,45 @@
+require 'mutex_m'
+module Phoenix
+  class Inbox
+    # Read it or forget it
+
+    include Mutex_m
+    attr_reader :ttl, :data
+    def initialize(ttl:)
+      @ttl = ttl
+      @bucket = Time.now.to_i / ttl
+      @data = Hash.new { |h, k| h[k] = {} }
+      super()
+    end
+
+    def push(key, val)
+      synchronize do
+        ts = current_timestamp
+        (data[ts][key] = val).tap do
+          if data.keys.size >= 3
+            data.delete_if { |key, _| key < (ts - 1) }
+          end
+        end
+      end
+    end
+
+    alias_method :[]=, :push
+
+    def pop(key)
+      synchronize do
+        ts = current_timestamp
+        data[ts - 1].delete(key) { data[ts].delete(key) { yield }}
+      end
+    end
+
+    alias_method :delete, :pop
+
+    def key?(key)
+      data.values.any? { |v| v.key?(key) }
+    end
+
+    def current_timestamp
+      Time.now.to_i / ttl
+    end
+  end
+end

data/lib/yatapp/socket.rb

@@ -0,0 +1,235 @@
+require 'faye/websocket'
+require 'eventmachine'
+require 'yatapp/inbox'
+require 'json'
+require 'cgi'
+require 'uri'
+require 'pry'
+begin
+  require 'rails-i18n'
+rescue
+  puts "WARNING: Failed to require rails-i18n gem, websocket integration may fail."
+end
+
+module Phoenix
+  class Socket
+    include MonitorMixin
+    attr_reader :path, :socket, :inbox, :topic
+    attr_accessor :verbose, :join_options_proc, :connect_options_proc
+    attr_accessor *Yatapp::Configuration::CONFIGURATION_OPTIONS
+
+    def initialize
+      initialize_configuration
+      @path = "ws://run.yatapp.net/socket/websocket?api_token=#{api_access_token}"
+      @topic = "translations:#{project_id}"
+      @join_options = {}
+      @connect_options = {}
+      @inbox = Phoenix::Inbox.new(ttl: 15)
+      super() # MonitorMixin
+      @inbox_cond = new_cond
+      @thread_ready = new_cond
+      @topic_cond = new_cond
+      reset_state_conditions
+      request_reply(event: "ping", payload: {})
+    end
+
+    def request_reply(event:, payload: {}, timeout: 5) # timeout in seconds
+      ref = SecureRandom.uuid
+      synchronize do
+        ensure_connection
+        @topic_cond.wait_until { @topic_joined }
+        EM.next_tick { socket.send({ topic: topic, event: event, payload: payload, ref: ref }.to_json) }
+        log [event, ref]
+
+        # Ruby's condition variables only support timeout on the basic 'wait' method;
+        # This should behave roughly as if wait_until also support a timeout:
+        # `inbox_cond.wait_until(timeout) { inbox.key?(ref) || @dead }
+        #
+        # Note that this serves only to unblock the main thread, and should not halt execution of the
+        # socket connection. Therefore, there is a possibility that the inbox may pile up with
+        # unread messages if a lot of timeouts are encountered. A self-sweeping inbox will
+        # be implemented to prevent this.
+        ts = Time.now
+        loop do
+          inbox_cond.wait(timeout) # waits until time expires or signaled
+          break if inbox.key?(ref) || @dead
+          raise 'timeout' if timeout && Time.now > (ts + timeout)
+        end
+        inbox.delete(ref) { raise "reply #{ref} not found" }
+      end
+    end
+
+    def join_options
+      return @join_options unless join_options_proc
+      join_options_proc.call(@join_options)
+    end
+
+    def connect_options
+      return @connect_options unless connect_options_proc
+      connect_options_proc.call(@connect_options)
+    end
+
+    private
+
+    attr_reader :inbox_cond, :thread_ready
+
+    def initialize_configuration
+      options = Yatapp.options
+      Yatapp::Configuration::CONFIGURATION_OPTIONS.each do |key|
+        send("#{key}=", options[key])
+      end
+    end
+
+    def log(msg)
+      return unless @verbose
+      puts "[#{Thread.current[:id]}] #{msg} (#@topic_joined)"
+    end
+
+    def ensure_connection
+      connection_alive? or synchronize do
+        spawn_thread
+        thread_ready.wait(3)
+        if @dead
+          @spawned = false
+          raise 'dead connection timeout'
+        end
+      end
+    end
+
+    def connection_alive?
+      @ws_thread&.alive? && !@dead
+    end
+
+    def reset_state_conditions
+      @dead = true # no EM thread active, or the connection has been closed
+      @socket = nil # the Faye::Websocket::Client instance
+      @spawned = false # The thread running (or about to run) EventMachine has been launched
+      @join_ref = SecureRandom.uuid # unique id that Phoenix uses to identify the socket <-> channel connection
+      @topic_joined = false # The initial join request has been acked by the remote server
+    end
+
+    def add_new_key_to_i18n(key, values)
+      values.each do |value|
+        unless I18n.available_locales.include?(value['lang'].to_sym)
+          add_new_locale(value['lang'])
+        end
+
+        key_array = key.split(".")
+        translation_hash = key_array.reverse.inject(value['text']) {|acc, n| {n => acc}}
+        I18n.backend.store_translations(value['lang'].to_sym, translation_hash)
+        puts "new translation added: #{value['lang']} => #{key}: #{value['text']}"
+      end
+    end
+
+    def add_new_locale(lang)
+      existing_locales = I18n.config.available_locales
+      new_locales      = existing_locales << lang.to_sym
+      I18n.config.available_locales = new_locales.uniq
+    end
+
+    def handle_message(event)
+      data = JSON.parse(event.data)
+      log event.data
+      synchronize do
+        if data['event'] == 'phx_close'
+          log('handling close from message')
+          handle_close(event)
+        elsif data['event'] == 'new_translation'
+          payload = data['payload']
+          add_new_key_to_i18n(payload['key'], payload['values'])
+        elsif data['event'] == 'updated_translation'
+          payload = data['payload']
+          add_new_key_to_i18n(payload['new_key'], payload['values'])
+        elsif data['event'] == 'deleted translation'
+          puts 'deleted translation'
+        elsif data['ref'] == @join_ref && data['event'] == 'phx_error'
+          # NOTE: For some reason, on errors phx will send the join ref instead of the message ref
+          inbox_cond.broadcast
+        elsif data['ref'] == @join_ref
+          log ['join_ref', @join_ref]
+          @topic_joined = true
+          @topic_cond.broadcast
+        else
+          inbox[data['ref']] = data
+          inbox_cond.broadcast
+        end
+      end
+    end
+
+    def handle_open(event)
+      log 'open'
+      socket.send({ topic: topic, event: "phx_join", payload: join_options, ref: @join_ref, join_ref: @join_ref }.to_json)
+      synchronize do
+        @dead     = false
+        thread_ready.broadcast
+      end
+      Yatapp.download_translations
+    end
+
+    def handle_close(event)
+      synchronize do
+        reset_state_conditions
+        inbox_cond.signal
+        thread_ready.signal
+      end
+    end
+
+    def build_path
+      uri = URI.parse(path)
+      existing_query = CGI.parse(uri.query || '')
+      uri.query = URI.encode_www_form(existing_query.merge(connect_options))
+      uri.to_s
+    end
+
+    def spawn_thread
+      return if @spawned || connection_alive?
+      log 'spawning...'
+      @spawned = true
+      @ws_thread = Thread.new do
+        Thread.current[:id] = "WSTHREAD_#{SecureRandom.hex(3)}"
+        run_event_machine
+      end
+    end
+
+    def reconnect
+      @spawned = true
+      @ws_thread = Thread.new do
+        Thread.current[:id] = "WSTHREAD_#{SecureRandom.hex(3)}"
+        run_event_machine
+      end
+    end
+
+    def run_event_machine
+      EM.run do
+        synchronize do
+          log 'em.run.sync'
+          @socket = Faye::WebSocket::Client.new(build_path)
+          socket.on :open do |event|
+            handle_open(event)
+          end
+
+          socket.on :message do |event|
+            handle_message(event)
+          end
+
+          socket.on :close do |event|
+            log [:close, event.code, event.reason]
+            handle_close(event)
+            EM.tick_loop do
+              unless connection_alive?
+                spawn_thread
+                sleep(1)
+              else
+                EM.next_tick { socket.send({ topic: "translations:#{project_id}", event: "ping", payload: {}, ref: @join_ref }.to_json) }
+              end
+            end
+          end
+
+          EventMachine.add_periodic_timer(50) do
+            EM.next_tick { socket.send({ topic: "translations:#{project_id}", event: "ping", payload: {}, ref: @join_ref }.to_json) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yatapp/version.rb

@@ -1,3 +1,3 @@
 module Yatapp
-  VERSION = "0.4.3"
+  VERSION = "0.5.0"
 end

data/lib/yatapp/yata_api_caller.rb

@@ -1,60 +1,45 @@
-require 'faraday'
-require 'typhoeus'
-require 'typhoeus/adapters/faraday'
-require 'pry'
+require 'httparty'
 
 module Yatapp
   class YataApiCaller
     API_VERSION           = 'v1'
     API_END_POINT_URL     = "/api/:api_version/project/:project_id/:lang/:format"
-    API_BASE_URL          = "http://api.yatapp.net"
-    API_CALLER_ATTRIBUTES = [
-      :connection,
-      :languages,
-      :project_id,
-      :save_to_path,
-      :translation_format
-    ].freeze
+    API_BASE_URL          = "http://run.yatapp.net"
 
     attr_accessor *Yatapp::Configuration::CONFIGURATION_OPTIONS
-    attr_reader *API_CALLER_ATTRIBUTES
 
     def initialize
-      initialize_configuration
       @translation_format = 'json'
       @save_to_path       = ""
-      @connection         = prepare_connection
-    end
-
-    def set_languages(languages)
-      @languages = languages
-    end
-
-    def set_project_id(project_id)
-      @project_id = project_id
-    end
-
-    def set_save_to_path(path)
-      @save_to_path = path
-    end
-
-    def set_translation_format(translation_format)
-      @translation_format = translation_format
+      @root               = false
+      @languages          = ['en']
+      initialize_configuration
     end
 
     def get_translations
       languages.each do |lang|
         puts "Getting translation for #{lang}"
         api_url      = download_url(lang)
-        api_response = connection.get(api_url)
+        api_response = HTTParty.get(api_url)
         next if !should_save_the_translation?(api_response)
         save_translation(lang, api_response)
       end
     end
 
+    def download_translations
+      languages.each do |lang|
+        puts "Getting translation for #{lang}"
+        api_url      = download_url_websocket(lang)
+        puts api_url
+        api_response = HTTParty.get(api_url)
+        next if !should_save_the_translation?(api_response)
+        add_new_key_to_i18n(lang, JSON.parse(api_response.body))
+      end
+    end
+
     private
       def should_save_the_translation?(api_response)
-        if api_response.status != 200
+        if api_response.code != 200
           puts "INVALID RESPONSE: #{api_response.body}"
           return false
         end
@@ -68,16 +53,10 @@ module Yatapp
         end
       end
 
-      def prepare_connection
-        Faraday.new(url: API_BASE_URL) do |faraday|
-          faraday.adapter :typhoeus
-        end
-      end
-
       def save_translation(lang, response)
         bfp = save_file_path
-        File.open("#{bfp}#{lang}.yata.#{translation_format}", 'wb') { |f| f.write(response.body) }
-        puts "#{lang}.yata.#{translation_format} saved"
+        File.open("#{bfp}#{lang}.#{translation_format}", 'wb') { |f| f.write(response.body) }
+        puts "#{lang}.#{translation_format} saved"
       end
 
       def save_file_path
@@ -89,12 +68,37 @@ module Yatapp
       end
 
       def download_url(lang)
-        url = API_END_POINT_URL.sub(':project_id', project_id)
+        url = API_BASE_URL + API_END_POINT_URL
+        url = url.sub(':project_id', project_id)
         url = url.sub(':format', translation_format)
         url = url.sub(':api_version', API_VERSION)
         url = url.sub(':lang', lang)
-        url = url + "?apiToken=#{api_access_token}"
+        url = url + "?apiToken=#{api_access_token}&root=#{root}"
+      end
+
+      def download_url_websocket(lang)
+        url = API_BASE_URL + API_END_POINT_URL
+        url = url.sub(':project_id', project_id)
+        url = url.sub(':format', 'json')
+        url = url.sub(':api_version', API_VERSION)
+        url = url.sub(':lang', lang)
+        url = url + "?apiToken=#{api_access_token}&root=true"
       end
 
+      def add_new_key_to_i18n(lang, api_response)
+        unless I18n.available_locales.include?(lang.to_sym)
+          add_new_locale(lang)
+        end
+
+        translations = api_response[lang]
+        I18n.backend.store_translations(lang.to_sym, translations)
+        puts "Loaded all #{lang} translations."
+      end
+
+      def add_new_locale(lang)
+        existing_locales = I18n.config.available_locales
+        new_locales      = existing_locales << lang.to_sym
+        I18n.config.available_locales = new_locales.uniq
+      end
   end
 end

data/yatapp.gemspec

@@ -27,9 +27,12 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency 'faraday'
-  spec.add_dependency 'typhoeus'
-  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_dependency 'faye-websocket'
+  spec.add_dependency 'rails-i18n'
+  spec.add_dependency 'httparty'
+  spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "webmock"
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: yatapp
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
 platform: ruby
 authors:
 - luki3k5
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-02-28 00:00:00.000000000 Z
+date: 2018-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: faraday
+  name: faye-websocket
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -25,7 +25,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: typhoeus
+  name: rails-i18n
+  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: httparty
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -44,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '1.16'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '1.16'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +94,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: webmock
+  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: This gem allows for easy integration with Yata to fetch translation files
   from the service
 email:
@@ -101,7 +143,9 @@ files:
 - lib/tasks/yata.rake
 - lib/yatapp.rb
 - lib/yatapp/configuration.rb
+- lib/yatapp/inbox.rb
 - lib/yatapp/railtie.rb
+- lib/yatapp/socket.rb
 - lib/yatapp/version.rb
 - lib/yatapp/yata_api_caller.rb
 - yatapp.gemspec
@@ -125,7 +169,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: This gem allows for easy integration with Yata to fetch translation files