lokalise_rails 0.1.0 → 1.2.0

data/lib/lokalise_rails/task_definition/exporter.rb

@@ -0,0 +1,78 @@
+# 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!
+          errors = opt_errors
+
+          if errors.any?
+            errors.each { |e| $stdout.puts e }
+            return errors
+          end
+
+          queued_processes = []
+          each_file do |full_path, relative_path|
+            queued_processes << api_client.upload_file(
+              project_id_with_branch, opts(full_path, relative_path)
+            )
+          rescue StandardError => e
+            $stdout.puts "Error while trying to upload #{full_path}: #{e.inspect}"
+          end
+
+          $stdout.print 'Task complete!'
+
+          queued_processes
+        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,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 project_id_with_branch, 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(open_file_or_remote(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
 
-            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
+            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
+          $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)
 
@@ -45,6 +87,24 @@ class LokaliseRails
           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

data/lib/lokalise_rails/version.rb

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

data/lib/tasks/lokalise_rails_tasks.rake

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 require 'rake'
-require 'ruby-lokalise-api'
-require 'zip'
-require 'open-uri'
-require 'yaml'
+require "#{Rails.root}/config/lokalise_rails"
 
 namespace :lokalise_rails do
   task :import do
-    msg = LokaliseRails::TaskDefinition::Importer.import!
-    $stdout.print msg
+    LokaliseRails::TaskDefinition::Importer.import!
+  end
+
+  task :export do
+    LokaliseRails::TaskDefinition::Exporter.export!
   end
 end

data/lokalise_rails.gemspec

@@ -35,11 +35,9 @@ Gem::Specification.new do |spec|
   end
   spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'rspec', '~> 3.6'
-  spec.add_development_dependency 'rspec-rails', '~> 4.0'
-  spec.add_development_dependency 'rubocop', '~> 0.60'
+  spec.add_development_dependency 'rubocop', '~> 1.0'
   spec.add_development_dependency 'rubocop-performance', '~> 1.5'
-  spec.add_development_dependency 'rubocop-rspec', '~> 1.37'
+  spec.add_development_dependency 'rubocop-rspec', '~> 2.0.0'
   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/task_definition/base_spec.rb

@@ -0,0 +1,85 @@
+# 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 '.opt_errors' do
+    it 'returns an error when the API key is not set' do
+      allow(LokaliseRails).to receive(:api_token).and_return(nil)
+      errors = described_class.opt_errors
+
+      expect(LokaliseRails).to have_received(:api_token)
+      expect(errors.length).to eq(1)
+      expect(errors.first).to include('API token is not set')
+    end
+
+    it 'returns an error when the project_id is not set' do
+      allow_project_id nil do
+        errors = described_class.opt_errors
+
+        expect(errors.length).to eq(1)
+        expect(errors.first).to include('Project ID is not set')
+      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

@@ -0,0 +1,165 @@
+# 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
+        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')
+      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 output(/API token is not set/).to_stdout
+        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 output(/Project ID is not set/).to_stdout
+        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 'rescues from export errors' do
+        allow_project_id
+
+        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
+        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