lokalise_rails 0.0.2.1 → 1.0.0

data/lib/lokalise_rails/task_definition/importer.rb

@@ -1,42 +1,84 @@
 # frozen_string_literal: true
 
-class LokaliseRails
+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!
-          status_ok, msg = check_required_opts
-          return msg unless status_ok
-          return 'Task cancelled!' unless proceed_when_safe_mode?
+          errors = opt_errors
+
+          if errors.any?
+            errors.each { |e| $stdout.puts e }
+            return false
+          end
+
+          unless proceed_when_safe_mode?
+            $stdout.print 'Task cancelled!'
+            return false
+          end
 
           open_and_process_zip download_files['bundle_url']
 
-          'Task complete!'
+          $stdout.print 'Task complete!'
+          true
         end
 
+        # Downloads files from Lokalise using the specified options
+        #
+        # @return [Hash]
         def download_files
-          client = ::Lokalise.client LokaliseRails.api_token
           opts = LokaliseRails.import_opts
 
-          client.download_files LokaliseRails.project_id, opts
+          api_client.download_files LokaliseRails.project_id, opts
+        rescue StandardError => e
+          $stdout.puts "There was an error when trying to download files: #{e.inspect}"
         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(URI.open(path)) { |zip| process_zip zip }
+          Zip::File.open_buffer(URI.open(path)) do |zip|
+            fetch_zip_entries(zip) { |entry| process!(entry) }
+          end
         end
 
-        def process_zip(zip)
+        # 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 /\.ya?ml/.match?(entry.name)
+            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 = YAML.safe_load zip_entry.get_input_stream.read
+          subdir, filename = subdir_and_filename_for zip_entry.name
+          full_path = "#{LokaliseRails.locales_path}/#{subdir}"
+          FileUtils.mkdir_p full_path
 
-            filename = entry.name.include?('/') ? entry.name.split('/')[1] : entry.name
-            data = YAML.safe_load entry.get_input_stream.read
-            File.open("#{LokaliseRails.locales_path}/#{filename}", 'w+:UTF-8') do |f|
-              f.write(data.to_yaml)
-            end
+          File.open(File.join(full_path, filename), 'w+:UTF-8') do |f|
+            f.write data.to_yaml
           end
+        rescue StandardError => e
+          $stdout.puts "Error when trying to process #{zip_entry&.name}: #{e.inspect}"
         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)
 

data/lib/lokalise_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-class LokaliseRails
-  VERSION = '0.0.2.1'
+module LokaliseRails
+  VERSION = '1.0.0'
 end

data/lib/tasks/lokalise_rails_tasks.rake

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'rake'
+require "#{Rails.root}/config/lokalise_rails"
+
+namespace :lokalise_rails do
+  task :import do
+    LokaliseRails::TaskDefinition::Importer.import!
+  end
+
+  task :export do
+    LokaliseRails::TaskDefinition::Exporter.export!
+  end
+end

data/lokalise_rails.gemspec

@@ -16,6 +16,7 @@ Gem::Specification.new do |spec|
 
   spec.files = Dir['README.md', 'LICENSE',
                    'CHANGELOG.md', 'lib/**/*.rb',
+                   'lib/**/*.rake',
                    'lokalise_rails.gemspec', '.github/*.md',
                    'Gemfile', 'Rakefile']
   spec.test_files       = Dir['spec/**/*.rb']
@@ -39,6 +40,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rubocop-performance', '~> 1.5'
   spec.add_development_dependency 'rubocop-rspec', '~> 1.37'
   spec.add_development_dependency 'simplecov', '~> 0.16'
-  spec.add_development_dependency 'sqlite3', '~> 1.4'
   spec.add_development_dependency 'vcr', '~> 6.0'
 end

data/spec/dummy/config/application.rb

@@ -4,9 +4,9 @@ require_relative 'boot'
 
 require 'rails'
 # Pick the frameworks you want:
-require 'active_model/railtie'
+# require 'active_model/railtie'
 # require "active_job/railtie"
-require 'active_record/railtie'
+# require 'active_record/railtie'
 # require "active_storage/engine"
 require 'action_controller/railtie'
 # require "action_mailer/railtie"
@@ -21,6 +21,8 @@ require 'sprockets/railtie'
 # you've limited to :test, :development, or :production.
 Bundler.require(*Rails.groups)
 
+require 'dotenv/load'
+
 module Dummy
   class Application < Rails::Application
     # Settings in config/environments/* take precedence over those specified here.

data/spec/dummy/config/lokalise_rails.rb

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

data/spec/lib/generators/lokalise_rails/install_generator_spec.rb

@@ -9,7 +9,7 @@ describe LokaliseRails::Generators::InstallGenerator do
 
   after :all do
     remove_config
-    described_class.start
+    add_config!
   end
 
   it 'installs config file properly' do

data/spec/lib/lokalise_rails/exporter_spec.rb

@@ -0,0 +1,144 @@
+# 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 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
+        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')
+      end
+
+      it 'halts when the API key is not set' do
+        expect(LokaliseRails).to receive(:api_token).and_return(nil)
+        expect(described_class).not_to receive(:each_file)
+        expect(-> { described_class.export! }).to output(/API token is not set/).to_stdout
+      end
+
+      it 'halts when the project_id is not set' do
+        expect(LokaliseRails).to receive(:project_id).and_return(nil)
+        expect(described_class).not_to receive(:each_file)
+        expect(-> { described_class.export! }).to output(/Project ID is not set/).to_stdout
+      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
+        expect(LokaliseRails).to receive(:export_opts).and_return({
+                                                                    detect_icu_plurals: true,
+                                                                    convert_placeholders: true
+                                                                  })
+
+        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')
+        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 'rescues from export errors' do
+        processes = VCR.use_cassette('upload_files_error') do
+          described_class.export!
+        end
+
+        expect(processes.length).to eq(1)
+        process = processes.first
+        expect(process.project_id).to eq(LokaliseRails.project_id)
+        expect(process.status).to eq('queued')
+      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
+        expect(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)
+          ]
+        )
+      end
+    end
+  end
+end

data/spec/lib/lokalise_rails/importer_spec.rb

@@ -1,8 +1,18 @@
 # 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 'rescues from errors during file processing' do
+      expect(-> { described_class.open_and_process_zip(faulty_trans) }).
+        to output(/Psych::DisallowedClass/).to_stdout
+    end
+  end
+
   describe '.download_files' do
     it 'returns a proper download URL' do
+      expect(LokaliseRails).to receive(:project_id).and_return('189934715f57a162257d74.88352370')
       response = VCR.use_cassette('download_files') do
         described_class.download_files
       end
@@ -10,20 +20,27 @@ describe LokaliseRails::TaskDefinition::Importer do
       expect(response['project_id']).to eq('189934715f57a162257d74.88352370')
       expect(response['bundle_url']).to include('s3-eu-west-1.amazonaws.com')
     end
+
+    it 'rescues from errors during file download' do
+      allow(LokaliseRails).to receive(:api_token).and_return('incorrect')
+
+      VCR.use_cassette('download_files_error') do
+        expect(-> { described_class.download_files }).
+          to output(/Lokalise::Error::BadRequest/).to_stdout
+      end
+    end
   end
 
   describe '.import!' do
     it 'halts when the API key is not set' do
       expect(LokaliseRails).to receive(:api_token).and_return(nil)
-      result = described_class.import!
-      expect(result).to include('API token is not set')
+      expect(-> {described_class.import!}).to output(/API token is not set/).to_stdout
       expect(count_translations).to eq(0)
     end
 
     it 'halts when the project_id is not set' do
       expect(LokaliseRails).to receive(:project_id).and_return(nil)
-      result = described_class.import!
-      expect(result).to include('Project ID is not set')
+      expect(-> {described_class.import!}).to output(/Project ID is not set/).to_stdout
       expect(count_translations).to eq(0)
     end
   end

data/spec/lib/lokalise_rails_spec.rb

@@ -1,10 +1,16 @@
 # frozen_string_literal: true
 
 describe LokaliseRails do
-  it 'should return a proper version' do
+  it 'returns a proper version' do
     expect(LokaliseRails::VERSION).to be_a(String)
   end
 
+  it 'is possible to provide config options' do
+    described_class.config do |c|
+      expect(c).to eq(described_class)
+    end
+  end
+
   describe 'parameters' do
     let(:fake_class) { class_double('LokaliseRails') }
 
@@ -13,6 +19,11 @@ describe LokaliseRails do
       fake_class.project_id = '123.abc'
     end
 
+    it 'is possible to set file_ext_regexp' do
+      expect(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
       expect(fake_class).to receive(:import_opts=).with(duck_type(:each))
       fake_class.import_opts = {
@@ -21,6 +32,14 @@ describe LokaliseRails do
       }
     end
 
+    it 'is possible to set export_opts' do
+      expect(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 import_safe_mode' do
       expect(fake_class).to receive(:import_safe_mode=).with(true)
       fake_class.import_safe_mode = true
@@ -32,9 +51,14 @@ describe LokaliseRails do
     end
 
     it 'is possible to override locales_path' do
-      expect(fake_class).to receive(:locales_path).and_return('/demo/path')
+      expect(fake_class).to receive(:locales_path=).with('/demo/path')
+      fake_class.locales_path = '/demo/path'
+    end
 
-      expect(fake_class.locales_path).to eq('/demo/path')
+    it 'is possible to set skip_file_export' do
+      cond = ->(f) { f.nil? }
+      expect(fake_class).to receive(:skip_file_export=).with(cond)
+      fake_class.skip_file_export = cond
     end
   end
 end

data/spec/lib/tasks/export_task_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe LokaliseRails do
+  it 'runs export rake task properly' do
+    expect(export_executor).to output(/complete!/).to_stdout
+  end
+end

data/spec/lib/tasks/import_task_spec.rb

@@ -3,6 +3,10 @@
 require 'fileutils'
 
 RSpec.describe LokaliseRails do
+  let(:loc_path) { described_class.locales_path }
+  let(:local_trans) { "#{Rails.root}/public/trans.zip" }
+  let(:remote_trans) { 'https://github.com/bodrovis/lokalise_rails/blob/master/spec/dummy/public/trans.zip?raw=true' }
+
   context 'when directory is empty' do
     before do
       mkdir_locales
@@ -13,13 +17,13 @@ RSpec.describe LokaliseRails do
       rm_translation_files
     end
 
-    it 'is callable' do
+    it 'import rake task is callable' do
       expect(LokaliseRails::TaskDefinition::Importer).to receive(
         :download_files
       ).and_return(
         {
           'project_id' => '123.abc',
-          'bundle_url' => "#{Rails.root}/public/translations.zip"
+          'bundle_url' => local_trans
         }
       )
 
@@ -27,17 +31,18 @@ RSpec.describe LokaliseRails do
 
       expect(count_translations).to eq(4)
 
-      main_en = File.join described_class.locales_path, 'main_en.yml'
-      expect(File.file?(main_en)).to be true
+      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 'downloads ZIP archive properly' do
+    it 'import rake task downloads ZIP archive properly' do
       expect(LokaliseRails::TaskDefinition::Importer).to receive(
         :download_files
       ).and_return(
         {
           'project_id' => '123.abc',
-          'bundle_url' => 'https://github.com/bodrovis/lokalise_rails/blob/master/spec/dummy/public/translations.zip?raw=true'
+          'bundle_url' => remote_trans
         }
       )
 
@@ -45,38 +50,53 @@ RSpec.describe LokaliseRails do
 
       expect(count_translations).to eq(4)
 
-      main_en = File.join described_class.locales_path, 'main_en.yml'
-      expect(File.file?(main_en)).to be true
+      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
   end
 
-  context 'when directory is not empty' do
+  context 'when directory is not empty and safe mode enabled' do
     before :all do
       mkdir_locales
-      rm_translation_files
-      temp_file = File.join described_class.locales_path, 'kill.me'
-      File.open(temp_file, 'w+') { |file| file.write('temp') }
       described_class.import_safe_mode = true
     end
 
+    before do
+      rm_translation_files
+      add_translation_files!
+    end
+
     after :all do
       rm_translation_files
       described_class.import_safe_mode = false
     end
 
-    it 'returns a success message with default settings' do
+    it 'import proceeds when the user agrees' do
       expect(LokaliseRails::TaskDefinition::Importer).to receive(
         :download_files
       ).and_return(
         {
           'project_id' => '123.abc',
-          'bundle_url' => "#{Rails.root}/public/translations.zip"
+          'bundle_url' => local_trans
         }
       )
       expect($stdin).to receive(:gets).and_return('Y')
       expect(import_executor).to output(/is not empty/).to_stdout
 
       expect(count_translations).to eq(5)
+
+      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
+      expect(LokaliseRails::TaskDefinition::Importer).not_to receive(:download_files)
+      expect($stdin).to receive(:gets).and_return('N')
+      expect(import_executor).to output(/is not empty/).to_stdout
+
+      expect(count_translations).to eq(1)
     end
   end
 end