lokalise_rails 1.4.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6448a3718185d09a6712428f671e02121e59c967199ae6e24f27b8623f12b280
-  data.tar.gz: c0f2501d9c937b26088ee23a6603a842121cb6a88516ae19d09d40abe1968161
+  metadata.gz: eac9b215d2e4002517b8dc09f29841e78cf349178639069e963bd4b0555cce93
+  data.tar.gz: 00aacebe6b1f54d80b4d3832c16a38e6863c469ba09cee44fffae9e8373772a6
 SHA512:
-  metadata.gz: be178f379eb4abbb4d50c4f3817422c665bed0c8a75f256c083b0229a57594956ca8c42648fe98be40ed1c4183f0e00fd51fcaf153a87ed408279c1d2ac152ec
-  data.tar.gz: db7dd0efdb0d9a7b72116adba959a04b899e41d5ccd89181f48e2ec2e1d097ebfebb732e6592c725b831cebf89134e77e0639deb8591876267306583064efa96
+  metadata.gz: b8647b6b7b1b691a03146fc69934f54fe550a76c547d4add769900095fa409949e982777b210cf977ee8523087f2f2864d5c4d141953d0513c5465b5ec21254b
+  data.tar.gz: 5e807d85f5cdf3c693d90ae0bbff1c2e0fcedc2ac5cf76d90ae65bb9e9992583cb72c13db29f05b028f9015668b4ace1e20936e3d67b4003337931b03233d2b3

data/CHANGELOG.md

@@ -1,5 +1,58 @@
 # Changelog
 
+## 4.0.0 (27-Jan-22)
+
+* File exporting is now multi-threaded as Lokalise API started to support parallel requests since January 2022
+* Test with Ruby 3.1
+
+## 3.0.0 (14-Oct-21)
+
+This is a major re-write of this gem. The actual import/export functionality was extracted to a separate gem called [lokalise_manager](https://github.com/bodrovis/lokalise_manager) that you can use to run your tasks programmatically from *any* Ruby scripts (powered or not powered by Rails). LokaliseRails now has only the Rails-related logic (even though it should probably work with other frameworks as well).
+
+* **Breaking change:** the global config class is renamed therefore update your `config/lokalise_rails.rb` file to look like this:
+
+```ruby
+LokaliseRails::GlobalConfig.config do |c|
+  # ...your configuration options provided as before...
+end
+```
+
+* **Breaking change**: the `branch` config option now has `""` set as default value (it was `"master"` previously). Therefore, you might need to explicitly state which branch to use now:
+
+```ruby
+LokaliseRails::GlobalConfig.config do |c|
+  c.branch = "master"
+end
+```
+
+* **Breaking change**: to run your task prommatically, use a new approach:
+
+```ruby
+LokaliseManager.importer(optional_config, global_config_object).import!
+
+LokaliseManager.exporter(optional_config, global_config_object).export!
+```
+
+* Please check [this document section](https://github.com/bodrovis/lokalise_rails#running-tasks-programmatically) to learn more about running tasks programmatically. This change doesn't have any effect on you if you're using only Rake tasks to import/export files.
+* No need to say `require 'lokalise_rails` in your `lokalise_rails.rb` config file anymore.
+
+## 2.0.0 (19-Aug-21)
+
+* Add exponential backoff mechanism for file imports to comply with the upcoming API changes ("rate limiting"), see below for more details.
+* Add `max_retries_import` option with a default value of `5`.
+
+## 2.0.0.rc1 (12-Aug-21)
+
+* **Lokalise is introducing API rate limiting.** Access to all endpoints will be limited to 6 requests per second from 14 September, 2021. This limit is applied per API token and per IP address. If you exceed the limit, a 429 HTTP status code will be returned and a `Lokalise::Error::TooManyRequests` exception will be raised. Therefore, to overcome this issue LokaliseRails is introducing an exponential backoff mechanism for file exports. Why? Because if you have, say, 10 translation files, we'll have to send 10 separate API requests which will probably mean exceeding the limit (this is not the case with importing as we're always receiving a single archive). Thus, if the HTTP status code 429 was received, we'll do the following:
+
+```ruby
+sleep 2 ** retries
+retries += 1
+```
+
+* If the maximum number of retries has been reached LokaliseRails will re-raise the `Lokalise::Error::TooManyRequests` error and give up. By default, the maximum number of retries is set to `5` but you can control it using the `max_retries_export` option.
+* Enabled compression for the API client.
+
 ## 1.4.0 (29-Jun-21)
 
 * Re-worked exception handling. Now when something goes wrong during the import or export process, this gem will re-raise all such errors (previously it just printed out some errors to the `$stdout`). If you run a Rake task, it will exit with a status code `1` and the actual error message. If you run a task programattically, you'll get an exception.

data/Gemfile

@@ -5,5 +5,16 @@ source 'http://rubygems.org'
 gemspec
 
 group :test do
+  gem 'codecov', '~> 0.2'
+  gem 'dotenv', '~> 2.5'
+  gem 'rails', '~> 7.0.0'
+  gem 'rake', '~> 13.0'
+  gem 'rspec', '~> 3.6'
+  gem 'rubocop', '~> 1.0'
+  gem 'rubocop-performance', '~> 1.5'
+  gem 'rubocop-rspec', '~> 2.6'
+  gem 'simplecov', '~> 0.16'
+  gem 'sprockets-rails', '~> 3'
   gem 'tzinfo-data', platforms: %i[mingw mswin x64_mingw jruby]
+  gem 'vcr', '~> 6.0'
 end

data/README.md

@@ -1,11 +1,11 @@
 # LokaliseRails
 
 ![Gem](https://img.shields.io/gem/v/lokalise_rails)
-[![Build Status](https://travis-ci.com/bodrovis/lokalise_rails.svg?branch=master)](https://travis-ci.com/github/bodrovis/lokalise_rails)
+![CI](https://github.com/bodrovis/lokalise_rails/actions/workflows/ci.yml/badge.svg)
 [![Test Coverage](https://codecov.io/gh/bodrovis/lokalise_rails/graph/badge.svg)](https://codecov.io/gh/bodrovis/lokalise_rails)
 ![Downloads total](https://img.shields.io/gem/dt/lokalise_rails)
 
-This gem provides [Lokalise](http://lokalise.com) integration for Ruby on Rails and allows to exchange translation files easily. It relies on [ruby-lokalise-api](https://lokalise.github.io/ruby-lokalise-api) to send APIv2 requests.
+This gem provides [Lokalise](http://lokalise.com) integration for Ruby on Rails and allows to exchange translation files easily. It relies on [lokalise_manager](https://github.com/bodrovis/lokalise_manager) which perform the actual import/export and can be used to run this task in any Ruby script.
 
 *If you would like to know how this gem was built, check out the ["How to create a Ruby gem" series at Lokalise blog](https://lokalise.com/blog/create-a-ruby-gem-basics/).*
 
@@ -15,6 +15,8 @@ This gem provides [Lokalise](http://lokalise.com) integration for Ruby on Rails
 
 This gem requires Ruby 2.5+ and Rails 5.1+. It might work with older versions of Rails though. You will also need to [setup a Lokalise account](https://app.lokalise.com/signup) and create a [translation project](https://docs.lokalise.com/en/articles/1400460-projects). Finally, you will need to generate a [read/write API token](https://docs.lokalise.com/en/articles/1929556-api-tokens) at your Lokalise profile.
 
+Alternatively, you can utilize a token obtained via OAuth 2 flow. When using such a token, you'll have to set `:use_oauth2_token` option to `true` (please check [options docs](https://github.com/bodrovis/lokalise_manager#common-config) to learn more).
+
 ### Installation
 
 Add the gem to your `Gemfile`:
@@ -33,9 +35,7 @@ rails g lokalise_rails:install
 The latter command will generate a new config file `config/lokalise_rails.rb` looking like this:
 
 ```ruby
-require 'lokalise_rails'
-
-LokaliseRails.config do |c|
+LokaliseRails::GlobalConfig.config do |c|
   c.api_token = ENV['LOKALISE_API_TOKEN']
   c.project_id = ENV['LOKALISE_PROJECT_ID']
 
@@ -45,7 +45,7 @@ end
 
 You have to provide `api_token` and `project_id` to proceed. `project_id` can be found in your Lokalise project settings.
 
-[Other options can be customized as well (see below)](https://github.com/bodrovis/lokalise_rails#import-settings) but they have sensible defaults.
+Other options can be customized as well but they have sensible defaults. To learn about all the available options please check [lokalise_manager docs](https://github.com/bodrovis/lokalise_manager#configuration). The generated config file also contains some examples to help you get started.
 
 ## Importing translations from Lokalise
 
@@ -55,7 +55,7 @@ To import translations from the specified Lokalise project to your Rails app, ru
 rails lokalise_rails:import
 ```
 
-Please note that any duplicating files inside the `locales` directory (or any other directory that you've specified in the options) will be overwritten! You may enable [safe mode](https://github.com/bodrovis/lokalise_rails#import-settings) to check whether the folder is empty or not.
+Please note that any duplicating files inside the `locales` directory (or any other directory that you've specified in the options) will be overwritten! You can enable [safe mode](https://github.com/bodrovis/lokalise_manager#import-config) to check whether the folder is empty or not.
 
 ## Exporting translations to Lokalise
 
@@ -67,81 +67,101 @@ rails lokalise_rails:export
 
 ## Running tasks programmatically
 
-You can also run the import and export tasks from the Rails app:
+You can also run the import and export tasks programmatically from your code. To achieve that, please check the [`lokalise_manager`](https://github.com/bodrovis/lokalise_manager) gem which `lokalise_rails` relies on.
+
+For example, you can use the following approach:
 
 ```ruby
+# This line is actually not required. Include it if you would like to use your global settings:
 require "#{Rails.root}/config/lokalise_rails.rb"
 
-# Import the files:
-result = LokaliseRails::TaskDefinition::Importer.import!
+importer = LokaliseManager.importer({api_token: '1234abc', project_id: '123.abc'}, LokaliseRails::GlobalConfig)
+
+# OR
+
+exporter = LokaliseManager.exporter({api_token: '1234abc', project_id: '123.abc'}, LokaliseRails::GlobalConfig)
 ```
-`result` contains a boolean value with the result of the operation
+
+The first argument passed to `importer` or `exporter` is the hash containing per-client options. This is an optional argument and you can simply pass an empty hash if you don't want to override any global settings.
+
+The second argument is the name of your global config which is usually stored inside the `lokalise_rails.rb` file (however, you can subclass this global config and even adjust the defaults [as explained here](https://github.com/bodrovis/lokalise_manager#overriding-defaults)). If you would like to use `LokaliseRails` global defaults, then you must pass this class to the clients. If you don't do this, then `LokaliseManager` defaults will be used instead. The only difference is the location where translation files are stored. For `LokaliseManager` we use `./locales` directory, whereas for `LokaliseRails` the directory is `./config/locales`.
+
+However, you can also provide the translation files folder on per-client basis, for instance:
 
 ```ruby
-# Export the files:
-processes = LokaliseRails::TaskDefinition::Exporter.export!
+importer = LokaliseManager.importer api_token: '1234abc', project_id: '123.abc', locales_path: "#{Rails.root}/config/locales"
 ```
 
-`processes` contains a list of [queued background processes](https://lokalise.github.io/ruby-lokalise-api/api/queued-processes).
+After the client is instantiated, you can run the corresponding task:
+
+```ruby
+importer.import!
+
+# OR 
+
+exporter.export!
+```
 
 ## Configuration
 
 Options are specified in the `config/lokalise_rails.rb` file.
 
-### Global settings
+Here's an example:
 
-* `api_token` (`string`, required) - Lokalise API token with read/write permissions.
-* `project_id` (`string`, required) - Lokalise project ID. You must have import/export permissions in the specified project.
-* `locales_path` (`string`) - path to the directory with your translation files. Defaults to `"#{Rails.root}/config/locales"`.
-* `branch` (`string`) - Lokalise project branch to use. Defaults to `"master"`.
-* `timeouts` (`hash`) - set [request timeouts for the Lokalise API client](https://lokalise.github.io/ruby-lokalise-api/additional_info/customization#setting-timeouts). By default, requests have no timeouts: `{open_timeout: nil, timeout: nil}`. Both values are in seconds.
+```ruby
+LokaliseRails::GlobalConfig.config do |c|
+  # These are mandatory options that you must set before running rake tasks:
+  c.api_token = ENV['LOKALISE_API_TOKEN']
+  c.project_id = ENV['LOKALISE_PROJECT_ID']
 
-### Import settings
+  # Provide a custom path to the directory with your translation files:
+  # c.locales_path = "#{Rails.root}/config/locales"
 
-* `import_opts` (`hash`) - options that will be passed to Lokalise API when downloading translations to your app. Here are the default options:
+  # Provide a Lokalise project branch to use:
+  c.branch = 'develop'
 
-```ruby
-{
-  format: 'yaml',
-  placeholder_format: :icu,
-  yaml_include_root: true,
-  original_filenames: true,
-  directory_prefix: '',
-  indentation: '2sp'
-}
-```
+  # Provide request timeouts for the Lokalise API client:
+  c.timeouts = {open_timeout: 5, timeout: 5}
 
-Full list of available import options [can be found in the official API documentation](https://app.lokalise.com/api2docs/curl/#transition-download-files-post).
-* `import_safe_mode` (`boolean`) - default to `false`. When this option is enabled, the import task will check whether the directory set with `locales_path` is empty or not. If it is not empty, you will be prompted to continue.
+  # Provide maximum number of retries for file exporting:
+  c.max_retries_export = 5
 
-### Export settings
+  # Provide maximum number of retries for file importing:
+  c.max_retries_import = 5
 
-* `export_opts` (`hash`) - options that will be passed to Lokalise API when uploading translations. Full list of available export options [can be found in the official documentation](https://app.lokalise.com/api2docs/curl/#transition-download-files-post). By default, the following options are provided:
-  + `data` (`string`, required) - base64-encoded contents of the translation file.
-  + `filename` (`string`, required) - translation file name. If the file is stored under a subdirectory (for example, `nested/en.yml` inside the `locales/` directory), the whole path acts as a name. Later when importing files with such names, they will be placed into the proper subdirectories.
-  + `lang_iso` (`string`, required) - language ISO code which is determined using the root key inside your YAML file. For example, in this case the `lang_iso` is `en_US`:
+  # Import options have the following defaults:
+  # c.import_opts = {
+  #   format: 'yaml',
+  #   placeholder_format: :icu,
+  #   yaml_include_root: true,
+  #   original_filenames: true,
+  #   directory_prefix: '',
+  #   indentation: '2sp'
+  # }
 
-```yaml
-en_US:
-  my_key: "my value"
-```
+  # Safe mode for imports is disabled by default:
+  # c.import_safe_mode = false
 
-**Please note** that if your Lokalise project does not have a language with the specified `lang_iso` code, the export will fail.
+  # Additional export options (only filename, contents, and lang_iso params are provided by default)
+  # c.export_opts = {}
 
-* `skip_file_export` (`lambda` or `proc`) - specify additional exclusion criteria for the exported files. By default, the rake task will ignore all non-file entries and all files with improper extensions (the latter is controlled by the `file_ext_regexp`). Lambda passed to this option should accept a single argument which is full path to the file (instance of the [`Pathname` class](https://ruby-doc.org/stdlib-2.7.1/libdoc/pathname/rdoc/Pathname.html)). For example, to exclude all files that have `fr` part in their names, add the following config:
+  # Provide additional file exclusion criteria for exports (by default, any file with the proper extension will be exported)
+  # c.skip_file_export = ->(file) { file.split[1].to_s.include?('fr') }
 
-```ruby
-c.skip_file_export = ->(file) { f.split[1].to_s.include?('fr') }
-```
+  # Set the options below if you would like to work with format other than YAML
+  ## Regular expression to use when choosing the files to extract from the downloaded archive and upload to Lokalise
+  ## c.file_ext_regexp = /\.ya?ml\z/i
 
-### Settings to work with formats other than YAML
+  ## Load translations data and make sure they are valid:
+  ## c.translations_loader = ->(raw_data) { YAML.safe_load raw_data }
 
-If your translation files are not in YAML format, you will need to adjust the following options:
+  ## Convert translations data to a proper format:
+  ## c.translations_converter = ->(raw_data) { raw_data.to_yaml }
 
-* `file_ext_regexp` (`regexp`) - regular expression applied to file extensions to determine which files should be imported and exported. Defaults to `/\.ya?ml\z/i` (YAML files).
-* `translations_loader` (`lambda` or `proc`) - loads translations data and makes sure they are valid before saving them to a translation file. Defaults to `->(raw_data) { YAML.safe_load raw_data }`. In the simplest case you may just return the data back, for example `-> (raw_data) { raw_data }`.
-* `translations_converter` (`lambda` or `proc`) - converts translations data to a proper format before saving them to a translation file. Defaults to `->(raw_data) { raw_data.to_yaml }`. In the simplest case you may just return the data back, for example `-> (raw_data) { raw_data }`.
-* `lang_iso_inferer` (`lambda` or `proc`) - infers language ISO code based on the translation file data before uploading it to Lokalise. Defaults to `->(data) { YAML.safe_load(data)&.keys&.first }`.
+  ## Infer language ISO code for the translation file:
+  ## c.lang_iso_inferer = ->(data) { YAML.safe_load(data)&.keys&.first }
+end
+```
 
 ## Running tests
 

data/lib/generators/templates/lokalise_rails_config.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require 'lokalise_rails'
-
-LokaliseRails.config do |c|
+LokaliseRails::GlobalConfig.config do |c|
   # These are mandatory options that you must set before running rake tasks:
   # c.api_token = ENV['LOKALISE_API_TOKEN']
   # c.project_id = ENV['LOKALISE_PROJECT_ID']
@@ -11,11 +9,17 @@ LokaliseRails.config do |c|
   # c.locales_path = "#{Rails.root}/config/locales"
 
   # Provide a Lokalise project branch to use:
-  # c.branch = 'master'
+  # c.branch = ''
 
   # Provide request timeouts for the Lokalise API client:
   # c.timeouts = {open_timeout: nil, timeout: nil}
 
+  # Provide maximum number of retries for file exporting:
+  # c.max_retries_export = 5
+
+  # Provide maximum number of retries for file importing:
+  # c.max_retries_import = 5
+
   # Import options have the following defaults:
   # c.import_opts = {
   #   format: 'yaml',

data/lib/lokalise_rails/global_config.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module LokaliseRails
+  class GlobalConfig < LokaliseManager::GlobalConfig
+    class << self
+      def locales_path
+        @locales_path || "#{LokaliseRails::Utils.root}/config/locales"
+      end
+    end
+  end
+end

data/lib/lokalise_rails/utils.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module LokaliseRails
+  module Utils
+    class << self
+      def root
+        Pathname.new(rails_root || Dir.getwd)
+      end
+
+      def rails_root
+        return ::Rails.root.to_s if defined?(::Rails.root) && ::Rails.root
+        return RAILS_ROOT.to_s if defined?(RAILS_ROOT)
+
+        nil
+      end
+    end
+  end
+end

data/lib/lokalise_rails/version.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# :nocov:
 module LokaliseRails
-  VERSION = '1.4.0'
+  VERSION = '4.0.0'
 end
+# :nocov:

data/lib/lokalise_rails.rb

@@ -1,83 +1,11 @@
 # frozen_string_literal: true
 
-require 'lokalise_rails/error'
-require 'lokalise_rails/task_definition/base'
-require 'lokalise_rails/task_definition/importer'
-require 'lokalise_rails/task_definition/exporter'
+require 'lokalise_manager'
 
-module LokaliseRails
-  class << self
-    attr_accessor :api_token, :project_id
-    attr_writer :import_opts, :import_safe_mode, :export_opts, :locales_path,
-                :file_ext_regexp, :skip_file_export, :branch, :timeouts,
-                :translations_loader, :translations_converter, :lang_iso_inferer
-
-    # Main interface to provide configuration options for rake tasks
-    def config
-      yield self
-    end
-
-    # Full path to directory with translation files
-    def locales_path
-      @locales_path || "#{Rails.root}/config/locales"
-    end
-
-    # Project branch to use
-    def branch
-      @branch || 'master'
-    end
-
-    # Set request timeouts for the Lokalise API client
-    def timeouts
-      @timeouts || {}
-    end
-
-    # Regular expression used to select translation files with proper extensions
-    def file_ext_regexp
-      @file_ext_regexp || /\.ya?ml\z/i
-    end
-
-    # Options for import rake task
-    def import_opts
-      @import_opts || {
-        format: 'yaml',
-        placeholder_format: :icu,
-        yaml_include_root: true,
-        original_filenames: true,
-        directory_prefix: '',
-        indentation: '2sp'
-      }
-    end
+require 'lokalise_rails/utils'
+require 'lokalise_rails/global_config'
 
-    # Options for export rake task
-    def export_opts
-      @export_opts || {}
-    end
-
-    # Enables safe mode for import. When enabled, will check whether the target folder is empty or not
-    def import_safe_mode
-      @import_safe_mode.nil? ? false : @import_safe_mode
-    end
-
-    # Additional file skip criteria to apply when performing export
-    def skip_file_export
-      @skip_file_export || ->(_) { false }
-    end
-
-    def translations_loader
-      @translations_loader || ->(raw_data) { YAML.safe_load raw_data }
-    end
-
-    # Converts translations data to the proper format
-    def translations_converter
-      @translations_converter || ->(raw_data) { raw_data.to_yaml }
-    end
-
-    # Infers lang ISO for the given translation file
-    def lang_iso_inferer
-      @lang_iso_inferer || ->(data) { YAML.safe_load(data)&.keys&.first }
-    end
-  end
+module LokaliseRails
 end
 
 require 'lokalise_rails/railtie' if defined?(Rails)

data/lib/tasks/lokalise_rails_tasks.rake

@@ -1,17 +1,20 @@
 # frozen_string_literal: true
 
 require 'rake'
-require "#{Rails.root}/config/lokalise_rails"
+require 'lokalise_rails'
+require "#{LokaliseRails::Utils.root}/config/lokalise_rails"
 
 namespace :lokalise_rails do
   task :import do
-    LokaliseRails::TaskDefinition::Importer.import!
+    importer = LokaliseManager.importer({}, LokaliseRails::GlobalConfig)
+    importer.import!
   rescue StandardError => e
     abort e.inspect
   end
 
   task :export do
-    LokaliseRails::TaskDefinition::Exporter.export!
+    exporter = LokaliseManager.exporter({}, LokaliseRails::GlobalConfig)
+    exporter.export!
   rescue StandardError => e
     abort e.inspect
   end

data/lokalise_rails.gemspec

@@ -23,21 +23,9 @@ Gem::Specification.new do |spec|
   spec.extra_rdoc_files = ['README.md']
   spec.require_paths    = ['lib']
 
-  spec.add_dependency 'ruby-lokalise-api', '~> 4.0'
-  spec.add_dependency 'rubyzip', '~> 2.3'
+  spec.add_dependency 'lokalise_manager', '~> 2.0'
 
-  spec.add_development_dependency 'codecov', '~> 0.2'
-  spec.add_development_dependency 'dotenv', '~> 2.5'
-  if ENV['TEST_RAILS_VERSION'].nil?
-    spec.add_development_dependency 'rails', '~> 6.1.0'
-  else
-    spec.add_development_dependency 'rails', ENV['TEST_RAILS_VERSION'].to_s
-  end
-  spec.add_development_dependency 'rake', '~> 13.0'
-  spec.add_development_dependency 'rspec', '~> 3.6'
-  spec.add_development_dependency 'rubocop', '~> 1.0'
-  spec.add_development_dependency 'rubocop-performance', '~> 1.5'
-  spec.add_development_dependency 'rubocop-rspec', '~> 2.4.0'
-  spec.add_development_dependency 'simplecov', '~> 0.16'
-  spec.add_development_dependency 'vcr', '~> 6.0'
+  spec.metadata = {
+    'rubygems_mfa_required' => 'true'
+  }
 end

data/spec/dummy/config/lokalise_rails.rb

@@ -1,5 +1,5 @@
-require 'lokalise_rails'
-LokaliseRails.config do |c|
+LokaliseRails::GlobalConfig.config do |c|
   c.api_token = ENV['LOKALISE_API_TOKEN']
   c.project_id = ENV['LOKALISE_PROJECT_ID']
-end
+
+end

data/spec/lib/{lokalise_rails_spec.rb → lokalise_rails/global_config_spec.rb}

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-describe LokaliseRails do
-  it 'returns a proper version' do
-    expect(LokaliseRails::VERSION).to be_a(String)
-  end
+describe LokaliseRails::GlobalConfig do
+  let(:child_config) { Class.new(described_class) }
 
   it 'is possible to provide config options' do
     described_class.config do |c|
@@ -11,8 +9,22 @@ describe LokaliseRails do
     end
   end
 
+  it 'can be redefined' do
+    child_config.config do |c|
+      c.api_token = ENV['LOKALISE_API_TOKEN']
+      c.project_id = ENV['LOKALISE_PROJECT_ID']
+
+      c.branch = 'develop'
+    end
+
+    expect(child_config.branch).to eq('develop')
+    importer = LokaliseManager::TaskDefinitions::Importer.new({}, child_config)
+    expect(importer.config.branch).to eq('develop')
+    expect(importer.config.api_token).to eq(ENV['LOKALISE_API_TOKEN'])
+  end
+
   describe 'parameters' do
-    let(:fake_class) { class_double('LokaliseRails') }
+    let(:fake_class) { class_double(described_class) }
 
     it 'is possible to set project_id' do
       allow(fake_class).to receive(:project_id=).with('123.abc')
@@ -58,6 +70,16 @@ describe LokaliseRails do
       fake_class.import_safe_mode = true
     end
 
+    it 'is possible to set max_retries_export' do
+      allow(fake_class).to receive(:max_retries_export=).with(10)
+      fake_class.max_retries_export = 10
+    end
+
+    it 'is possible to set max_retries_import' do
+      allow(fake_class).to receive(:max_retries_import=).with(10)
+      fake_class.max_retries_import = 10
+    end
+
     it 'is possible to set api_token' do
       allow(fake_class).to receive(:api_token=).with('abc')
       fake_class.api_token = 'abc'

data/spec/lib/lokalise_rails/version_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+describe LokaliseRails do
+  it 'returns a proper version' do
+    expect(LokaliseRails::VERSION).to be_a(String)
+  end
+end

data/spec/lib/tasks/export_task_spec.rb

@@ -1,27 +1,26 @@
 # frozen_string_literal: true
 
-RSpec.describe LokaliseRails do
+RSpec.describe 'Export Rake task' do
+  let(:global_config) { LokaliseRails::GlobalConfig }
+
   it 'halts when the API key is not set' do
-    allow(described_class).to receive(:api_token).and_return(nil)
+    allow(global_config).to receive(:api_token).and_return(nil)
 
     expect(export_executor).to raise_error(SystemExit, /API token is not set/i)
-    expect(described_class).to have_received(:api_token)
+    expect(global_config).to have_received(:api_token)
   end
 
   it 'halts when the project ID is not set' do
-    allow_project_id nil do
-      expect(export_executor).to raise_error(SystemExit, /ID is not set/i)
-    end
-  end
+    allow(global_config).to receive(:project_id).and_return(nil)
+
+    expect(export_executor).to raise_error(SystemExit, /ID is not set/i)
 
-  it 'runs export rake task properly' do
-    expect(export_executor).to output(/complete!/).to_stdout
+    expect(global_config).to have_received(:project_id)
   end
 
   context 'with two translation files' do
     let(:filename_ru) { 'ru.yml' }
     let(:path_ru) { "#{Rails.root}/config/locales/#{filename_ru}" }
-    let(:relative_name_ru) { filename_ru }
 
     before :all do
       add_translation_files! with_ru: true
@@ -31,12 +30,20 @@ RSpec.describe LokaliseRails do
       rm_translation_files
     end
 
-    describe '.export!' do
-      it 're-raises export errors' do
-        allow_project_id
+    describe 'export' do
+      it 'is callable' do
+        allow_project_id global_config, ENV['LOKALISE_PROJECT_ID'] do
+          VCR.use_cassette('upload_files') do
+            expect(export_executor).to output(/complete!/).to_stdout
+          end
+        end
+      end
 
-        VCR.use_cassette('upload_files_error') do
-          expect(export_executor).to raise_error(SystemExit, /Unknown `lang_iso`/)
+      it 're-raises export errors' do
+        allow_project_id global_config, '542886116159f798720dc4.94769464' do
+          VCR.use_cassette('upload_files_error') do
+            expect(export_executor).to raise_error(SystemExit, /Unknown `lang_iso`/)
+          end
         end
       end
     end