lokalise_rails 2.0.0 → 5.0.0

data/lib/lokalise_rails/task_definition/base.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require 'ruby-lokalise-api'
-require 'pathname'
-
-module LokaliseRails
-  module TaskDefinition
-    class Base
-      class << self
-        attr_writer :api_client
-
-        # Creates a Lokalise API client
-        #
-        # @return [Lokalise::Client]
-        def api_client
-          @api_client ||= ::Lokalise.client LokaliseRails.api_token, {enable_compression: true}.merge(LokaliseRails.timeouts)
-        end
-
-        # Resets API client
-        def reset_api_client!
-          Lokalise.reset_client!
-          @api_client = nil
-        end
-
-        # Checks task options
-        #
-        # @return Array
-        def check_options_errors!
-          errors = []
-          errors << 'Project ID is not set!' if LokaliseRails.project_id.nil? || LokaliseRails.project_id.empty?
-          errors << 'Lokalise API token is not set!' if LokaliseRails.api_token.nil? || LokaliseRails.api_token.empty?
-
-          raise(LokaliseRails::Error, errors.join(' ')) if errors.any?
-        end
-
-        private
-
-        # Checks whether the provided file has a proper extension as dictated by the `file_ext_regexp` option
-        #
-        # @return Boolean
-        # @param raw_path [String, Pathname]
-        def proper_ext?(raw_path)
-          path = raw_path.is_a?(Pathname) ? raw_path : Pathname.new(raw_path)
-          LokaliseRails.file_ext_regexp.match? path.extname
-        end
-
-        # Returns directory and filename for the given entry
-        #
-        # @return Array
-        # @param entry [String]
-        def subdir_and_filename_for(entry)
-          Pathname.new(entry).split
-        end
-
-        # Returns Lokalise project ID and branch, semicolumn separated
-        #
-        # @return [String]
-        def project_id_with_branch
-          "#{LokaliseRails.project_id}:#{LokaliseRails.branch}"
-        end
-
-        # Sends request with exponential backoff mechanism
-        def with_exp_backoff(max_retries)
-          return unless block_given?
-
-          retries = 0
-          begin
-            yield
-          rescue Lokalise::Error::TooManyRequests => e
-            raise(e.class, "Gave up after #{retries} retries") if retries >= max_retries
-
-            sleep 2**retries
-            retries += 1
-            retry
-          end
-        end
-      end
-    end
-  end
-end

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/dummy/config/initializers/application_controller_renderer.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-# Be sure to restart your server when you modify this file.
-
-# ActiveSupport::Reloader.to_prepare do
-#   ApplicationController.renderer.defaults.merge!(
-#     http_host: 'example.org',
-#     https: false
-#   )
-# end

data/spec/dummy/config/initializers/backtrace_silencers.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-# Be sure to restart your server when you modify this file.
-
-# You can add backtrace silencers for libraries that you're using but don't wish to see in your backtraces.
-# Rails.backtrace_cleaner.add_silencer { |line| line =~ /my_noisy_library/ }
-
-# You can also remove all the silencers if you're trying to debug a problem that might stem from framework code.
-# Rails.backtrace_cleaner.remove_silencers!

data/spec/dummy/config/initializers/content_security_policy.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-# Be sure to restart your server when you modify this file.
-
-# Define an application-wide content security policy
-# For further information see the following documentation
-# https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy
-
-# Rails.application.config.content_security_policy do |policy|
-#   policy.default_src :self, :https
-#   policy.font_src    :self, :https, :data
-#   policy.img_src     :self, :https, :data
-#   policy.object_src  :none
-#   policy.script_src  :self, :https
-#   policy.style_src   :self, :https
-
-#   # Specify URI for violation reports
-#   # policy.report_uri "/csp-violation-report-endpoint"
-# end
-
-# If you are using UJS then enable automatic nonce generation
-# Rails.application.config.content_security_policy_nonce_generator = -> request { SecureRandom.base64(16) }
-
-# Set the nonce only to specific directives
-# Rails.application.config.content_security_policy_nonce_directives = %w(script-src)
-
-# Report CSP violations to a specified URI
-# For further information see the following documentation:
-# https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy-Report-Only
-# Rails.application.config.content_security_policy_report_only = true

data/spec/dummy/config/initializers/inflections.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-# Be sure to restart your server when you modify this file.
-
-# Add new inflection rules using the following format. Inflections
-# are locale specific, and you may define rules for as many different
-# locales as you wish. All of these examples are active by default:
-# ActiveSupport::Inflector.inflections(:en) do |inflect|
-#   inflect.plural /^(ox)$/i, '\1en'
-#   inflect.singular /^(ox)en/i, '\1'
-#   inflect.irregular 'person', 'people'
-#   inflect.uncountable %w( fish sheep )
-# end
-
-# These inflection rules are supported but not enabled by default:
-# ActiveSupport::Inflector.inflections(:en) do |inflect|
-#   inflect.acronym 'RESTful'
-# end

data/spec/dummy/config/initializers/mime_types.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-# Be sure to restart your server when you modify this file.
-
-# Add new mime types for use in respond_to blocks:
-# Mime::Type.register "text/richtext", :rtf

data/spec/dummy/config/initializers/wrap_parameters.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-# Be sure to restart your server when you modify this file.
-
-# This file contains settings for ActionController::ParamsWrapper which
-# is enabled by default.
-
-# Enable parameter wrapping for JSON. You can disable this by setting :format to an empty array.
-ActiveSupport.on_load(:action_controller) do
-  wrap_parameters format: [:json]
-end
-
-# To enable root element in JSON for ActiveRecord objects.
-# ActiveSupport.on_load(:active_record) do
-#   self.include_root_in_json = true
-# 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