lokalise_rails 2.0.0 → 3.0.0

data/lib/lokalise_rails/task_definition/exporter.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require 'base64'
-
-module LokaliseRails
-  module TaskDefinition
-    class Exporter < Base
-      class << self
-        # Performs translation file export from Rails to Lokalise and returns an array of queued processes
-        #
-        # @return [Array]
-        def export!
-          check_options_errors!
-
-          queued_processes = []
-          each_file do |full_path, relative_path|
-            queued_processes << do_upload(full_path, relative_path)
-          rescue StandardError => e
-            raise e.class, "Error while trying to upload #{full_path}: #{e.message}"
-          end
-
-          $stdout.print 'Task complete!'
-
-          queued_processes
-        end
-
-        # Performs the actual file uploading to Lokalise. If the API rate limit is exceeed,
-        # applies exponential backoff
-        def do_upload(f_path, r_path)
-          with_exp_backoff(LokaliseRails.max_retries_export) do
-            api_client.upload_file project_id_with_branch, opts(f_path, r_path)
-          end
-        end
-
-        # Processes each translation file in the specified directory
-        def each_file
-          return unless block_given?
-
-          loc_path = LokaliseRails.locales_path
-          Dir["#{loc_path}/**/*"].sort.each do |f|
-            full_path = Pathname.new f
-
-            next unless file_matches_criteria? full_path
-
-            relative_path = full_path.relative_path_from Pathname.new(loc_path)
-
-            yield full_path, relative_path
-          end
-        end
-
-        # Generates export options
-        #
-        # @return [Hash]
-        # @param full_p [Pathname]
-        # @param relative_p [Pathname]
-        def opts(full_p, relative_p)
-          content = File.read full_p
-
-          initial_opts = {
-            data: Base64.strict_encode64(content.strip),
-            filename: relative_p,
-            lang_iso: LokaliseRails.lang_iso_inferer.call(content)
-          }
-
-          initial_opts.merge LokaliseRails.export_opts
-        end
-
-        # Checks whether the specified file has to be processed or not
-        #
-        # @return [Boolean]
-        # @param full_path [Pathname]
-        def file_matches_criteria?(full_path)
-          full_path.file? && proper_ext?(full_path) &&
-            !LokaliseRails.skip_file_export.call(full_path)
-        end
-      end
-    end
-  end
-end

data/lib/lokalise_rails/task_definition/importer.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-require 'zip'
-require 'yaml'
-require 'open-uri'
-require 'fileutils'
-
-module LokaliseRails
-  module TaskDefinition
-    class Importer < Base
-      class << self
-        # Performs translation files import from Lokalise to Rails app
-        #
-        # @return [Boolean]
-        def import!
-          check_options_errors!
-
-          unless proceed_when_safe_mode?
-            $stdout.print 'Task cancelled!'
-            return false
-          end
-
-          open_and_process_zip download_files['bundle_url']
-
-          $stdout.print 'Task complete!'
-          true
-        end
-
-        # Downloads files from Lokalise using the specified options.
-        # Utilizes exponential backoff if "too many requests" error is received
-        #
-        # @return [Hash]
-        def download_files
-          with_exp_backoff(LokaliseRails.max_retries_import) do
-            api_client.download_files project_id_with_branch, LokaliseRails.import_opts
-          end
-        rescue StandardError => e
-          raise e.class, "There was an error when trying to download files: #{e.message}"
-        end
-
-        # Opens ZIP archive (local or remote) with translations and processes its entries
-        #
-        # @param path [String]
-        def open_and_process_zip(path)
-          Zip::File.open_buffer(open_file_or_remote(path)) do |zip|
-            fetch_zip_entries(zip) { |entry| process!(entry) }
-          end
-        rescue StandardError => e
-          raise e.class, "There was an error when trying to process the downloaded files: #{e.message}"
-        end
-
-        # Iterates over ZIP entries. Each entry may be a file or folder.
-        def fetch_zip_entries(zip)
-          return unless block_given?
-
-          zip.each do |entry|
-            next unless proper_ext? entry.name
-
-            yield entry
-          end
-        end
-
-        # Processes ZIP entry by reading its contents and creating the corresponding translation file
-        def process!(zip_entry)
-          data = data_from zip_entry
-          subdir, filename = subdir_and_filename_for zip_entry.name
-          full_path = "#{LokaliseRails.locales_path}/#{subdir}"
-          FileUtils.mkdir_p full_path
-
-          File.open(File.join(full_path, filename), 'w+:UTF-8') do |f|
-            f.write LokaliseRails.translations_converter.call(data)
-          end
-        rescue StandardError => e
-          raise e.class, "Error when trying to process #{zip_entry&.name}: #{e.message}"
-        end
-
-        # Checks whether the user wishes to proceed when safe mode is enabled and the target directory is not empty
-        #
-        # @return [Boolean]
-        def proceed_when_safe_mode?
-          return true unless LokaliseRails.import_safe_mode && !Dir.empty?(LokaliseRails.locales_path.to_s)
-
-          $stdout.puts "The target directory #{LokaliseRails.locales_path} is not empty!"
-          $stdout.print 'Enter Y to continue: '
-          answer = $stdin.gets
-          answer.to_s.strip == 'Y'
-        end
-
-        # Opens a local file or a remote URL using the provided patf
-        #
-        # @return [String]
-        def open_file_or_remote(path)
-          parsed_path = URI.parse(path)
-          if parsed_path&.scheme&.include?('http')
-            parsed_path.open
-          else
-            File.open path
-          end
-        end
-
-        private
-
-        def data_from(zip_entry)
-          LokaliseRails.translations_loader.call zip_entry.get_input_stream.read
-        end
-      end
-    end
-  end
-end

data/spec/lib/lokalise_rails/task_definition/base_spec.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-describe LokaliseRails::TaskDefinition::Base do
-  specify '.reset_client!' do
-    expect(described_class.api_client).to be_an_instance_of(Lokalise::Client)
-    described_class.reset_api_client!
-    current_client = described_class.instance_variable_get '@api_client'
-    expect(current_client).to be_nil
-  end
-
-  specify '.project_id_with_branch!' do
-    result = described_class.send :project_id_with_branch
-    expect(result).to be_an_instance_of(String)
-    expect(result).to include(':master')
-  end
-
-  describe '.subdir_and_filename_for' do
-    it 'works properly for longer paths' do
-      path = 'my_path/is/here/file.yml'
-      result = described_class.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_class.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(LokaliseRails).to receive(:api_token).and_return(nil)
-
-      expect(-> { described_class.check_options_errors! }).to raise_error(LokaliseRails::Error, /API token is not set/i)
-
-      expect(LokaliseRails).to have_received(:api_token)
-    end
-
-    it 'returns an error when the project_id is not set' do
-      allow_project_id nil do
-        expect(-> { described_class.check_options_errors! }).to raise_error(LokaliseRails::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_class.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_class.send(:proper_ext?, path)).to be false
-    end
-  end
-
-  describe '.api_client' do
-    before(:all) { described_class.reset_api_client! }
-
-    after(:all) { described_class.reset_api_client! }
-
-    it 'is possible to set timeouts' do
-      allow(LokaliseRails).to receive(:timeouts).and_return({
-                                                              open_timeout: 100,
-                                                              timeout: 500
-                                                            })
-
-      expect(described_class.api_client).to be_an_instance_of(Lokalise::Client)
-      expect(described_class.api_client.open_timeout).to eq(100)
-      expect(described_class.api_client.timeout).to eq(500)
-    end
-  end
-end

data/spec/lib/lokalise_rails/task_definition/exporter_spec.rb

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-
-require 'base64'
-
-describe LokaliseRails::TaskDefinition::Exporter do
-  let(:filename) { 'en.yml' }
-  let(:path) { "#{Rails.root}/config/locales/nested/#{filename}" }
-  let(:relative_name) { "nested/#{filename}" }
-
-  context 'with many translation files' do
-    let(:fake_class) { described_class }
-
-    before :all do
-      add_translation_files! with_ru: true, additional: 5
-    end
-
-    after :all do
-      rm_translation_files
-    end
-
-    describe '.export!' do
-      it 'sends a proper API request and handles rate limiting' do
-        allow_project_id '672198945b7d72fc048021.15940510'
-
-        process = VCR.use_cassette('upload_files_multiple') do
-          described_class.export!
-        end.first
-
-        expect(process.project_id).to eq(LokaliseRails.project_id)
-        expect(process.status).to eq('queued')
-      end
-
-      it 'handles too many requests' do
-        allow_project_id '672198945b7d72fc048021.15940510'
-        allow(LokaliseRails).to receive(:max_retries_export).and_return(2)
-
-        fake_client = double
-        allow(fake_client).to receive(:upload_file).and_raise(Lokalise::Error::TooManyRequests)
-        allow(fake_class).to receive(:api_client).and_return(fake_client)
-
-        expect(-> { fake_class.export! }).to raise_error(Lokalise::Error::TooManyRequests, /Gave up after 2 retries/i)
-        expect(LokaliseRails).to have_received(:max_retries_export).exactly(1).times
-        expect(fake_class).to have_received(:api_client).exactly(3).times
-        expect(fake_client).to have_received(:upload_file).exactly(3).times
-      end
-    end
-  end
-
-  context 'with one translation file' do
-    before :all do
-      add_translation_files!
-    end
-
-    after :all do
-      rm_translation_files
-    end
-
-    describe '.export!' do
-      it 'sends a proper API request' do
-        allow_project_id
-
-        process = VCR.use_cassette('upload_files') do
-          described_class.export!
-        end.first
-
-        expect(process.project_id).to eq(LokaliseRails.project_id)
-        expect(process.status).to eq('queued')
-        expect(LokaliseRails.max_retries_export).to eq(5)
-      end
-
-      it 'sends a proper API request when a different branch is provided' do
-        allow_project_id
-        allow(LokaliseRails).to receive(:branch).and_return('develop')
-
-        process = VCR.use_cassette('upload_files_branch') do
-          described_class.export!
-        end.first
-
-        expect(LokaliseRails).to have_received(:branch)
-        expect(process.project_id).to eq(LokaliseRails.project_id)
-        expect(process.status).to eq('queued')
-      end
-
-      it 'halts when the API key is not set' do
-        allow(LokaliseRails).to receive(:api_token).and_return(nil)
-
-        expect(-> { described_class.export! }).to raise_error(LokaliseRails::Error, /API token is not set/i)
-        expect(LokaliseRails).to have_received(:api_token)
-      end
-
-      it 'halts when the project_id is not set' do
-        allow_project_id nil do
-          expect(-> { described_class.export! }).to raise_error(LokaliseRails::Error, /ID is not set/i)
-        end
-      end
-    end
-
-    describe '.each_file' do
-      it 'yield proper arguments' do
-        expect { |b| described_class.each_file(&b) }.to yield_with_args(
-          Pathname.new(path),
-          Pathname.new(relative_name)
-        )
-      end
-    end
-
-    describe '.opts' do
-      let(:base64content) { Base64.strict_encode64(File.read(path).strip) }
-
-      it 'generates proper options' do
-        resulting_opts = described_class.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(LokaliseRails).to receive(:export_opts).and_return({
-                                                                   detect_icu_plurals: true,
-                                                                   convert_placeholders: true
-                                                                 })
-
-        resulting_opts = described_class.opts(path, relative_name)
-
-        expect(LokaliseRails).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) { "#{Rails.root}/config/locales/#{filename_ru}" }
-    let(:relative_name_ru) { filename_ru }
-
-    before :all do
-      add_translation_files! with_ru: true
-    end
-
-    after :all do
-      rm_translation_files
-    end
-
-    describe '.export!' do
-      it 're-raises export errors' do
-        allow_project_id
-
-        VCR.use_cassette('upload_files_error') do
-          expect { described_class.export! }.to raise_error(Lokalise::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_class.opts(path_ru, relative_name_ru)
-
-        expect(resulting_opts[:data]).to eq(base64content_ru)
-        expect(resulting_opts[:filename]).to eq(relative_name_ru)
-        expect(resulting_opts[:lang_iso]).to eq('ru_RU')
-      end
-    end
-
-    describe '.each_file' do
-      it 'yields every translation file' do
-        expect { |b| described_class.each_file(&b) }.to yield_successive_args(
-          [
-            Pathname.new(path),
-            Pathname.new(relative_name)
-          ],
-          [
-            Pathname.new(path_ru),
-            Pathname.new(relative_name_ru)
-          ]
-        )
-      end
-
-      it 'does not yield files that have to be skipped' do
-        allow(LokaliseRails).to receive(:skip_file_export).twice.and_return(
-          ->(f) { f.split[1].to_s.include?('ru') }
-        )
-        expect { |b| described_class.each_file(&b) }.to yield_successive_args(
-          [
-            Pathname.new(path),
-            Pathname.new(relative_name)
-          ]
-        )
-
-        expect(LokaliseRails).to have_received(:skip_file_export).twice
-      end
-    end
-  end
-end

data/spec/lib/lokalise_rails/task_definition/importer_spec.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-describe LokaliseRails::TaskDefinition::Importer do
-  describe '.open_and_process_zip' do
-    let(:faulty_trans) { "#{Rails.root}/public/faulty_trans.zip" }
-
-    it 're-raises errors during file processing' do
-      expect(-> { described_class.open_and_process_zip(faulty_trans) }).
-        to raise_error(Psych::DisallowedClass, /Error when trying to process fail\.yml/)
-    end
-
-    it 're-raises errors during file opening' do
-      expect(-> { described_class.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
-      allow_project_id '672198945b7d72fc048021.15940510' do
-        response = VCR.use_cassette('download_files') do
-          described_class.download_files
-        end
-
-        expect(response['project_id']).to eq('672198945b7d72fc048021.15940510')
-        expect(response['bundle_url']).to include('s3-eu-west-1.amazonaws.com')
-        expect(described_class.api_client.enable_compression).to eq(true)
-        expect(LokaliseRails.max_retries_import).to eq(5)
-      end
-    end
-
-    it 're-raises errors during file download' do
-      allow_project_id 'invalid'
-      VCR.use_cassette('download_files_error') do
-        expect(-> { described_class.download_files }).
-          to raise_error(Lokalise::Error::BadRequest, /Invalid `project_id` parameter/)
-      end
-    end
-  end
-
-  describe '.import!' do
-    let(:fake_class) { described_class }
-
-    it 'handles too many requests' do
-      allow_project_id '672198945b7d72fc048021.15940510'
-      allow(LokaliseRails).to receive(:max_retries_import).and_return(2)
-
-      fake_client = double
-      allow(fake_client).to receive(:download_files).and_raise(Lokalise::Error::TooManyRequests)
-      allow(fake_class).to receive(:api_client).and_return(fake_client)
-
-      expect(-> { fake_class.import! }).to raise_error(Lokalise::Error::TooManyRequests, /Gave up after 2 retries/i)
-      expect(LokaliseRails).to have_received(:max_retries_import).exactly(1).times
-      expect(fake_class).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(LokaliseRails).to receive(:api_token).and_return(nil)
-      expect(-> { described_class.import! }).to raise_error(LokaliseRails::Error, /API token is not set/i)
-      expect(LokaliseRails).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 nil do
-        expect(-> { described_class.import! }).to raise_error(LokaliseRails::Error, /ID is not set/i)
-        expect(count_translations).to eq(0)
-      end
-    end
-  end
-end