lokalise_manager 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f68d621f5413a53e386f1d1f1539e8f824f6f3e90e81c0fb93c71e9e1c271c9a
-  data.tar.gz: ecaf5166531cb24f7fa6162ea11d86f885ead2e911f40543cdd08e717e9731e4
+  metadata.gz: 71731c95118ae4f31be9e82b256aa2cc17094a0ab64b5a186b95cb37843fec52
+  data.tar.gz: d8cbbfd4d60926f2f62323e0908addacf218425fc7e2b579d2f748d0e9acdf93
 SHA512:
-  metadata.gz: 659795e4573dab1751fa00b7d23ed43d6c9b276561fc763341b9a2d72dabadb9e8eeb638a7888d4f736b42e49efcb75a627d12c3b5bc63c9a46f369077dacb2c
-  data.tar.gz: f3681cca401d48512786731538697a2dcac4a7f47ab8d7037a6ce9444308dc4ab71ee34220218654dc71823c1d1a0b3945494015f6f822ac089ca87627a92d1d
+  metadata.gz: d457a5a7e4f703b80c3780e1a35e75278671c78f9caa0464bb0488352fa2772500e9f4f921446f8a3b51e9240fd229b1935705ba5b86263cb9e20bd27eab274d
+  data.tar.gz: 7053cf881bee4814dd67f17238557f7e19a0f6dc96109cf88700845018110c083612477eb15b49643d2459332d7e6abbd705cfe9322d36aa4735d7e73bcf887c

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 3.1.0 (17-Aug-22)
+
+* The default format is now `ruby_yaml` (it used to be `yaml`)
+
 ## 3.0.0 (11-Mar-22)
 
 * **Breaking change**: Require Ruby 2.7 or above

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 Lokalise team, Ilya Bodrov
+Copyright (c) 2022 Lokalise team, Ilya Krukowski
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -111,7 +111,7 @@ Please don't forget that Lokalise API has rate limiting and you cannot send more
 
 ```ruby
 {
-  format: 'yaml',
+  format: 'ruby_yaml',
   placeholder_format: :icu,
   yaml_include_root: true,
   original_filenames: true,
@@ -120,7 +120,7 @@ Please don't forget that Lokalise API has rate limiting and you cannot send more
 }
 ```
 
-Full list of available import options [can be found in the official API documentation](https://app.lokalise.com/api2docs/curl/#transition-download-files-post).
+Full list of available import options [can be found in the official API documentation](https://developers.lokalise.com/reference/download-files).
 
 You can provide additional options, and they will be merged with the default ones. For example:
 
@@ -135,7 +135,7 @@ In this case the `import_opts` will have `original_filenames` set to `true` and
 ```ruby
 importer = LokaliseManager.importer api_token: '1234abc',
                                     project_id: '123.abc',
-                                    import_opts: {indentation: '4sp}
+                                    import_opts: {indentation: '4sp'}
 ```
 
 * `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.
@@ -143,7 +143,7 @@ importer = LokaliseManager.importer api_token: '1234abc',
 
 ### Export config
 
-* `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-upload-a-file-post). By default, the following options are provided:
+* `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://developers.lokalise.com/reference/upload-a-file). 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`:
@@ -302,4 +302,4 @@ importer.import!
 
 ## License
 
-Copyright (c) [Lokalise team](http://lokalise.com), [Ilya Bodrov](http://bodrovis.tech). License type is [MIT](https://github.com/bodrovis/lokalise_manager/blob/master/LICENSE).
+Copyright (c) [Lokalise team](http://lokalise.com), [Ilya Krukowski](http://bodrovis.tech). License type is [MIT](https://github.com/bodrovis/lokalise_manager/blob/master/LICENSE).

data/lib/lokalise_manager/global_config.rb

@@ -65,7 +65,7 @@ module LokaliseManager
       # Options for import rake task
       def import_opts
         @import_opts || {
-          format: 'yaml',
+          format: 'ruby_yaml',
           placeholder_format: :icu,
           yaml_include_root: true,
           original_filenames: true,

data/lib/lokalise_manager/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LokaliseManager
-  VERSION = '3.0.0'
+  VERSION = '3.1.0'
 end

data/lokalise_manager.gemspec

@@ -5,7 +5,7 @@ require File.expand_path('lib/lokalise_manager/version', __dir__)
 Gem::Specification.new do |spec|
   spec.name                  = 'lokalise_manager'
   spec.version               = LokaliseManager::VERSION
-  spec.authors               = ['Ilya Bodrov']
+  spec.authors               = ['Ilya Krukowski']
   spec.email                 = ['golosizpru@gmail.com']
   spec.summary               = 'Lokalise integration for Ruby'
   spec.description           = 'This gem contains a collection of some common tasks for Lokalise. Specifically, it allows to import/export translation files from/to Lokalise TMS.'
@@ -19,7 +19,6 @@ Gem::Specification.new do |spec|
                    'lib/**/*.rake',
                    'lokalise_manager.gemspec', '.github/*.md',
                    'Gemfile', 'Rakefile']
-  spec.test_files       = Dir['spec/**/*.rb']
   spec.extra_rdoc_files = ['README.md']
   spec.require_paths    = ['lib']
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lokalise_manager
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.1.0
 platform: ruby
 authors:
-- Ilya Bodrov
+- Ilya Krukowski
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-11 00:00:00.000000000 Z
+date: 2022-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-lokalise-api
@@ -204,16 +204,6 @@ files:
 - lib/lokalise_manager/utils/hash_utils.rb
 - lib/lokalise_manager/version.rb
 - lokalise_manager.gemspec
-- spec/lib/lokalise_manager/global_config_spec.rb
-- spec/lib/lokalise_manager/task_definitions/base_spec.rb
-- spec/lib/lokalise_manager/task_definitions/exporter_spec.rb
-- spec/lib/lokalise_manager/task_definitions/importer_spec.rb
-- spec/lib/lokalise_manager/utils/hash_utils_spec.rb
-- spec/lib/lokalise_manager_spec.rb
-- spec/spec_helper.rb
-- spec/support/file_manager.rb
-- spec/support/spec_addons.rb
-- spec/support/vcr.rb
 homepage: https://github.com/bodrovis/lokalise_manager
 licenses:
 - MIT
@@ -234,18 +224,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.8
+rubygems_version: 3.3.19
 signing_key:
 specification_version: 4
 summary: Lokalise integration for Ruby
-test_files:
-- spec/lib/lokalise_manager/global_config_spec.rb
-- spec/lib/lokalise_manager/task_definitions/base_spec.rb
-- spec/lib/lokalise_manager/task_definitions/exporter_spec.rb
-- spec/lib/lokalise_manager/task_definitions/importer_spec.rb
-- spec/lib/lokalise_manager/utils/hash_utils_spec.rb
-- spec/lib/lokalise_manager_spec.rb
-- spec/spec_helper.rb
-- spec/support/file_manager.rb
-- spec/support/spec_addons.rb
-- spec/support/vcr.rb
+test_files: []

data/spec/lib/lokalise_manager/global_config_spec.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-describe LokaliseManager::GlobalConfig do
-  let(:fake_class) { class_double(described_class) }
-
-  it 'is possible to provide config' do
-    described_class.config do |c|
-      expect(c).to eq(described_class)
-    end
-  end
-
-  it 'is possible to set project_id' do
-    allow(fake_class).to receive(:project_id=).with('123.abc')
-    fake_class.project_id = '123.abc'
-  end
-
-  it 'is possible to set raise_on_export_fail' do
-    allow(fake_class).to receive(:raise_on_export_fail=).with(false)
-    fake_class.raise_on_export_fail = false
-  end
-
-  it 'is possible to set silent_mode' do
-    allow(fake_class).to receive(:silent_mode=).with(true)
-    fake_class.silent_mode = true
-  end
-
-  it 'is possible to set use_oauth2_token' do
-    allow(fake_class).to receive(:use_oauth2_token=).with(true)
-    fake_class.use_oauth2_token = true
-  end
-
-  it 'is possible to set file_ext_regexp' do
-    allow(fake_class).to receive(:file_ext_regexp=).with(Regexp.new('.*'))
-    fake_class.file_ext_regexp = Regexp.new('.*')
-  end
-
-  it 'is possible to set import_opts' do
-    allow(fake_class).to receive(:import_opts=).with(duck_type(:each))
-    fake_class.import_opts = {
-      format: 'json',
-      indentation: '8sp'
-    }
-  end
-
-  it 'is possible to set export_opts' do
-    allow(fake_class).to receive(:export_opts=).with(duck_type(:each))
-    fake_class.export_opts = {
-      convert_placeholders: true,
-      detect_icu_plurals: true
-    }
-  end
-
-  it 'is possible to set branch' do
-    allow(fake_class).to receive(:branch=).with('custom')
-    fake_class.branch = 'custom'
-  end
-
-  it 'is possible to set timeouts' do
-    allow(fake_class).to receive(:timeouts=).with(duck_type(:each))
-    fake_class.timeouts = {
-      open_timeout: 100,
-      timeout: 500
-    }
-  end
-
-  it 'is possible to set import_safe_mode' do
-    allow(fake_class).to receive(:import_safe_mode=).with(true)
-    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'
-  end
-
-  it 'is possible to override locales_path' do
-    allow(fake_class).to receive(:locales_path=).with('/demo/path')
-    fake_class.locales_path = '/demo/path'
-  end
-
-  it 'is possible to set skip_file_export' do
-    cond = ->(f) { f.nil? }
-    allow(fake_class).to receive(:skip_file_export=).with(cond)
-    fake_class.skip_file_export = cond
-  end
-
-  it 'is possible to set translations_loader' do
-    runner = ->(f) { f.to_json }
-    allow(fake_class).to receive(:translations_loader=).with(runner)
-    fake_class.translations_loader = runner
-  end
-
-  it 'is possible to set translations_converter' do
-    runner = ->(f) { f.to_json }
-    allow(fake_class).to receive(:translations_converter=).with(runner)
-    fake_class.translations_converter = runner
-  end
-
-  it 'is possible to set lang_iso_inferer' do
-    runner = ->(f) { f.to_json }
-    allow(fake_class).to receive(:lang_iso_inferer=).with(runner)
-    fake_class.lang_iso_inferer = runner
-  end
-end

data/spec/lib/lokalise_manager/task_definitions/base_spec.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-describe LokaliseManager::TaskDefinitions::Base do
-  let(:described_object) { described_class.new }
-
-  describe '.new' do
-    it 'allows to override config' do
-      obj = described_class.new token: 'fake'
-      expect(obj.config.token).to eq('fake')
-    end
-  end
-
-  describe '#config' do
-    it 'allows to update config after initialization' do
-      obj = described_class.new token: 'fake', project_id: '123'
-
-      obj.config.project_id = '345'
-
-      expect(obj.config.project_id).to eq('345')
-      expect(obj.config.token).to eq('fake')
-    end
-  end
-
-  specify '.reset_client!' do
-    expect(described_object.api_client).to be_an_instance_of(RubyLokaliseApi::Client)
-    described_object.reset_api_client!
-    current_client = described_object.instance_variable_get :@api_client
-    expect(current_client).to be_nil
-  end
-
-  specify '.project_id_with_branch!' do
-    result = described_object.send :project_id_with_branch
-    expect(result).to be_an_instance_of(String)
-    expect(result).not_to include(':master')
-
-    described_object.config.branch = 'develop'
-    result = described_object.send :project_id_with_branch
-    expect(result).to be_an_instance_of(String)
-    expect(result).to include(':develop')
-  end
-
-  describe '.subdir_and_filename_for' do
-    it 'works properly for longer paths' do
-      path = 'my_path/is/here/file.yml'
-      result = described_object.send(:subdir_and_filename_for, path)
-      expect(result.length).to eq(2)
-      expect(result[0]).to be_an_instance_of(Pathname)
-      expect(result[0].to_s).to eq('my_path/is/here')
-      expect(result[1].to_s).to eq('file.yml')
-    end
-
-    it 'works properly for shorter paths' do
-      path = 'file.yml'
-      result = described_object.send(:subdir_and_filename_for, path)
-      expect(result.length).to eq(2)
-      expect(result[1]).to be_an_instance_of(Pathname)
-      expect(result[0].to_s).to eq('.')
-      expect(result[1].to_s).to eq('file.yml')
-    end
-  end
-
-  describe '.check_options_errors!' do
-    it 'raises an error when the API key is not set' do
-      allow(LokaliseManager::GlobalConfig).to receive(:api_token).and_return(nil)
-
-      expect do
-        described_object.send(:check_options_errors!)
-      end.to raise_error(LokaliseManager::Error, /API token is not set/i)
-
-      expect(LokaliseManager::GlobalConfig).to have_received(:api_token)
-    end
-
-    it 'returns an error when the project_id is not set' do
-      allow_project_id described_object, nil do
-        expect do
-          described_object.send(:check_options_errors!)
-        end.to raise_error(LokaliseManager::Error, /ID is not set/i)
-      end
-    end
-  end
-
-  describe '.proper_ext?' do
-    it 'works properly with path represented as a string' do
-      path = 'my_path/here/file.yml'
-      expect(described_object.send(:proper_ext?, path)).to be true
-    end
-
-    it 'works properly with path represented as a pathname' do
-      path = Pathname.new 'my_path/here/file.json'
-      expect(described_object.send(:proper_ext?, path)).to be false
-    end
-  end
-
-  describe '.api_client' do
-    it 'is possible to set timeouts' do
-      allow(described_object.config).to receive(:timeouts).and_return({
-                                                                        open_timeout: 100,
-                                                                        timeout: 500
-                                                                      })
-
-      client = described_object.api_client
-      expect(client).to be_an_instance_of(RubyLokaliseApi::Client)
-      expect(client).not_to be_an_instance_of(RubyLokaliseApi::OAuth2Client)
-      expect(client.open_timeout).to eq(100)
-      expect(client.timeout).to eq(500)
-    end
-
-    it 'uses .oauth_client when the use_oauth2_token is true' do
-      allow(described_object.config).to receive(:use_oauth2_token).and_return(true)
-
-      client = described_object.api_client
-
-      expect(client).to be_an_instance_of(RubyLokaliseApi::OAuth2Client)
-      expect(client).not_to be_an_instance_of(RubyLokaliseApi::Client)
-    end
-  end
-end

data/spec/lib/lokalise_manager/task_definitions/exporter_spec.rb

@@ -1,273 +0,0 @@
-# frozen_string_literal: true
-
-require 'base64'
-
-describe LokaliseManager::TaskDefinitions::Exporter do
-  let(:filename) { 'en.yml' }
-  let(:path) { "#{Dir.getwd}/locales/nested/#{filename}" }
-  let(:relative_name) { "nested/#{filename}" }
-  let(:project_id) { ENV['LOKALISE_PROJECT_ID'] }
-  let(:described_object) do
-    described_class.new project_id: project_id,
-                        api_token: ENV['LOKALISE_API_TOKEN'],
-                        max_retries_export: 2
-  end
-
-  context 'with many translation files' do
-    describe '.export!' do
-      context 'with no errors' do
-        before do
-          add_translation_files! with_ru: true, additional: 5
-        end
-
-        after do
-          rm_translation_files
-        end
-
-        it 'sends a proper API request and handles rate limiting' do
-          process = nil
-
-          VCR.use_cassette('upload_files_multiple') do
-            expect { process = described_object.export!.first.process }.to output(/complete!/).to_stdout
-          end
-
-          expect(process.project_id).to eq(project_id)
-          expect(process.status).to eq('queued')
-        end
-
-        it 'handles too many requests but does not re-raise anything when raise_on_export_fail is false' do
-          allow(described_object.config).to receive(:max_retries_export).and_return(1)
-          allow(described_object.config).to receive(:raise_on_export_fail).and_return(false)
-          allow(described_object).to receive(:sleep).and_return(0)
-
-          fake_client = instance_double('RubyLokaliseApi::Client')
-          allow(fake_client).to receive(:token).with(any_args).and_return('fake_token')
-          allow(fake_client).to receive(:upload_file).with(any_args).and_raise(RubyLokaliseApi::Error::TooManyRequests)
-          allow(described_object).to receive(:api_client).and_return(fake_client)
-          processes = []
-          expect { processes = described_object.export! }.not_to raise_error
-
-          expect(processes[0].success).to be false
-          expect(processes[1].error.class).to eq(RubyLokaliseApi::Error::TooManyRequests)
-          expect(processes.count).to eq(7)
-
-          expect(described_object).to have_received(:sleep).exactly(7).times
-          expect(described_object).to have_received(:api_client).at_least(14).times
-          expect(fake_client).to have_received(:upload_file).exactly(14).times
-        end
-      end
-
-      context 'with errors' do
-        before do
-          add_translation_files! with_ru: true
-        end
-
-        after do
-          rm_translation_files
-        end
-
-        it 'handles too many requests' do
-          allow(described_object.config).to receive(:max_retries_export).and_return(1)
-          allow(described_object).to receive(:sleep).and_return(0)
-
-          fake_client = instance_double('RubyLokaliseApi::Client')
-          allow(fake_client).to receive(:token).with(any_args).and_return('fake_token')
-          allow(fake_client).to receive(:upload_file).with(any_args).and_raise(RubyLokaliseApi::Error::TooManyRequests)
-          allow(described_object).to receive(:api_client).and_return(fake_client)
-
-          expect do
-            described_object.export!
-          end.to raise_error(RubyLokaliseApi::Error::TooManyRequests, /Gave up after 1 retries/i)
-
-          expect(described_object).to have_received(:sleep).exactly(2).times
-          expect(described_object).to have_received(:api_client).at_least(4).times
-          expect(fake_client).to have_received(:upload_file).exactly(4).times
-        end
-      end
-    end
-  end
-
-  context 'with one translation file' do
-    context 'without files' do
-      it 'halts when the API key is not set' do
-        allow(described_object.config).to receive(:api_token).and_return(nil)
-
-        expect { described_object.export! }.to raise_error(LokaliseManager::Error, /API token is not set/i)
-        expect(described_object.config).to have_received(:api_token)
-      end
-
-      it 'halts when the project_id is not set' do
-        allow_project_id described_object, nil do
-          expect { described_object.export! }.to raise_error(LokaliseManager::Error, /ID is not set/i)
-        end
-      end
-    end
-
-    context 'with files' do
-      before do
-        add_translation_files!
-      end
-
-      after do
-        rm_translation_files
-      end
-
-      describe '.export!' do
-        it 'sends a proper API request but does not output anything when silent_mode is enabled' do
-          allow(described_object.config).to receive(:silent_mode).and_return(true)
-
-          process = nil
-
-          VCR.use_cassette('upload_files') do
-            expect { process = described_object.export!.first.process }.not_to output(/complete!/).to_stdout
-          end
-
-          expect(process.status).to eq('queued')
-          expect(described_object.config).to have_received(:silent_mode).at_most(1).times
-        end
-
-        it 'sends a proper API request' do
-          process = VCR.use_cassette('upload_files') do
-            described_object.export!
-          end.first.process
-
-          expect(process.project_id).to eq(project_id)
-          expect(process.status).to eq('queued')
-        end
-
-        it 'sends a proper API request when a different branch is provided' do
-          allow(described_object.config).to receive(:branch).and_return('develop')
-
-          process_data = VCR.use_cassette('upload_files_branch') do
-            described_object.export!
-          end.first
-
-          expect(described_object.config).to have_received(:branch).at_most(2).times
-          expect(process_data.success).to be true
-          expect(process_data.path.to_s).to include('en.yml')
-
-          process = process_data.process
-          expect(process).to be_an_instance_of(RubyLokaliseApi::Resources::QueuedProcess)
-          expect(process.project_id).to eq(project_id)
-          expect(process.status).to eq('queued')
-        end
-      end
-    end
-
-    describe '#all_files' do
-      before do
-        add_translation_files!
-      end
-
-      after do
-        rm_translation_files
-      end
-
-      it 'yield proper arguments' do
-        expect(described_object.send(:all_files).flatten).to include(
-          Pathname.new(path),
-          Pathname.new(relative_name)
-        )
-      end
-    end
-
-    describe '.opts' do
-      before do
-        add_translation_files!
-      end
-
-      after do
-        rm_translation_files
-      end
-
-      let(:base64content) { Base64.strict_encode64(File.read(path).strip) }
-
-      it 'generates proper options' do
-        resulting_opts = described_object.send(:opts, path, relative_name)
-
-        expect(resulting_opts[:data]).to eq(base64content)
-        expect(resulting_opts[:filename]).to eq(relative_name)
-        expect(resulting_opts[:lang_iso]).to eq('en')
-      end
-
-      it 'allows to redefine options' do
-        allow(described_object.config).to receive(:export_opts).and_return({
-                                                                             detect_icu_plurals: true,
-                                                                             convert_placeholders: true
-                                                                           })
-
-        resulting_opts = described_object.send(:opts, path, relative_name)
-
-        expect(described_object.config).to have_received(:export_opts)
-        expect(resulting_opts[:data]).to eq(base64content)
-        expect(resulting_opts[:filename]).to eq(relative_name)
-        expect(resulting_opts[:lang_iso]).to eq('en')
-        expect(resulting_opts[:detect_icu_plurals]).to be true
-        expect(resulting_opts[:convert_placeholders]).to be true
-      end
-    end
-  end
-
-  context 'with two translation files' do
-    let(:filename_ru) { 'ru.yml' }
-    let(:path_ru) { "#{Dir.getwd}/locales/#{filename_ru}" }
-
-    before do
-      add_translation_files! with_ru: true
-    end
-
-    after do
-      rm_translation_files
-    end
-
-    describe '.export!' do
-      it 're-raises export errors' do
-        allow_project_id described_object, '542886116159f798720dc4.94769464'
-
-        VCR.use_cassette('upload_files_error') do
-          expect { described_object.export! }.to raise_error(RubyLokaliseApi::Error::BadRequest, /Unknown `lang_iso`/)
-        end
-      end
-    end
-
-    describe '.opts' do
-      let(:base64content_ru) { Base64.strict_encode64(File.read(path_ru).strip) }
-
-      it 'generates proper options' do
-        resulting_opts = described_object.send(:opts, path_ru, filename_ru)
-
-        expect(resulting_opts[:data]).to eq(base64content_ru)
-        expect(resulting_opts[:filename]).to eq(filename_ru)
-        expect(resulting_opts[:lang_iso]).to eq('ru_RU')
-      end
-    end
-
-    describe '#all_files' do
-      it 'returns all files' do
-        files = described_object.send(:all_files).flatten
-        expect(files).to include(
-          Pathname.new(path),
-          Pathname.new(relative_name)
-        )
-        expect(files).to include(
-          Pathname.new(path_ru),
-          Pathname.new(filename_ru)
-        )
-      end
-
-      it 'does not return files that have to be skipped' do
-        allow(described_object.config).to receive(:skip_file_export).twice.and_return(
-          ->(f) { f.split[1].to_s.include?('ru') }
-        )
-        files = described_object.send(:all_files).sort
-        expect(files[0]).to include(
-          Pathname.new(path),
-          Pathname.new(relative_name)
-        )
-        expect(files.count).to eq(1)
-
-        expect(described_object.config).to have_received(:skip_file_export).twice
-      end
-    end
-  end
-end

data/spec/lib/lokalise_manager/task_definitions/importer_spec.rb

@@ -1,195 +0,0 @@
-# frozen_string_literal: true
-
-describe LokaliseManager::TaskDefinitions::Importer do
-  let(:described_object) do
-    described_class.new project_id: project_id,
-                        api_token: ENV['LOKALISE_API_TOKEN'],
-                        max_retries_import: 2
-  end
-  let(:loc_path) { described_object.config.locales_path }
-  let(:project_id) { ENV['LOKALISE_PROJECT_ID'] }
-  let(:local_trans) { "#{Dir.getwd}/spec/fixtures/trans.zip" }
-
-  describe '#open_and_process_zip' do
-    it 're-raises errors during file processing' do
-      entry = double
-      allow(entry).to receive(:name).and_return('fail.yml')
-      allow(described_object).to receive(:data_from).with(entry).and_raise(EncodingError)
-      expect { described_object.send(:process!, entry) }.
-        to raise_error(EncodingError, /Error when trying to process fail\.yml/)
-
-      expect(described_object).to have_received(:data_from)
-    end
-
-    it 're-raises errors during file opening' do
-      expect { described_object.send(:open_and_process_zip, 'http://fake.url/wrong/path.zip') }.
-        to raise_error(SocketError, /Failed to open TCP connection/)
-    end
-  end
-
-  describe '#download_files' do
-    it 'returns a proper download URL' do
-      response = VCR.use_cassette('download_files') do
-        described_object.send :download_files
-      end
-
-      expect(response['project_id']).to eq('672198945b7d72fc048021.15940510')
-      expect(response['bundle_url']).to include('s3-eu-west-1.amazonaws.com')
-    end
-
-    it 're-raises errors during file download' do
-      allow_project_id described_object, 'invalid'
-
-      VCR.use_cassette('download_files_error') do
-        expect { described_object.send :download_files }.
-          to raise_error(RubyLokaliseApi::Error::BadRequest, /Invalid `project_id` parameter/)
-      end
-    end
-  end
-
-  describe '.import!' do
-    context 'with errors' do
-      it 'handles too many requests' do
-        allow(described_object).to receive(:sleep).and_return(0)
-
-        fake_client = instance_double('RubyLokaliseApi::Client')
-        allow(fake_client).to receive(:download_files).and_raise(RubyLokaliseApi::Error::TooManyRequests)
-        allow(described_object).to receive(:api_client).and_return(fake_client)
-
-        expect { described_object.import! }.to raise_error(RubyLokaliseApi::Error::TooManyRequests, /Gave up after 2 retries/i)
-
-        expect(described_object).to have_received(:sleep).exactly(2).times
-        expect(described_object).to have_received(:api_client).exactly(3).times
-        expect(fake_client).to have_received(:download_files).exactly(3).times
-      end
-
-      it 'halts when the API key is not set' do
-        allow(described_object.config).to receive(:api_token).and_return(nil)
-        expect { described_object.import! }.to raise_error(LokaliseManager::Error, /API token is not set/i)
-        expect(described_object.config).to have_received(:api_token)
-        expect(count_translations).to eq(0)
-      end
-
-      it 'halts when the project_id is not set' do
-        allow_project_id described_object, nil do
-          expect { described_object.import! }.to raise_error(LokaliseManager::Error, /ID is not set/i)
-          expect(count_translations).to eq(0)
-        end
-      end
-    end
-
-    context 'when directory is empty' do
-      before do
-        mkdir_locales
-      end
-
-      after do
-        rm_translation_files
-      end
-
-      it 'runs import successfully for local files' do
-        allow(described_object).to receive(:download_files).and_return(
-          {
-            'project_id' => '123.abc',
-            'bundle_url' => local_trans
-          }
-        )
-
-        expect(described_object.import!).to be true
-
-        expect(count_translations).to eq(4)
-        expect(described_object).to have_received(:download_files)
-        expect_file_exist loc_path, 'en/nested/main_en.yml'
-        expect_file_exist loc_path, 'en/nested/deep/secondary_en.yml'
-        expect_file_exist loc_path, 'ru/main_ru.yml'
-      end
-
-      it 'runs import successfully' do
-        result = nil
-
-        VCR.use_cassette('import') do
-          expect { result = described_object.import! }.to output(/complete!/).to_stdout
-        end
-
-        expect(result).to be true
-
-        expect(count_translations).to eq(24)
-        expect_file_exist loc_path, 'en_1.yml'
-        expect_file_exist loc_path, 'ru_2.yml'
-      end
-
-      it 'runs import successfully but does not provide any output when silent_mode is enabled' do
-        allow(described_object.config).to receive(:silent_mode).and_return(true)
-        result = nil
-
-        VCR.use_cassette('import') do
-          expect { result = described_object.import! }.not_to output(/complete!/).to_stdout
-        end
-
-        expect(result).to be true
-        expect_file_exist loc_path, 'en_1.yml'
-        expect_file_exist loc_path, 'ru_2.yml'
-        expect(described_object.config).to have_received(:silent_mode).at_most(1).times
-      end
-    end
-
-    context 'when directory is not empty and safe mode enabled' do
-      let(:safe_mode_obj) do
-        described_class.new project_id: project_id,
-                            api_token: ENV['LOKALISE_API_TOKEN'],
-                            import_safe_mode: true
-      end
-
-      before do
-        mkdir_locales
-        rm_translation_files
-        add_translation_files!
-      end
-
-      after do
-        rm_translation_files
-      end
-
-      it 'import proceeds when the user agrees' do
-        allow(safe_mode_obj).to receive(:download_files).and_return(
-          {
-            'project_id' => '123.abc',
-            'bundle_url' => local_trans
-          }
-        )
-
-        allow($stdin).to receive(:gets).and_return('Y')
-        expect { safe_mode_obj.import! }.to output(/is not empty/).to_stdout
-
-        expect(count_translations).to eq(5)
-        expect($stdin).to have_received(:gets)
-        expect(safe_mode_obj).to have_received(:download_files)
-        expect_file_exist loc_path, 'en/nested/main_en.yml'
-        expect_file_exist loc_path, 'en/nested/deep/secondary_en.yml'
-        expect_file_exist loc_path, 'ru/main_ru.yml'
-      end
-
-      it 'import halts when a user chooses not to proceed' do
-        allow(safe_mode_obj).to receive(:download_files).at_most(0).times
-        allow($stdin).to receive(:gets).and_return('N')
-        expect { safe_mode_obj.import! }.to output(/cancelled/).to_stdout
-
-        expect(safe_mode_obj).not_to have_received(:download_files)
-        expect($stdin).to have_received(:gets)
-        expect(count_translations).to eq(1)
-      end
-
-      it 'import halts when a user chooses to halt and debug info is not printed out when silent_mode is enabled' do
-        allow(safe_mode_obj.config).to receive(:silent_mode).and_return(true)
-        allow(safe_mode_obj).to receive(:download_files).at_most(0).times
-        allow($stdin).to receive(:gets).and_return('N')
-        expect { safe_mode_obj.import! }.not_to output(/cancelled/).to_stdout
-
-        expect(safe_mode_obj).not_to have_received(:download_files)
-        expect(safe_mode_obj.config).to have_received(:silent_mode)
-        expect($stdin).to have_received(:gets)
-        expect(count_translations).to eq(1)
-      end
-    end
-  end
-end

data/spec/lib/lokalise_manager/utils/hash_utils_spec.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-describe LokaliseManager::Utils::HashUtils do
-  using described_class
-  let(:h1) { {a: 100, b: 200, c: {c1: 100}} }
-  let(:h2) { {b: 250, c: {c1: 200}} }
-
-  specify '#deep_merge' do
-    result = h1.deep_merge(h2) { |_key, this_val, other_val| this_val + other_val }
-    expect(result[:b]).to eq(450)
-    expect(result[:c][:c1]).to eq(300)
-  end
-end

data/spec/lib/lokalise_manager_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-describe LokaliseManager do
-  it 'returns a proper version' do
-    expect(described_class::VERSION).to be_a(String)
-  end
-
-  specify '.importer' do
-    expect(described_class.importer).to be_a(LokaliseManager::TaskDefinitions::Importer)
-  end
-
-  specify '.exporter' do
-    expect(described_class.exporter).to be_a(LokaliseManager::TaskDefinitions::Exporter)
-  end
-end

data/spec/spec_helper.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'dotenv/load'
-require 'simplecov'
-
-SimpleCov.start do
-  add_filter 'spec/'
-  add_filter '.github/'
-end
-
-if ENV['CI'] == 'true'
-  require 'codecov'
-  SimpleCov.formatter = SimpleCov::Formatter::Codecov
-end
-
-require 'lokalise_manager'
-
-# Support files
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].sort.each { |f| require f }
-
-RSpec.configure do |config|
-  config.include FileManager
-  config.include SpecAddons
-end

data/spec/support/file_manager.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require 'fileutils'
-
-module FileManager
-  def mkdir_locales
-    return if File.directory?(LokaliseManager::GlobalConfig.locales_path)
-
-    FileUtils.mkdir_p(LokaliseManager::GlobalConfig.locales_path)
-  end
-
-  def rm_translation_files
-    FileUtils.rm_rf locales_dir
-  end
-
-  def locales_dir
-    Dir["#{LokaliseManager::GlobalConfig.locales_path}/**/*"]
-  end
-
-  def count_translations
-    locales_dir.count { |file| File.file?(file) }
-  end
-
-  def add_translation_files!(with_ru: false, additional: nil)
-    FileUtils.mkdir_p "#{Dir.getwd}/locales/nested"
-    open_and_write('locales/nested/en.yml') { |f| f.write en_data }
-
-    return unless with_ru
-
-    open_and_write('locales/ru.yml') { |f| f.write ru_data }
-
-    return unless additional
-
-    additional.times do |i|
-      data = {'en' => {"key_#{i}" => "value #{i}"}}
-
-      open_and_write("locales/en_#{i}.yml") { |f| f.write data.to_yaml }
-    end
-  end
-
-  def open_and_write(rel_path, &block)
-    return unless block
-
-    File.open("#{Dir.getwd}/#{rel_path}", 'w+:UTF-8', &block)
-  end
-
-  private
-
-  def en_data
-    <<~DATA
-      en:
-        my_key: "My value"
-        nested:
-          key: "Value 2"
-    DATA
-  end
-
-  def ru_data
-    <<~DATA
-      ru_RU:
-        my_key: "Моё значение"
-        nested:
-          key: "Значение 2"
-    DATA
-  end
-end

data/spec/support/spec_addons.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module SpecAddons
-  def allow_project_id(obj, value)
-    allow(obj.config).to receive(:project_id).and_return(value)
-    return unless block_given?
-
-    yield
-    expect(obj.config).to have_received(:project_id)
-  end
-
-  def expect_file_exist(path, file)
-    file_path = File.join path, file
-    expect(File.file?(file_path)).to be true
-  end
-end

data/spec/support/vcr.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require 'vcr'
-
-VCR.configure do |c|
-  c.ignore_hosts 'codeclimate.com'
-  c.hook_into :faraday
-  c.cassette_library_dir = File.join(File.dirname(__FILE__), '..', 'fixtures', 'vcr_cassettes')
-  c.filter_sensitive_data('<LOKALISE_TOKEN>') do |_i|
-    ENV.fetch('LOKALISE_API_TOKEN')
-  end
-  c.configure_rspec_metadata!
-end