├── .gitignore
├── .ruby-gemset
├── .ruby-version
├── .travis.yml
├── Appraisals
├── CHANGELOG.md
├── Gemfile
├── MIT-LICENSE
├── README.md
├── Rakefile
├── app
    ├── assets
    │   ├── images
    │   │   └── lit
    │   │   │   ├── .gitkeep
    │   │   │   └── jquery-te.png
    │   ├── javascripts
    │   │   └── lit
    │   │   │   ├── application.js
    │   │   │   ├── backend
    │   │   │       ├── bootstrap.js.coffee
    │   │   │       ├── bootstrap.min.js
    │   │   │       ├── dashboard.js
    │   │   │       ├── jquery-te-1.4.0.min.js
    │   │   │       ├── localizations.js.coffee
    │   │   │       └── sources.js.coffee
    │   │   │   ├── lit_frontend.js
    │   │   │   └── mousetrap.js
    │   └── stylesheets
    │   │   └── lit
    │   │       ├── application.css
    │   │       ├── backend
    │   │           └── jquery-te-1.4.0.css.scss
    │   │       └── lit_frontend.css
    ├── controllers
    │   └── lit
    │   │   ├── api
    │   │       └── v1
    │   │       │   ├── base_controller.rb
    │   │       │   ├── locales_controller.rb
    │   │       │   ├── localization_keys_controller.rb
    │   │       │   └── localizations_controller.rb
    │   │   ├── application_controller.rb
    │   │   ├── cloud_translations_controller.rb
    │   │   ├── concerns
    │   │       ├── request_info_store.rb
    │   │       └── request_keys_store.rb
    │   │   ├── dashboard_controller.rb
    │   │   ├── incomming_localizations_controller.rb
    │   │   ├── locales_controller.rb
    │   │   ├── localization_keys_controller.rb
    │   │   ├── localizations_controller.rb
    │   │   ├── request_info_store.rb
    │   │   ├── request_keys_store.rb
    │   │   └── sources_controller.rb
    ├── helpers
    │   └── lit
    │   │   ├── application_helper.rb
    │   │   ├── dashboard_helper.rb
    │   │   ├── frontend_helper.rb
    │   │   ├── localization_keys_helper.rb
    │   │   ├── localizations_helper.rb
    │   │   └── sources_helper.rb
    ├── jobs
    │   └── lit
    │   │   └── synchronize_source_job.rb
    ├── models
    │   └── lit
    │   │   ├── base.rb
    │   │   ├── incomming_localization.rb
    │   │   ├── locale.rb
    │   │   ├── localization.rb
    │   │   ├── localization_key.rb
    │   │   ├── localization_version.rb
    │   │   └── source.rb
    ├── queries
    │   └── localization_key_search_query.rb
    ├── services
    │   ├── remote_interactor_service.rb
    │   └── synchronize_source_service.rb
    └── views
    │   ├── kaminari
    │       └── lit
    │       │   ├── _first_page.html.erb
    │       │   ├── _gap.html.erb
    │       │   ├── _last_page.html.erb
    │       │   ├── _next_page.html.erb
    │       │   ├── _page.html.erb
    │       │   ├── _paginator.html.erb
    │       │   └── _prev_page.html.erb
    │   ├── layouts
    │       └── lit
    │       │   ├── _messages.html.erb
    │       │   ├── _navigation.html.erb
    │       │   └── application.html.erb
    │   └── lit
    │       ├── cloud_translations
    │           └── show.js.erb
    │       ├── dashboard
    │           └── index.html.erb
    │       ├── incomming_localizations
    │           ├── accept.js.erb
    │           ├── destroy.js.erb
    │           └── index.html.erb
    │       ├── locales
    │           ├── _hide_link.html.erb
    │           ├── hide.js.erb
    │           └── index.html.erb
    │       ├── localization_keys
    │           ├── _localization_row.html.erb
    │           ├── _localizations_list.html.erb
    │           ├── _sidebar.html.erb
    │           ├── batch_touch.js.erb
    │           ├── change_completed.js.erb
    │           ├── destroy.js.erb
    │           ├── index.html.erb
    │           ├── not_translated.html.erb
    │           ├── restore_deleted.js.erb
    │           ├── star.js.erb
    │           └── visited_again.html.erb
    │       ├── localizations
    │           ├── _form.html.erb
    │           ├── _previous_versions_rows.html.erb
    │           ├── change_completed.js.erb
    │           ├── edit.js.erb
    │           ├── previous_versions.js.erb
    │           └── update.js.erb
    │       └── sources
    │           ├── _form.html.erb
    │           ├── edit.html.erb
    │           ├── index.html.erb
    │           ├── new.html.erb
    │           └── show.html.erb
├── config
    └── routes.rb
├── db
    └── migrate
    │   ├── 20180101010101_lit_create_lit_locales.rb
    │   ├── 20180101010102_lit_create_lit_localization_keys.rb
    │   ├── 20180101010103_lit_create_lit_localizations.rb
    │   ├── 20180101010104_lit_add_is_completed_and_is_starred_to_localization_keys.rb
    │   ├── 20180101010105_lit_add_is_hidden_to_locales.rb
    │   ├── 20180101010106_lit_create_lit_localization_versions.rb
    │   ├── 20180101010107_lit_create_lit_sources.rb
    │   ├── 20180101010108_lit_create_lit_incomming_localizations.rb
    │   ├── 20180101010109_lit_add_sync_complete_to_lit_sources.rb
    │   ├── 20181017123839_lit_add_is_deleted_to_localization_keys.rb
    │   ├── 20181018075955_lit_add_localization_key_is_deleted_to_localization_keys.rb
    │   ├── 20181030111522_lit_add_is_visited_again_to_localization_keys.rb
    │   └── 20181129103819_lit_add_localization_key_locale_unique_index_to_localizations.rb
├── gemfiles
    ├── rails_5.2.gemfile
    ├── rails_5.2.gemfile.lock
    ├── rails_6.0.gemfile
    ├── rails_6.0.gemfile.lock
    ├── rails_6.1.gemfile
    └── rails_6.1.gemfile.lock
├── lib
    ├── generators
    │   └── lit
    │   │   ├── install
    │   │       └── templates
    │   │       │   └── initializer.erb
    │   │   └── install_generator.rb
    ├── lit.rb
    ├── lit
    │   ├── adapters.rb
    │   ├── adapters
    │   │   ├── hash_storage.rb
    │   │   └── redis_storage.rb
    │   ├── cache.rb
    │   ├── cloud_translation.rb
    │   ├── cloud_translation
    │   │   └── providers
    │   │   │   ├── base.rb
    │   │   │   ├── google.rb
    │   │   │   └── yandex.rb
    │   ├── engine.rb
    │   ├── export.rb
    │   ├── i18n_backend.rb
    │   ├── import.rb
    │   ├── loader.rb
    │   ├── middleware.rb
    │   ├── rails.rb
    │   ├── railtie.rb
    │   ├── services
    │   │   ├── humanize_service.rb
    │   │   └── localization_keys_to_hash_service.rb
    │   └── version.rb
    └── tasks
    │   └── lit_tasks.rake
├── lit.gemspec
├── script
    └── rails
└── test
    ├── .rubocop.yml
    ├── cassettes
        ├── Lit_CloudTranslation_Providers_Google
        │   ├── edge_cases
        │   │   └── when_text_contains_newline_characters
        │   │   │   └── translation_comes_back_preserving_those_characters.yml
        │   ├── when_from_and_to_languages_are_given
        │   │   ├── when_array_of_strings_is_given
        │   │   │   └── translates_array_of_strings_to_target_language.yml
        │   │   └── when_single_string_is_given
        │   │   │   └── translates_single_string_to_target_language.yml
        │   └── when_only_to_language_is_given
        │   │   ├── when_array_containing_nil_values_is_given
        │   │       └── translates_array_to_target_language_converting_nil_to_.yml
        │   │   ├── when_array_of_strings_is_given
        │   │       └── translates_array_of_strings_to_target_language.yml
        │   │   └── when_single_string_is_given
        │   │       ├── translates_single_string_to_target_language.yml
        │   │       └── when_string_contains_interpolation
        │   │           └── does_not_translate_stuff_enclosed_in_.yml
        └── Lit_CloudTranslation_Providers_Yandex
        │   ├── when_from_and_to_languages_are_given
        │       ├── when_array_of_strings_is_given
        │       │   └── translates_array_of_strings_to_target_language.yml
        │       └── when_single_string_is_given
        │       │   └── translates_single_string_to_target_language.yml
        │   └── when_only_to_language_is_given
        │       ├── when_array_containing_nil_values_is_given
        │           └── translates_array_to_target_language_converting_nil_to_.yml
        │       ├── when_array_of_strings_is_given
        │           └── translates_array_of_strings_to_target_language.yml
        │       └── when_single_string_is_given
        │           ├── translates_single_string_to_target_language.yml
        │           └── when_string_contains_interpolation
        │               └── does_not_translate_stuff_enclosed_in_.yml
    ├── dummy
        ├── README.rdoc
        ├── Rakefile
        ├── app
        │   ├── assets
        │   │   ├── config
        │   │   │   └── manifest.js
        │   │   ├── javascripts
        │   │   │   ├── application.js
        │   │   │   └── projects.js
        │   │   └── stylesheets
        │   │   │   ├── application.css
        │   │   │   ├── projects.css.scss
        │   │   │   └── scaffolds.css.scss
        │   ├── controllers
        │   │   ├── application_controller.rb
        │   │   ├── projects_controller.rb
        │   │   └── welcome_controller.rb
        │   ├── helpers
        │   │   ├── application_helper.rb
        │   │   └── projects_helper.rb
        │   ├── mailers
        │   │   └── .gitkeep
        │   ├── models
        │   │   ├── .gitkeep
        │   │   ├── admin.rb
        │   │   └── project.rb
        │   └── views
        │   │   ├── layouts
        │   │       └── application.html.erb
        │   │   ├── projects
        │   │       ├── _form.html.erb
        │   │       ├── edit.html.erb
        │   │       ├── index.html.erb
        │   │       ├── new.html.erb
        │   │       └── show.html.erb
        │   │   └── welcome
        │   │       └── index.html.erb
        ├── config.ru
        ├── config
        │   ├── application.rb
        │   ├── boot.rb
        │   ├── database.yml.sample
        │   ├── database.yml.travis
        │   ├── environment.rb
        │   ├── environments
        │   │   ├── development.rb
        │   │   ├── production.rb
        │   │   └── test.rb
        │   ├── initializers
        │   │   ├── assets.rb
        │   │   ├── backtrace_silencers.rb
        │   │   ├── devise.rb
        │   │   ├── i18n.rb
        │   │   ├── inflections.rb
        │   │   ├── lit.rb
        │   │   ├── mime_types.rb
        │   │   ├── postgres_10_pg_sequence_fix.rb
        │   │   ├── secret_token.rb
        │   │   ├── session_store.rb
        │   │   └── wrap_parameters.rb
        │   ├── locales
        │   │   ├── active_support_extensions.yml
        │   │   ├── en.yml
        │   │   ├── pl.yml
        │   │   └── simple_form.en.yml
        │   └── routes.rb
        ├── db
        │   ├── migrate
        │   │   ├── 20121106204557_devise_create_admins.rb
        │   │   └── 20121223141035_create_projects.rb
        │   └── schema.rb
        ├── lib
        │   └── assets
        │   │   └── .gitkeep
        ├── log
        │   └── .gitkeep
        ├── public
        │   ├── 404.html
        │   ├── 422.html
        │   ├── 500.html
        │   └── favicon.ico
        └── script
        │   └── rails
    ├── fixtures
        └── lit
        │   ├── files
        │       ├── import.csv.array
        │       ├── import.csv.array_with_nil
        │       ├── import.csv.malformed
        │       ├── import.csv.missing-locale
        │       ├── import.csv.nil
        │       ├── import.csv.normal
        │       ├── import.tsv.normal
        │       ├── import.yml.array
        │       ├── import.yml.malformed
        │       ├── import.yml.missing-locale
        │       ├── import.yml.nil
        │       ├── import.yml.normal
        │       └── import.yml.raw
        │   ├── incomming_localizations.yml
        │   ├── locales.yml
        │   ├── localization_keys.yml
        │   ├── localization_versions.yml
        │   ├── localizations.yml
        │   └── sources.yml
    ├── functional
        ├── lit
        │   ├── api
        │   │   └── v1
        │   │   │   ├── locales_controller_test.rb
        │   │   │   ├── localization_keys_controller_test.rb
        │   │   │   └── localizations_controller_test.rb
        │   ├── cloud_translations_controller_test.rb
        │   ├── dashboard_controller_test.rb
        │   ├── incomming_localizations_controller_test.rb
        │   ├── locales_controller_test.rb
        │   ├── localization_keys_controller_test.rb
        │   ├── localizations_controller_test.rb
        │   └── sources_controller_test.rb
        └── welcome_controller_test.rb
    ├── integration
        └── lit
        │   ├── backend_test.rb
        │   ├── locales_test.rb
        │   ├── projects_test.rb
        │   └── welcome_test.rb
    ├── lib
        └── raw_import_task_test.rb
    ├── lit_test.rb
    ├── services
        └── lit
        │   └── synchronize_source_service_test.rb
    ├── support
        ├── clear_redis.rb
        ├── en.yml
        ├── en_changed.yml
        └── redis_prefix.rb
    ├── test_helper.rb
    ├── test_helpers
        └── warden.rb
    └── unit
        ├── export_test.rb
        ├── helpers
            └── lit
            │   ├── dashboard_helper_test.rb
            │   └── sources_helper_test.rb
        ├── i18n_backend_test.rb
        ├── import_test.rb
        ├── lit
            ├── cloud_translation
            │   └── providers
            │   │   ├── examples.rb
            │   │   ├── google_test.rb
            │   │   └── yandex_test.rb
            ├── incomming_localization_test.rb
            ├── locale_test.rb
            ├── localization_key_test.rb
            ├── localization_test.rb
            ├── localization_version_test.rb
            ├── services
            │   └── localization_keys_to_hash_service_test.rb
            └── source_test.rb
        ├── lit_behaviour_test.rb
        └── pure_i18n_compatibility_test.rb


/.gitignore:
--------------------------------------------------------------------------------
 1 | .bundle/
 2 | log/*.log
 3 | pkg/
 4 | test/dummy/db/*.sqlite3
 5 | test/dummy/log/*.log
 6 | test/dummy/tmp/
 7 | test/dummy/.sass-cache
 8 | .sass-cache/
 9 | /lit-*.gem
10 | **.DS_Store
11 | Gemfile.lock
12 | vendor/bundle
13 | /tags
14 | test/dummy/config/database.yml
15 | 


--------------------------------------------------------------------------------
/.ruby-gemset:
--------------------------------------------------------------------------------
1 | lit
2 | 


--------------------------------------------------------------------------------
/.ruby-version:
--------------------------------------------------------------------------------
1 | 2.7.4
2 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: ruby
 2 | jobs:
 3 |   exclude:
 4 |     - rvm: 3.0.1
 5 |       gemfile: gemfiles/rails_5.2.gemfile
 6 | rvm:
 7 |   - 2.7.3
 8 |   - 3.0.1
 9 | gemfile:
10 |   - gemfiles/rails_5.2.gemfile
11 |   - gemfiles/rails_6.0.gemfile
12 |   - gemfiles/rails_6.1.gemfile
13 | services:
14 |   - postgresql
15 |   - redis-server
16 | env:
17 |   - LIT_STORAGE=hash
18 |   - LIT_STORAGE=redis
19 | before_install:
20 |   - gem install bundler
21 | before_script:
22 |   - cp test/dummy/config/database.yml.travis test/dummy/config/database.yml
23 |   - psql -c 'create database lit_test;' -U postgres
24 |   - RAILS_ENV=test bundle exec rake db:migrate
25 | script: "bundle exec rake test"
26 | 


--------------------------------------------------------------------------------
/Appraisals:
--------------------------------------------------------------------------------
 1 | appraise 'rails-5.2' do
 2 |   source 'https://rubygems.org'
 3 |   gem 'rails', '~> 5.2.0'
 4 |   gem 'devise'
 5 |   gem 'pg', '~> 1.2.3'
 6 |   gem 'redis'
 7 |   gem 'capybara'
 8 |   gem 'database_cleaner'
 9 |   gem 'test_declarative'
10 |   gem 'mocha'
11 |   gem 'webmock'
12 |   gem 'sass-rails'
13 |   gem 'jquery-rails'
14 |   gem 'coffee-rails'
15 |   gem 'pry-rails'
16 |   gem 'rails-controller-testing'
17 |   gem 'minitest'
18 |   gem 'm', '~> 1.5.0'
19 |   gem 'google-cloud-translate', '~> 1.2.4'
20 | end
21 | 
22 | appraise 'rails-6.0' do
23 |   source 'https://rubygems.org'
24 |   gem 'rails', '~> 6.0.3'
25 |   gem 'devise'
26 |   gem 'pg', '~> 1.2.3'
27 |   gem 'redis'
28 |   gem 'capybara'
29 |   gem 'database_cleaner'
30 |   gem 'test_declarative'
31 |   gem 'mocha'
32 |   gem 'webmock'
33 |   gem 'sass-rails'
34 |   gem 'jquery-rails'
35 |   gem 'coffee-rails'
36 |   gem 'pry-rails'
37 |   gem 'rails-controller-testing'
38 |   gem 'minitest'
39 |   gem 'm', '~> 1.5.0'
40 |   gem 'google-cloud-translate', '~> 1.2.4'
41 | end
42 | 
43 | appraise 'rails-6.1' do
44 |   source 'https://rubygems.org'
45 |   gem 'rails', '~> 6.1.4.1'
46 |   gem 'devise'
47 |   gem 'pg', '~> 1.2.3'
48 |   gem 'redis'
49 |   gem 'capybara'
50 |   gem 'database_cleaner'
51 |   gem 'test_declarative'
52 |   gem 'mocha'
53 |   gem 'webmock'
54 |   gem 'sass-rails'
55 |   gem 'jquery-rails'
56 |   gem 'coffee-rails'
57 |   gem 'pry-rails'
58 |   gem 'rails-controller-testing'
59 |   gem 'minitest'
60 |   gem 'm', '~> 1.5.0'
61 |   gem 'google-cloud-translate', '~> 2.1.2'
62 | end
63 | 


--------------------------------------------------------------------------------
/Gemfile:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 | 
3 | source 'https://rubygems.org'
4 | 
5 | gemspec
6 | 


--------------------------------------------------------------------------------
/MIT-LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2013 Prograils.com
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining
 4 | a copy of this software and associated documentation files (the
 5 | "Software"), to deal in the Software without restriction, including
 6 | without limitation the rights to use, copy, modify, merge, publish,
 7 | distribute, sublicense, and/or sell copies of the Software, and to
 8 | permit persons to whom the Software is furnished to do so, subject to
 9 | the following conditions:
10 | 
11 | The above copyright notice and this permission notice shall be
12 | included in all copies or substantial portions of the Software.
13 | 
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
18 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
19 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
 1 | require "bundler/gem_tasks"
 2 | 
 3 | APP_RAKEFILE = File.expand_path('../test/dummy/Rakefile', __FILE__)
 4 | load 'rails/tasks/engine.rake'
 5 | 
 6 | begin
 7 |   require 'rdoc/task'
 8 | rescue LoadError
 9 |   require 'rdoc/rdoc'
10 |   require 'rake/rdoctask'
11 |   RDoc::Task = Rake::RDocTask
12 | end
13 | 
14 | RDoc::Task.new(:rdoc) do |rdoc|
15 |   rdoc.rdoc_dir = 'rdoc'
16 |   rdoc.title    = 'Lit'
17 |   rdoc.options << '--line-numbers'
18 |   rdoc.rdoc_files.include('README.rdoc')
19 |   rdoc.rdoc_files.include('lib/**/*.rb')
20 | end
21 | 
22 | require "rake/testtask"
23 | Rake::TestTask.new(:test) do |t|
24 |   puts "Storage: #{ENV['LIT_STORAGE'] || 'redis'}"
25 |   t.libs << 'test'
26 |   t.libs << 'lib'
27 |   t.pattern = 'test/**/*_test.rb'
28 |   t.verbose = false
29 | end
30 | 
31 | task :default => :test
32 | 
33 | 


--------------------------------------------------------------------------------
/app/assets/images/lit/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/prograils/lit/dc11ab3415524d16a6dfe40b130a07248dc65f2b/app/assets/images/lit/.gitkeep


--------------------------------------------------------------------------------
/app/assets/images/lit/jquery-te.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/prograils/lit/dc11ab3415524d16a6dfe40b130a07248dc65f2b/app/assets/images/lit/jquery-te.png


--------------------------------------------------------------------------------
/app/assets/javascripts/lit/application.js:
--------------------------------------------------------------------------------
 1 | // This is a manifest file that'll be compiled into application.js, which will include all the files
 2 | // listed below.
 3 | //
 4 | // Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
 5 | // or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
 6 | //
 7 | // It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
 8 | // the compiled file.
 9 | //
10 | // WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
11 | // GO AFTER THE REQUIRES BELOW.
12 | //
13 | //= require jquery
14 | //= require jquery_ujs
15 | //= require_directory ./backend/
16 | 
17 | $(document).ready(function(){
18 |   $('.title').tooltip();
19 | });
20 | 


--------------------------------------------------------------------------------
/app/assets/javascripts/lit/backend/bootstrap.js.coffee:
--------------------------------------------------------------------------------
1 | jQuery ->
2 |   $("a[rel=popover]").popover()
3 |   $(".tooltip").tooltip()
4 |   $("a[rel=tooltip]").tooltip()


--------------------------------------------------------------------------------
/app/assets/javascripts/lit/backend/dashboard.js:
--------------------------------------------------------------------------------
1 | // Place all the behaviors and hooks related to the matching controller here.
2 | // All this logic will automatically be available in application.js.
3 | 


--------------------------------------------------------------------------------
/app/assets/javascripts/lit/backend/localizations.js.coffee:
--------------------------------------------------------------------------------
 1 | @edited_rows = {}
 2 | $(document).ready ->
 3 |   $('td.localization_row[data-editing=0]').on 'click', ->
 4 |     $this = $(this)
 5 |     if parseInt($this.data('editing')) == 0
 6 |       edited_rows[$this.data('id')] = $this.html()
 7 |       unless parseInt($this.data('editing'))
 8 |         $this.data('editing', '1')
 9 |         $.get $this.data('edit')
10 |   $('td.localization_row').on 'click', 'form button.cancel', (e) ->
11 |     $this = $(this)
12 |     if $this[0].localName == 'button'
13 |       $this = $this.parents('td.localization_row')
14 |     $this.data('editing', 0)
15 |     $this.html edited_rows[$this.data('id')]
16 |     e.preventDefault()
17 |     false
18 |   $('tr.localization_versions_row').on 'click', '.close_versions', (e) ->
19 |     $this = $(this)
20 |     $parent = $this.parents('tr.localization_versions_row')
21 |     $parent.addClass('hidden')
22 |     $parent.children('td').html('')
23 |   $('tr.localization_key_row').on 'click', 'input.wysiwyg_switch', (e) ->
24 |     $(this).parents('form').find("textarea").jqte()
25 |   $('tr.localization_key_row').on 'click', '.request_info_link', (e) ->
26 |     $(this).parents('tr.localization_key_row').find(".request_info_row").toggleClass('hidden')
27 |   $('tr.localization_key_row').on 'click', '.js-copy_to_clipboard', (e) ->
28 |     if(!navigator.clipboard)
29 |       alert('No browser support for clipboard')
30 |     else
31 |       navigator.clipboard.writeText($(this).data('key'))
32 |     e.preventDefault()
33 |     false
34 | 


--------------------------------------------------------------------------------
/app/assets/javascripts/lit/backend/sources.js.coffee:
--------------------------------------------------------------------------------
 1 | $ ->
 2 |   sourceId = $('#source_id').attr('value')
 3 | 
 4 |   updateFunc = ->
 5 |     $.ajax "/lit/sources/" + sourceId + "/sync_complete",
 6 |       type: 'GET'
 7 |       format: 'json'
 8 |       success: (xml, textStatus, xhr) ->
 9 |         if xhr.responseJSON.sync_complete
10 |           $('.loading').addClass('loaded').removeClass('loading')
11 |           clearInterval(interval)
12 |           location.reload()
13 |       statusCode:
14 |         404: ->
15 |           $('.loading').text('Could not update synchronization status, please try refreshing page')
16 |         401: ->
17 |           $('.loading').text('You are not authorized. Please check if you are properly logged in')
18 |         500: ->
19 |           $('.loading').text('Something went wrong, please try synchronizing again')
20 |       error: ->
21 |         clearInterval(interval)
22 | 
23 |   if $('.loading').length > 0
24 |     interval = window.setInterval(updateFunc, 500)
25 | 


--------------------------------------------------------------------------------
/app/assets/stylesheets/lit/application.css:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * This is a manifest file that'll be compiled into application.css, which will include all the files
 3 |  * listed below.
 4 |  *
 5 |  * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
 6 |  * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
 7 |  *
 8 |  * You're free to add application-wide styles to this file and they'll appear at the top of the
 9 |  * compiled file, but it's generally better to create a new file per style scope.
10 |  *
11 |  *= require './backend/jquery-te-1.4.0.css'
12 |  *= require_self
13 |  */
14 | .detail_wrapper {
15 |   padding: 10px 0 0 10px;
16 | }
17 | .detail_wrapper table tr td.locale_row {
18 |   width: 75px;
19 | }
20 | .localization_key_row .localization_keys_options {
21 |   display: none;
22 |   float: right;
23 | }
24 | .localization_key_row:hover .localization_keys_options {
25 |   display: block;
26 | }
27 | 
28 | li.key_prefix .fa-chevron-right {
29 |   float: right;
30 |   margin-top: 2px;
31 |   margin-right: -6px;
32 |   opacity: 0.25;
33 | }
34 | 
35 | .hidden {
36 |   display: none;
37 | }
38 | i.fa {
39 |   color: black;
40 | }
41 | .nav.nav-stacked > li > a {
42 |   padding: 5px 7px;
43 | }
44 | .well {
45 |   background-color: white;
46 |   border-radius: 0px;
47 | }
48 | .well label {
49 |   font-weight: normal;
50 | }
51 | .well .form-search {
52 |   margin-bottom: 15px;
53 | }
54 | .localization_row em {
55 |   color: #bbb;
56 | }
57 | .loading {
58 |   display: inline;
59 | }
60 | .loaded {
61 |   display: none;
62 | }
63 | .copy_to_clipboard_btn {
64 |   cursor: pointer;
65 | }
66 | 


--------------------------------------------------------------------------------
/app/assets/stylesheets/lit/lit_frontend.css:
--------------------------------------------------------------------------------
 1 | .lit-key-generic {
 2 | }
 3 | .lit-key-highlight {
 4 |   text-decoration: underline !important;
 5 |   text-decoration-color: red !important;
 6 |   text-decoration-style: wavy !important;
 7 | }
 8 | #lit_button_wrapper {
 9 |   position: fixed;
10 |   bottom: 20px;
11 |   right: 20px;
12 |   z-index: 100;
13 |   background-color: red;
14 |   border-radius: 4px;
15 |   display: block;
16 |   padding: 5px;
17 |   cursor: pointer;
18 |   color: white;
19 | }
20 | #lit_button_wrapper.lit-highlight-enabled {
21 |   background-color: lightgreen;
22 | }
23 | #lit_textarea {
24 |   position: absolute;
25 |   padding: 0 0 1px 0;
26 |   margin: 0 0 0 0;
27 |   border: 0;
28 |   border-bottom: 1px solid red;
29 | }
30 | .lit-translations-info.collapsed {
31 |   position: fixed;
32 |   bottom: 60px;
33 |   right: 20px;
34 |   z-index: 100;
35 |   background-color: green;
36 |   border-radius: 4px;
37 |   display: block;
38 |   padding: 5px;
39 |   cursor: pointer;
40 |   color: white;
41 | }
42 | .lit-translations-info.expanded {
43 |   position: absolute;
44 |   display: block;
45 |   width: 80%;
46 |   overflow: auto;
47 |   height: 80%;
48 |   right: 10%;
49 |   left: 10%;
50 |   top: 10%;
51 |   background-color: rgba(240, 240, 240, 0.9);
52 |   border: 1px solid black;
53 |   z-index: 90;
54 | }
55 | 
56 | .lit-translations-info.collapsed span.lit-open-button {
57 |   display: block;
58 | }
59 | .lit-translations-info.expanded span.lit-open-button {
60 |   display: none;
61 | }
62 | .lit-translations-info.collapsed span.lit-close-button {
63 |   display: none;
64 | }
65 | .lit-translations-info.expanded span.lit-close-button {
66 |   display: block;
67 |   position: fixed;
68 |   right: 10%;
69 |   border: 2px solid black;
70 |   font-size: 12pt;
71 |   font-weight: bold;
72 |   background-color: white;
73 |   padding: 10px 10px 5px;
74 | }
75 | .lit-translations-info.collapsed ul.lit-translations-list {
76 |   display: none;
77 | }
78 | .lit-translations-info.expanded ul.lit-translations-list {
79 | }
80 | 
81 | .lit-translations-info.expanded ul.lit-translations-list li {
82 |   margin: 5px;
83 | }
84 | 
85 | .lit-translations-info.expanded #lit_textarea {
86 |   padding: 2px;
87 | }
88 | 


--------------------------------------------------------------------------------
/app/controllers/lit/api/v1/base_controller.rb:
--------------------------------------------------------------------------------
 1 | module Lit
 2 |   module Api
 3 |     module V1
 4 |       class BaseController < ActionController::Base
 5 |         layout nil
 6 |         respond_to :json if ::Rails::VERSION::MAJOR < 5
 7 |         before_action :authenticate_requests!
 8 | 
 9 |         private
10 | 
11 |         def authenticate_requests!
12 |           authenticate_or_request_with_http_token do |token, _options|
13 |             Lit.api_key == token
14 |           end
15 |         end
16 |       end
17 |     end
18 |   end
19 | end
20 | 


--------------------------------------------------------------------------------
/app/controllers/lit/api/v1/locales_controller.rb:
--------------------------------------------------------------------------------
 1 | require_dependency 'lit/api/v1/base_controller'
 2 | 
 3 | module Lit
 4 |   module Api
 5 |     module V1
 6 |       class LocalesController < Api::V1::BaseController
 7 |         def index
 8 |           @locales = Locale.all
 9 |           render json: @locales.as_json(root: false, only: %i[id locale])
10 |         end
11 |       end
12 |     end
13 |   end
14 | end
15 | 


--------------------------------------------------------------------------------
/app/controllers/lit/api/v1/localization_keys_controller.rb:
--------------------------------------------------------------------------------
 1 | require_dependency 'lit/api/v1/base_controller'
 2 | 
 3 | module Lit
 4 |   class Api::V1::LocalizationKeysController < Api::V1::BaseController
 5 |     def index
 6 |       @localization_keys = fetch_localization_keys
 7 |       render json: @localization_keys.as_json(
 8 |         root: false, only: %i[id localization_key is_deleted]
 9 |       )
10 |     end
11 | 
12 |     private
13 | 
14 |     def fetch_localization_keys
15 |       if params[:after].present?
16 |         after_date = Time.parse(params[:after])
17 |         LocalizationKey.after(after_date).to_a
18 |       else
19 |         LocalizationKey.all
20 |       end
21 |     end
22 |   end
23 | end
24 | 


--------------------------------------------------------------------------------
/app/controllers/lit/api/v1/localizations_controller.rb:
--------------------------------------------------------------------------------
 1 | module Lit
 2 |   class Api::V1::LocalizationsController < Api::V1::BaseController
 3 |     def index
 4 |       @localizations = fetch_localizations
 5 |       render json:
 6 |                @localizations.as_json(
 7 |                  root: false,
 8 |                  only: %i[id localization_key_id locale_id],
 9 |                  methods: %i[value localization_key_str locale_str localization_key_is_deleted],
10 |                )
11 |     end
12 | 
13 |     def last_change
14 |       @localization = Localization.order(updated_at: :desc).first
15 |       render json: @localization.as_json(root: false, only: [], methods: [:last_change])
16 |     end
17 | 
18 |     private
19 | 
20 |     def fetch_localizations
21 |       scope = Localization.includes(:locale, :localization_key)
22 | 
23 |       if params[:after].present?
24 |         after_date = Time.parse("#{params[:after]} #{Time.zone.name}").in_time_zone
25 |         scope.after(after_date).to_a
26 |       else
27 |         scope.all
28 |       end
29 |     end
30 |   end
31 | end
32 | 


--------------------------------------------------------------------------------
/app/controllers/lit/application_controller.rb:
--------------------------------------------------------------------------------
 1 | module Lit
 2 |   class ApplicationController < ActionController::Base
 3 |     unless respond_to?(:before_action)
 4 |       alias before_action before_filter
 5 |       alias after_action after_filter
 6 |     end
 7 |     before_action :authenticate
 8 |     before_action :stop_hits_counter
 9 |     after_action :restore_hits_counter
10 | 
11 |     private
12 | 
13 |     def authenticate
14 |       return unless Lit.authentication_function.present?
15 | 
16 |       send(Lit.authentication_function)
17 |     end
18 | 
19 |     def stop_hits_counter
20 |       Lit.init.cache.stop_hits_counter
21 |     end
22 | 
23 |     def restore_hits_counter
24 |       Lit.init.cache.restore_hits_counter
25 |     end
26 | 
27 |     def redirect_to_back_or_default(fallback_location: nil)
28 |       fallback_location ||= lit.localization_keys_path
29 |       if respond_to?(:redirect_back)
30 |         redirect_back fallback_location: fallback_location
31 |       elsif referer.present? && referer != request.env['REQUEST_URI']
32 |         redirect_to :back
33 |       else
34 |         redirect_to fallback_location
35 |       end
36 |     end
37 | 
38 |     def referer
39 |       request.referer
40 |     end
41 |   end
42 | end
43 | 


--------------------------------------------------------------------------------
/app/controllers/lit/cloud_translations_controller.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | module Lit
 4 |   class CloudTranslationsController < ::Lit::ApplicationController
 5 |     def show
 6 |       params.delete(:from) if params[:from] == 'auto'
 7 |       @target_localization = Localization.find(params[:localization_id])
 8 |       @localization_key = @target_localization.localization_key
 9 |       if params[:from]
10 |         @localization = @localization_key.localizations.joins(:locale)
11 |                                          .find_by!(lit_locales: { locale: params[:from] })
12 |       end
13 |       opts =
14 |         {
15 |           # if :from was auto, translate from the target localization's
16 |           # current text itself
17 |           text: (@localization || @target_localization).value,
18 |           from: params[:from],
19 |           to: @target_localization.locale.locale
20 |         }.compact
21 |       @translated_text = Lit::CloudTranslation.translate(**opts)
22 |     rescue Lit::CloudTranslation::TranslationError => e
23 |       @error_message = "Translation failed. #{e.message}"
24 |     end
25 |   end
26 | end
27 | 


--------------------------------------------------------------------------------
/app/controllers/lit/concerns/request_info_store.rb:
--------------------------------------------------------------------------------
1 | module Lit::Concerns::RequestInfoStore
2 |   extend ActiveSupport::Concern
3 | 
4 |   included do
5 |     Rails.logger.info 'DEPRECATED: Use include Lit::RequestInfoStore'
6 |     include Lit::RequestInfoStore
7 |   end
8 | end
9 | 


--------------------------------------------------------------------------------
/app/controllers/lit/concerns/request_keys_store.rb:
--------------------------------------------------------------------------------
1 | module Lit::Concerns::RequestKeysStore
2 |   extend ActiveSupport::Concern
3 | 
4 |   included do
5 |     Rails.logger.info 'DEPRECATED: Use include Lit::RequestKeysStore'
6 |     include Lit::RequestKeysStore
7 |   end
8 | end
9 | 


--------------------------------------------------------------------------------
/app/controllers/lit/dashboard_controller.rb:
--------------------------------------------------------------------------------
 1 | require_dependency 'lit/application_controller'
 2 | 
 3 | module Lit
 4 |   class DashboardController < ::Lit::ApplicationController
 5 |     def index
 6 |       @locales = Lit::Locale.ordered.visible
 7 |     end
 8 |   end
 9 | end
10 | 


--------------------------------------------------------------------------------
/app/controllers/lit/incomming_localizations_controller.rb:
--------------------------------------------------------------------------------
 1 | require_dependency 'lit/application_controller'
 2 | 
 3 | module Lit
 4 |   class IncommingLocalizationsController < ApplicationController
 5 |     before_action :find_source_and_incomming_localizations
 6 |     before_action :find_icomming_localization, only: %i[accept destroy]
 7 | 
 8 |     def index; end
 9 | 
10 |     def accept
11 |       @incomming_localization.accept
12 |       respond_to do |format|
13 |         format.html { finish_request }
14 |         format.js
15 |       end
16 |     end
17 | 
18 |     def accept_all
19 |       ActiveRecord::Base.transaction do
20 |         @incomming_localizations.each(&:accept)
21 |       end
22 |       finish_request
23 |     end
24 | 
25 |     def reject_all
26 |       @incomming_localizations.destroy_all
27 |       finish_request
28 |     end
29 | 
30 |     def destroy
31 |       @incomming_localization.destroy
32 |       respond_to do |format|
33 |         format.html { redirect_to source_incomming_localizations_path(@source) }
34 |         format.js
35 |       end
36 |     end
37 | 
38 |     private
39 | 
40 |     def find_icomming_localization
41 |       @incomming_localization = @source.incomming_localizations
42 |                                        .find(params[:id].to_i)
43 |     end
44 | 
45 |     def find_source_and_incomming_localizations
46 |       @source = Source.find(params[:source_id].to_i)
47 |       @incomming_localizations = @source.incomming_localizations
48 |     end
49 | 
50 |     def finish_request
51 |       redirect_to_back_or_default(
52 |         fallback_location: source_incomming_localizations_path(@source)
53 |       )
54 |     end
55 |   end
56 | end
57 | 


--------------------------------------------------------------------------------
/app/controllers/lit/locales_controller.rb:
--------------------------------------------------------------------------------
 1 | require_dependency 'lit/application_controller'
 2 | 
 3 | module Lit
 4 |   class LocalesController < ApplicationController
 5 |     def index
 6 |       @locales = Locale.ordered
 7 | 
 8 |       respond_to do |format|
 9 |         format.html # index.html.erb
10 |         format.json { render json: @locales }
11 |       end
12 |     end
13 | 
14 |     def hide
15 |       @locale = Locale.find(params[:id])
16 |       @locale.toggle :is_hidden
17 |       @locale.save
18 |       respond_to :js
19 |     end
20 | 
21 |     def destroy
22 |       @locale = Locale.find(params[:id])
23 |       @locale.destroy
24 | 
25 |       respond_to do |format|
26 |         format.html { redirect_to locales_url }
27 |         format.json { head :no_content }
28 |       end
29 |     end
30 |   end
31 | end
32 | 


--------------------------------------------------------------------------------
/app/controllers/lit/localizations_controller.rb:
--------------------------------------------------------------------------------
 1 | module Lit
 2 |   class LocalizationsController < ::Lit::ApplicationController
 3 |     before_action :find_localization_key
 4 |     before_action :find_localization
 5 | 
 6 |     def show
 7 |       render json: { value: @localization.translation }
 8 |     end
 9 | 
10 |     def edit
11 |       @localization.translated_value = @localization.translation
12 |       respond_to do |format|
13 |         format.js
14 |       end
15 |     end
16 | 
17 |     def update
18 |       # Wrapping it in a transaction leverages the fact that @localization's
19 |       # :after_commit callback is then executed AFTER whatever's done in
20 |       # #after_update_operations. So it'll first set :is_changed to true
21 |       # and then it will be properly read in the cache setting routine.
22 |       @localization.transaction do
23 |         after_update_operations if @localization.update(clear_params)
24 |       end
25 |       respond_to do |f|
26 |         f.js
27 |         f.json do
28 |           render json: { value: @localization.reload.translation }
29 |         end
30 |       end
31 |     end
32 | 
33 |     def change_completed
34 |       @localization.toggle(:is_changed).save!
35 |       respond_to :js
36 |     end
37 | 
38 |     def previous_versions
39 |       @versions = @localization.versions.order(created_at: :desc)
40 |       respond_to :js
41 |     end
42 | 
43 |     private
44 | 
45 |     def find_localization_key
46 |       @localization_key =
47 |         Lit::LocalizationKey.active.find(params[:localization_key_id])
48 |     end
49 | 
50 |     def find_localization
51 |       @localization =
52 |         @localization_key.localizations.includes(:locale).find(params[:id])
53 |     end
54 | 
55 |     def after_update_operations
56 |       @localization.update_column :is_changed, true
57 |     end
58 | 
59 |     def clear_params
60 |       if params.respond_to?(:permit)
61 |         # allow translated_value to be an array
62 |         if @localization.value.is_a?(Array)
63 |           params.require(:localization).permit(:locale_id, translated_value: [])
64 |         else
65 |           params.require(:localization).permit(:locale_id, :translated_value)
66 |         end
67 |       else
68 |         params[:localization].is_a?(Hash) ? params[:localization].slice(:translated_value, :locale_id) : {}
69 |       end
70 |     end
71 |   end
72 | end
73 | 


--------------------------------------------------------------------------------
/app/controllers/lit/request_info_store.rb:
--------------------------------------------------------------------------------
 1 | module Lit::RequestInfoStore
 2 |   extend ::ActiveSupport::Concern
 3 |   included { before_action :store_request_path }
 4 | 
 5 |   private
 6 | 
 7 |   def store_request_path
 8 |     Thread.current[:lit_current_request_path] = request&.path
 9 |   end
10 | end
11 | 


--------------------------------------------------------------------------------
/app/controllers/lit/request_keys_store.rb:
--------------------------------------------------------------------------------
 1 | module Lit::RequestKeysStore
 2 |   extend ::ActiveSupport::Concern
 3 |   included { before_action :init_request_keys }
 4 | 
 5 |   private
 6 | 
 7 |   def init_request_keys
 8 |     Thread.current[:lit_request_keys] = {}
 9 |   end
10 | end
11 | 


--------------------------------------------------------------------------------
/app/controllers/lit/sources_controller.rb:
--------------------------------------------------------------------------------
 1 | require_dependency 'lit/application_controller'
 2 | 
 3 | module Lit
 4 |   class SourcesController < ApplicationController
 5 |     before_action :find_source, except: %i[index new create]
 6 |     def index
 7 |       @sources = Source.all
 8 |     end
 9 | 
10 |     def show; end
11 | 
12 |     def new
13 |       @source = Source.new
14 |     end
15 | 
16 |     def edit; end
17 | 
18 |     def synchronize
19 |       @source.update_column(:sync_complete, false)
20 |       if defined?(ActiveJob)
21 |         SynchronizeSourceJob.perform_later(@source)
22 |       else
23 |         SynchronizeSourceService.new(@source).execute
24 |       end
25 |       redirect_to lit.source_incomming_localizations_path(@source)
26 |     end
27 | 
28 |     def touch
29 |       @source.touch_last_updated_at!
30 |       redirect_to_back_or_default fallback_location: source_path(@source)
31 |     end
32 | 
33 |     def create
34 |       @source = Source.new(clear_params)
35 |       if @source.save
36 |         redirect_to @source, notice: 'Source was successfully created.'
37 |       else
38 |         render action: 'new'
39 |       end
40 |     end
41 | 
42 |     def update
43 |       if @source.update(clear_params)
44 |         redirect_to @source, notice: 'Source was successfully updated.'
45 |       else
46 |         render action: 'edit'
47 |       end
48 |     end
49 | 
50 |     def destroy
51 |       @source.destroy
52 |       redirect_to sources_url
53 |     end
54 | 
55 |     def sync_complete
56 |       render json: { sync_complete: @source.sync_complete }
57 |     end
58 | 
59 |     private
60 | 
61 |     def find_source
62 |       @source = Source.find(params[:id])
63 |     end
64 | 
65 |     def clear_params
66 |       if defined?(::ActionController::StrongParameters)
67 |         params.require(:source).permit(:identifier, :url, :api_key)
68 |       else
69 |         params[:source]
70 |       end
71 |     end
72 |   end
73 | end
74 | 


--------------------------------------------------------------------------------
/app/helpers/lit/application_helper.rb:
--------------------------------------------------------------------------------
1 | module Lit
2 |   module ApplicationHelper
3 |   end
4 | end
5 | 


--------------------------------------------------------------------------------
/app/helpers/lit/dashboard_helper.rb:
--------------------------------------------------------------------------------
1 | module Lit
2 |   module DashboardHelper
3 |   end
4 | end
5 | 


--------------------------------------------------------------------------------
/app/helpers/lit/frontend_helper.rb:
--------------------------------------------------------------------------------
 1 | module Lit::FrontendHelper
 2 |   include ActionView::Helpers::TranslationHelper
 3 | 
 4 |   module TranslationKeyWrapper
 5 |     def translate(key, options = {})
 6 |       count = options[:count]
 7 |       options = options.with_indifferent_access
 8 |       key = scope_key_by_partial(key)
 9 |       key = pluralized_key(key, count) if count
10 | 
11 |       content = super(key, **options.symbolize_keys)
12 |       content = get_translateable_span(key, content) if !options[:skip_lit] && lit_authorized?
13 |       content
14 |     end
15 | 
16 |     def pluralized_key(key, count)
17 |       pluralizer = I18n.backend.send(:pluralizer, locale)
18 |       return unless pluralizer.respond_to?(:call)
19 |       last = count.zero? ? :zero : pluralizer.call(count)
20 |       format '%<key>s.%<last>s', key: key, last: last
21 |     end
22 | 
23 |     def t(key, options = {})
24 |       translate(key, options)
25 |     end
26 | 
27 |     def missing_translation(key, options)
28 |       # We try to humanize the key. Rails will do
29 |       # it anyway in below call to super, but then it will wrap it also in
30 |       # translation_missing span.
31 |       # Humanizing key should be last resort
32 |       if Lit::Services::HumanizeService.should_humanize?(key)
33 |         return Lit::Services::HumanizeService.humanize_and_cache(key, options)
34 |       end
35 | 
36 |       super(key, options)
37 |     end
38 |   end
39 |   prepend Lit::FrontendHelper::TranslationKeyWrapper
40 | 
41 |   def javascript_lit_tag
42 |     javascript_include_tag 'lit/lit_frontend', defer: true
43 |   end
44 | 
45 |   def stylesheet_lit_tag
46 |     stylesheet_link_tag 'lit/lit_frontend'
47 |   end
48 | 
49 |   def lit_frontend_assets
50 |     return unless lit_authorized?
51 | 
52 |     meta = content_tag :meta, '', value: lit.find_localization_localization_keys_path, name: 'lit-url-base'
53 |     safe_join [javascript_lit_tag, stylesheet_lit_tag, meta]
54 |   end
55 | 
56 |   def lit_translations_info
57 |     return if Thread.current[:lit_request_keys].nil?
58 |     return unless lit_authorized?
59 | 
60 |     content_tag :div, class: 'lit-translations-info collapsed' do
61 |       concat content_tag(:span, 'Show translations', class: 'lit-open-button')
62 |       concat content_tag(:span, 'X', class: 'lit-close-button')
63 |       concat translations_list_content_tag
64 |     end
65 |   end
66 | 
67 |   def translations_list_content_tag
68 |     content_tag :ul, class: 'lit-translations-list' do
69 |       Lit
70 |         .init
71 |         .cache
72 |         .request_keys
73 |         .each do |k, v|
74 |           concat(
75 |             content_tag(:li) do
76 |               concat content_tag(:code, "#{k}:")
77 |               concat get_translateable_span(k, v, alternative_text: '[empty]')
78 |             end,
79 |           )
80 |         end
81 |     end
82 |   end
83 | 
84 |   def lit_authorized?
85 |     return false if Lit.authentication_verification.blank?
86 | 
87 |     send Lit.authentication_verification
88 |   end
89 | 
90 |   def get_translateable_span(key, localization, alternative_text: nil)
91 |     content_tag :span, class: 'lit-key-generic', data: { key: key, locale: I18n.locale } do
92 |       localization.blank? ? alternative_text : localization
93 |     end
94 |   end
95 | end
96 | 


--------------------------------------------------------------------------------
/app/helpers/lit/localization_keys_helper.rb:
--------------------------------------------------------------------------------
1 | module Lit
2 |   module LocalizationKeysHelper
3 |     include LocalizationsHelper
4 |   end
5 | end
6 | 


--------------------------------------------------------------------------------
/app/helpers/lit/localizations_helper.rb:
--------------------------------------------------------------------------------
 1 | module Lit
 2 |   module LocalizationsHelper
 3 |     def draw_icon(icon, opts = {})
 4 |       raw "<i class=\"fa fa-#{icon} #{opts[:class]}\" " \
 5 |           "title=\"#{opts[:title]}\" ></i>"
 6 |     end
 7 | 
 8 |     def ejs(val)
 9 |       escape_javascript val.to_s
10 |     end
11 | 
12 |     def locale_flag locale
13 |       locale = locale.to_s.upcase[0,2]
14 |       locale = case locale
15 |                when 'EN' then 'GB'
16 |                else locale
17 |                end
18 |       locale.tr('A-Z', "\u{1F1E6}-\u{1F1FF}")
19 |     end
20 | 
21 |     def allow_wysiwyg_editor?(key)
22 |       Lit.all_translations_are_html_safe || key.to_s =~ /(\b|_|\.)html$/
23 |     end
24 | 
25 |     def available_locales_with_default_first
26 |       I18n.available_locales.sort_by { |l| l == I18n.default_locale ? 0 : 1 }
27 |     end
28 |   end
29 | end
30 | 


--------------------------------------------------------------------------------
/app/helpers/lit/sources_helper.rb:
--------------------------------------------------------------------------------
1 | module Lit
2 |   module SourcesHelper
3 |     def source_loading_class(source)
4 |       source.sync_complete ? 'loaded' : 'loading'
5 |     end
6 |   end
7 | end
8 | 


--------------------------------------------------------------------------------
/app/jobs/lit/synchronize_source_job.rb:
--------------------------------------------------------------------------------
 1 | module Lit
 2 |   if defined?(::ActiveJob)
 3 |     class SynchronizeSourceJob < ::ActiveJob::Base
 4 |       queue_as :default
 5 | 
 6 |       def perform(source)
 7 |         SynchronizeSourceService.new(source).execute
 8 |       end
 9 |     end
10 |   end
11 | end
12 | 


--------------------------------------------------------------------------------
/app/models/lit/base.rb:
--------------------------------------------------------------------------------
 1 | class Lit::Base < ActiveRecord::Base
 2 |   self.abstract_class = true
 3 | 
 4 |   before_save :mark_for_retry
 5 | 
 6 |   attr_accessor :retried_created, :retried_updated
 7 | 
 8 |   def mark_for_retry
 9 |     @will_retry_create = true
10 |   end
11 | 
12 |   after_rollback :retry_lit_model_save
13 | 
14 |   def rolledback_after_insert?
15 |     persisted? && @was_saved_with_insert && @was_rolled_back
16 |   end
17 | 
18 |   def rolledback_after_update?
19 |     persisted? && @was_saved_with_update && @was_rolled_back
20 |   end
21 | 
22 |   private
23 | 
24 |   def create_or_update(**kwargs, &block)
25 |     @was_saved_with_insert = true if new_record?
26 |     @was_saved_with_update = true if persisted?
27 | 
28 |     super
29 |   end
30 | 
31 |   def retry_lit_model_save
32 |     return if @was_rolled_back
33 |     @was_rolled_back = true
34 |     do_retry if instance_variable_defined?(:@will_retry_create) && @will_retry_create
35 |   end
36 | 
37 |   def do_retry
38 |     if !retried_created
39 |       self.retried_created = true
40 |       if rolledback_after_insert?
41 |         self.class.create! attributes.merge(retried_created: true)
42 |       end
43 |     elsif !retried_updated
44 |       # Why elsif and not just if? Because if a record object was first saved
45 |       # with INSERT and then with UPDATE (still being the same Ruby object),
46 |       # it makes no sense to retry both create and upadte. Let's only retry create.
47 |       self.retried_updated = true
48 |       if rolledback_after_update?
49 |         update_columns(attributes)
50 |       end
51 |     end
52 |   end
53 | 
54 | end
55 | 


--------------------------------------------------------------------------------
/app/models/lit/incomming_localization.rb:
--------------------------------------------------------------------------------
 1 | module Lit
 2 |   class IncommingLocalization < ActiveRecord::Base
 3 |     serialize :translated_value
 4 | 
 5 |     ## ASSOCIATIONS
 6 |     belongs_to :locale
 7 |     belongs_to :localization_key
 8 |     belongs_to :localization
 9 |     belongs_to :source
10 | 
11 |     ## ACCESSORS
12 |     attr_accessible unless defined?(::ActionController::StrongParameters)
13 | 
14 |     ## BEFORE & AFTER
15 |     before_validation :set_localization, on: :create
16 | 
17 |     def translation
18 |       translated_value
19 |     end
20 | 
21 |     def full_key
22 |       [locale_str, localization_key_str].join('.')
23 |     end
24 | 
25 |     def accept
26 |       if localization.present?
27 |         update_existing_localization_data
28 |         update_existing_localization_key_data
29 |       else
30 |         assign_new_localization_data
31 |       end
32 |       update_cache
33 |       destroy
34 |     end
35 | 
36 |     def duplicated?(val)
37 |       set_localization
38 |       return false if localization_has_changed?
39 | 
40 |       localization.translation == val
41 |     end
42 | 
43 |     private
44 | 
45 |     def set_localization
46 |       return if locale.blank? || localization_key.blank?
47 |       self.localization = localization_key.localizations.find_by(locale_id: locale_id)
48 |     end
49 | 
50 |     def localization_has_changed?
51 |       localization.blank? || localization.is_deleted != localization_key_is_deleted
52 |     end
53 | 
54 |     def update_existing_localization_data
55 |       localization.update!(translated_value: translated_value, is_changed: true)
56 |     end
57 | 
58 |     def update_existing_localization_key_data
59 |       localization_key.update!(is_deleted: localization_key_is_deleted)
60 |     end
61 | 
62 |     def assign_new_localization_data
63 |       assign_new_locale unless locale.present?
64 |       assign_new_localization_key unless localization_key.present?
65 |       assign_new_localization unless localization.present?
66 |     end
67 | 
68 |     def assign_new_locale
69 |       self.locale = Lit::Locale.where(locale: locale_str).first_or_create
70 |     end
71 | 
72 |     def assign_new_localization_key
73 |       self.localization_key =
74 |         Lit::LocalizationKey.where(localization_key: localization_key_str, is_deleted: localization_key_is_deleted)
75 |           .first_or_create!
76 |     end
77 | 
78 |     def assign_new_localization
79 |       self.localization =
80 |         Lit::Localization
81 |           .where(localization_key_id: localization_key.id)
82 |           .where(locale_id: locale.id)
83 |           .first_or_initialize
84 |       localization.translated_value = translated_value
85 |       localization.is_changed = true
86 |       localization.save!
87 |     end
88 | 
89 |     def update_cache
90 |       Lit.init.cache.update_cache localization.full_key, localization.translation
91 |     end
92 |   end
93 | end
94 | 


--------------------------------------------------------------------------------
/app/models/lit/locale.rb:
--------------------------------------------------------------------------------
 1 | module Lit
 2 |   class Locale < Base
 3 |     ## SCOPES
 4 |     scope :ordered, -> { order(locale: :asc) }
 5 |     scope :visible, -> { where(is_hidden: false) }
 6 | 
 7 |     ## ASSOCIATIONS
 8 |     has_many :localizations, dependent: :destroy
 9 | 
10 |     ## VALIDATIONS
11 |     validates :locale, presence: true, uniqueness: true
12 | 
13 |     ## BEFORE & AFTER
14 |     after_save :reset_available_locales_cache
15 |     after_destroy :reset_available_locales_cache
16 | 
17 |     ## ACCESSORS
18 |     unless defined?(::ActionController::StrongParameters)
19 |       attr_accessible :locale
20 |     end
21 | 
22 |     def to_s
23 |       locale
24 |     end
25 | 
26 |     def translated_percentage
27 |       total = all_localizations_count
28 |       total > 0 ? (changed_localizations_count * 100 / total) : 0
29 |     end
30 | 
31 |     def changed_localizations_count
32 |       localizations.active.changed.count(:id)
33 |     end
34 | 
35 |     def all_localizations_count
36 |       localizations.active.count(:id)
37 |     end
38 | 
39 |     private
40 | 
41 |     def reset_available_locales_cache
42 |       return unless I18n.backend.respond_to?(:reset_available_locales_cache)
43 |       I18n.backend.reset_available_locales_cache
44 |     end
45 |   end
46 | end
47 | 


--------------------------------------------------------------------------------
/app/models/lit/localization.rb:
--------------------------------------------------------------------------------
 1 | module Lit
 2 |   class Localization < Lit::Base
 3 |     serialize :translated_value
 4 |     serialize :default_value
 5 | 
 6 |     ## SCOPES
 7 |     scope :changed, -> { where is_changed: true }
 8 |     scope :not_changed, -> { where is_changed: false }
 9 | 
10 |     # @HACK: dirty, find a way to round date to full second
11 |     scope :after, lambda { |dt| where('updated_at >= ?', dt + 1.second).where(is_changed: true) }
12 |     scope :active, lambda { joins(:localization_key).where(Lit::LocalizationKey.table_name => { is_deleted: false }) }
13 | 
14 |     ## ASSOCIATIONS
15 |     belongs_to :locale, required: true
16 |     belongs_to :localization_key, touch: true, required: true
17 |     has_many :localization_versions, dependent: :destroy
18 |     has_many :versions, class_name: '::Lit::LocalizationVersion'
19 | 
20 |     ## DELEGATIONS
21 |     delegate :is_deleted, to: :localization_key
22 | 
23 |     ## VALIDATIONS
24 |     validates :locale, :localization_key, presence: true
25 | 
26 |     ## ACCESSORS
27 |     attr_accessor :full_key_str
28 | 
29 |     attr_accessible :translated_value, :locale_id unless defined?(::ActionController::StrongParameters)
30 | 
31 |     ## BEFORE & AFTER
32 |     with_options if: :translated_value_changed? do |o|
33 |       o.before_update :create_version
34 |     end
35 |     after_commit :update_cache, on: :update
36 | 
37 |     def to_s
38 |       translation
39 |     end
40 | 
41 |     def full_key
42 |       full_key_str || [locale.locale, localization_key.localization_key].join('.')
43 |     end
44 | 
45 |     def translation
46 |       is_changed? && !translated_value.nil? ? translated_value : default_value
47 |     end
48 | 
49 |     def value
50 |       translation
51 |     end
52 | 
53 |     def localization_key_str
54 |       localization_key.localization_key
55 |     end
56 | 
57 |     def localization_key_is_deleted
58 |       localization_key.is_deleted
59 |     end
60 | 
61 |     def locale_str
62 |       locale.locale
63 |     end
64 | 
65 |     def last_change
66 |       updated_at.to_s(:db)
67 |     end
68 | 
69 |     def update_default_value(value)
70 |       return true if persisted? && default_value == value
71 |       if persisted?
72 |         update(default_value: value)
73 |       else
74 |         self.default_value = value
75 |         save!
76 |       end
77 |     end
78 | 
79 |     private
80 | 
81 |     def update_cache
82 |       Lit.init.cache.update_cache full_key, translation
83 |     end
84 | 
85 |     def create_version
86 |       return if translated_value.blank?
87 |       translated_value = translated_value_was || default_value
88 |       localization_versions.new(translated_value: translated_value)
89 |     end
90 |   end
91 | end
92 | 


--------------------------------------------------------------------------------
/app/models/lit/localization_version.rb:
--------------------------------------------------------------------------------
 1 | module Lit
 2 |   class LocalizationVersion < ActiveRecord::Base
 3 |     serialize :translated_value
 4 | 
 5 |     ## ASSOCIATIONS
 6 |     belongs_to :localization
 7 | 
 8 |     def to_s
 9 |       translated_value
10 |     end
11 |   end
12 | end
13 | 


--------------------------------------------------------------------------------
/app/models/lit/source.rb:
--------------------------------------------------------------------------------
 1 | require 'net/http'
 2 | module Lit
 3 |   class Source < ActiveRecord::Base
 4 |     LOCALES_PATH = '/api/v1/locales.json'.freeze
 5 |     LOCALIZATION_KEYS_PATH = '/api/v1/localization_keys.json'.freeze
 6 |     LOCALIZATIONS_PATH = '/api/v1/localizations.json'.freeze
 7 |     LAST_CHANGE_PATH = '/api/v1/last_change.json'.freeze
 8 | 
 9 |     ## ASSOCIATIONS
10 |     has_many :incomming_localizations
11 | 
12 |     ## VALIDATIONS
13 |     validates :api_key, :identifier, :url,
14 |               presence: true
15 |     validates :url,
16 |               format: { with: %r{\Ahttps?://.*/.*[^/]\Z}i }
17 | 
18 |     ## ACCESSORS
19 |     unless defined?(::ActionController::StrongParameters)
20 |       attr_accessible :api_key, :identifier, :url
21 |     end
22 | 
23 |     ## BEFORE & AFTER
24 |     before_create :set_last_updated_at_upon_creation
25 |     after_validation :check_if_url_is_valid
26 | 
27 |     def last_change
28 |       result = RemoteInteractorService.new(self).send_request(LAST_CHANGE_PATH)
29 |       result['last_change'] unless result.nil?
30 |     end
31 | 
32 |     def touch_last_updated_at!
33 |       assign_last_updated_at
34 |       save
35 |     end
36 | 
37 |     def assign_last_updated_at(time = nil)
38 |       self.last_updated_at = time || Time.now
39 |     end
40 | 
41 |     private
42 | 
43 |     def check_if_url_is_valid
44 |       return if errors.present? || !(new_record? || url_changed?) ||
45 |                 last_change.present?
46 |       errors.add :url, 'is not accessible'
47 |     end
48 | 
49 |     def set_last_updated_at_upon_creation
50 |       return if last_updated_at.blank? && !Lit.set_last_updated_at_upon_creation
51 |       assign_last_updated_at
52 |     end
53 |   end
54 | end
55 | 


--------------------------------------------------------------------------------
/app/queries/localization_key_search_query.rb:
--------------------------------------------------------------------------------
 1 | class LocalizationKeySearchQuery
 2 |   def initialize(scope, params = {})
 3 |     @scope = scope
 4 |     @params = params.to_h
 5 |                     .reverse_merge(@scope.default_search_options)
 6 |                     .with_indifferent_access
 7 |   end
 8 | 
 9 |   def perform
10 |     order_data
11 |     search_key_prefix
12 |     search_key
13 |     search_completed
14 |     @scope
15 |   end
16 | 
17 |   private
18 | 
19 |   def order_data
20 |     if @params[:order] && order_options.include?(@params[:order])
21 |       column, order = @params[:order].split(' ')
22 |       @scope = @scope.order(
23 |         localization_key_arel[column.to_sym].send(order.to_sym)
24 |       )
25 |     else
26 |       @scope = @scope.ordered
27 |     end
28 |   end
29 | 
30 |   def search_key_prefix
31 |     return if @params[:key_prefix].blank?
32 |     q = Arel::Nodes.build_quoted("#{@params[:key_prefix]}%")
33 |     @scope = @scope.where(localization_key_col.matches(q))
34 |   end
35 | 
36 |   def search_key
37 |     return if @params[:key].blank?
38 |     q = Arel::Nodes.build_quoted("%#{@params[:key]}%")
39 |     q_underscore = Arel::Nodes.build_quoted("%#{@params[:key].parameterize.underscore}%")
40 |     cond = search_key_conditions(q, q_underscore)
41 |     @scope = @scope.joins([:localizations]).where(cond)
42 |   end
43 | 
44 |   def search_key_conditions(query, q_underscore)
45 |     localization_key_col.matches(query).or(
46 |       default_value_col.matches(query).or(
47 |         translated_value_col.matches(query)
48 |       )
49 |     ).or(localization_key_col.matches(q_underscore))
50 |   end
51 | 
52 |   def search_completed
53 |     return if @params[:include_completed].to_i != 1
54 |     @scope = @scope.not_completed
55 |   end
56 | 
57 |   def localization_key_col
58 |     localization_key_arel[:localization_key]
59 |   end
60 | 
61 |   def default_value_col
62 |     localization_arel[:default_value]
63 |   end
64 | 
65 |   def translated_value_col
66 |     localization_arel[:translated_value]
67 |   end
68 | 
69 |   def localization_key_arel
70 |     Arel::Table.new 'lit_localization_keys'
71 |   end
72 | 
73 |   def localization_arel
74 |     Arel::Table.new 'lit_localizations'
75 |   end
76 | 
77 |   def order_options
78 |     Lit::LocalizationKey.order_options
79 |   end
80 | end
81 | 


--------------------------------------------------------------------------------
/app/services/remote_interactor_service.rb:
--------------------------------------------------------------------------------
 1 | class RemoteInteractorService
 2 |   def initialize(source)
 3 |     @source = source
 4 |   end
 5 | 
 6 |   def send_request(path, query_values = {})
 7 |     uri = initialize_uri(path, query_values)
 8 |     req = initialize_request(uri)
 9 |     connection = initialize_connection(uri)
10 |     perform_request(connection, req)
11 |   rescue => e
12 |     return unless defined?(Rails)
13 |     ::Rails.logger.error { "Lit remote error: #{e}" }
14 |     nil # Return nil to be consistent with checks for .nil? otherwise returns True
15 |   end
16 | 
17 |   private
18 | 
19 |   def initialize_uri(path, query_values)
20 |     uri = URI(@source.url + path)
21 |     query_values.each do |k, v|
22 |       params = URI.decode_www_form(uri.query || '') << [k, v]
23 |       uri.query = URI.encode_www_form(params)
24 |     end
25 |     uri
26 |   end
27 | 
28 |   def initialize_request(uri)
29 |     req = Net::HTTP::Get.new(uri.request_uri)
30 |     req.add_field('Authorization', "Token token=\"#{@source.api_key}\"")
31 |     req
32 |   end
33 | 
34 |   def initialize_connection(uri)
35 |     http = Net::HTTP.new(uri.host, uri.port)
36 |     http.use_ssl = (uri.port == 443)
37 |     http.verify_mode = OpenSSL::SSL::VERIFY_NONE
38 |     http
39 |   end
40 | 
41 |   def perform_request(connection, request)
42 |     res = connection.start { |http| http.request(request) }
43 |     return res unless res.is_a?(Net::HTTPSuccess)
44 | 
45 |     JSON.parse(res.body)
46 |   end
47 | end
48 | 


--------------------------------------------------------------------------------
/app/services/synchronize_source_service.rb:
--------------------------------------------------------------------------------
 1 | class SynchronizeSourceService
 2 |   def initialize(source)
 3 |     @source = source
 4 |   end
 5 | 
 6 |   def execute
 7 |     synchronize_localizations
 8 |     update_timestamps
 9 |   end
10 | 
11 |   private
12 | 
13 |   def synchronize_localizations
14 |     after_date = @source.last_updated_at&.to_s(:db)
15 |     result = interactor.send_request Lit::Source::LOCALIZATIONS_PATH, after: after_date
16 |     return unless result&.is_a?(Array)
17 |     result.each { |loc| synchronize_localization loc }
18 |   end
19 | 
20 |   def synchronize_localization(loc)
21 |     inc_loc = find_incomming_localization(loc)
22 |     inc_loc.source = @source
23 |     inc_loc.locale_str = loc['locale_str']
24 |     inc_loc.locale = Lit::Locale.find_by(locale: loc['locale_str'])
25 |     inc_loc.localization_key_str = loc['localization_key_str']
26 |     inc_loc.localization_key_is_deleted = localization_key_deleted?(loc)
27 |     inc_loc.localization_key = find_localization_key(inc_loc)
28 |     inc_loc.translated_value = loc['value']
29 |     return if inc_loc.duplicated?(loc['value'])
30 | 
31 |     inc_loc.save!
32 |   end
33 | 
34 |   def find_incomming_localization(localization)
35 |     Lit::IncommingLocalization.find_or_initialize_by(incomming_id: localization['id'])
36 |   end
37 | 
38 |   def find_localization_key(inc_loc)
39 |     Lit::LocalizationKey.find_by(localization_key: inc_loc.localization_key_str)
40 |   end
41 | 
42 |   def localization_key_deleted?(loc)
43 |     loc['localization_key_is_deleted'] || false
44 |   end
45 | 
46 |   def update_timestamps
47 |     @source.assign_last_updated_at(fetch_last_change)
48 |     @source.sync_complete = true
49 |     @source.save!
50 |   end
51 | 
52 |   def fetch_last_change
53 |     interactor.send_request(Lit::Source::LAST_CHANGE_PATH)['last_change']
54 |   end
55 | 
56 |   def interactor
57 |     RemoteInteractorService.new(@source)
58 |   end
59 | end
60 | 


--------------------------------------------------------------------------------
/app/views/kaminari/lit/_first_page.html.erb:
--------------------------------------------------------------------------------
1 | <% unless current_page.first? %>
2 |   <li class="first">
3 |     <%= link_to_unless current_page.first?, raw(t('views.pagination.first')), url, :remote => remote %>
4 |   </li>
5 | <% end %>
6 | 


--------------------------------------------------------------------------------
/app/views/kaminari/lit/_gap.html.erb:
--------------------------------------------------------------------------------
1 | <li class="page gap disabled">
2 |   <a href="#" onclick="return false;"><%= raw I18n.t('views.pagination.truncate') %></a>
3 | </li>
4 | 


--------------------------------------------------------------------------------
/app/views/kaminari/lit/_last_page.html.erb:
--------------------------------------------------------------------------------
1 | <% unless current_page.last? %>
2 |   <li class="last next">
3 |     <%= link_to_unless current_page.last?, raw(t('views.pagination.last')), url, {:remote => remote} %>
4 |   </li>
5 | <% end %>
6 | 
7 | 


--------------------------------------------------------------------------------
/app/views/kaminari/lit/_next_page.html.erb:
--------------------------------------------------------------------------------
1 | <% unless current_page.last? %>
2 |   <li class="next_page">
3 |     <%= link_to_unless current_page.last?, raw(t('views.pagination.next')), url, :rel => 'next', :remote => remote %>
4 |   </li>
5 | <% end %>
6 | 


--------------------------------------------------------------------------------
/app/views/kaminari/lit/_page.html.erb:
--------------------------------------------------------------------------------
1 | <li class="page <%= "active" if page.current? %>">
2 |   <%= link_to page, url, opts = {:remote => remote, :rel => page.next? ? 'next' : page.prev? ? 'prev' : nil} %>
3 | </li>
4 | 


--------------------------------------------------------------------------------
/app/views/kaminari/lit/_paginator.html.erb:
--------------------------------------------------------------------------------
 1 | <%= paginator.render do %>
 2 |   <div>
 3 |     <ul class="pagination">
 4 |       <%= first_page_tag unless current_page.first? %>
 5 |       <%= prev_page_tag unless current_page.first? %>
 6 |       <% each_page do |page| %>
 7 |         <% if page.left_outer? || page.right_outer? || page.inside_window? %>
 8 |           <%= page_tag page %>
 9 |         <% elsif !page.was_truncated? %>
10 |           <%= gap_tag %>
11 |         <% end %>
12 |       <% end %>
13 |       <%= next_page_tag unless current_page.last? %>
14 |       <%= last_page_tag unless current_page.last? %>
15 |     </ul>
16 |   </div>
17 | <% end %>
18 | 


--------------------------------------------------------------------------------
/app/views/kaminari/lit/_prev_page.html.erb:
--------------------------------------------------------------------------------
1 | <% unless current_page.first? %>
2 |   <li class="prev">
3 |     <%= link_to_unless current_page.first?, raw(t('views.pagination.previous')), url, :rel => 'prev', :remote => remote %>
4 |   </li>
5 | <% end %>
6 | 


--------------------------------------------------------------------------------
/app/views/layouts/lit/_messages.html.erb:
--------------------------------------------------------------------------------
1 | <% flash.each do |name, msg| %>
2 |   <div class="alert alert-<%= "#{name == :notice ? "success" : "error"}" %>">
3 |     <a class="close" data-dismiss="alert">×</a>
4 |     <%= content_tag :div, msg, :id => "flash_#{name}" if msg.is_a?(String) %>
5 |   </div>
6 | <% end %>
7 | 


--------------------------------------------------------------------------------
/app/views/layouts/lit/_navigation.html.erb:
--------------------------------------------------------------------------------
 1 | <div class="navbar-header">
 2 |   <button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1">
 3 |     <span class="sr-only">Toggle navigation</span>
 4 |     <span class="icon-bar"></span>
 5 |     <span class="icon-bar"></span>
 6 |     <span class="icon-bar"></span>
 7 |   </button>
 8 |   <%= link_to "Lost in translation", root_path, :class=>'navbar-brand' %>
 9 | </div>
10 | <div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
11 |   <ul class="nav navbar-nav">
12 |     <li><%= link_to "Translate!", lit.not_translated_localization_keys_path %></li>
13 |     <li><%= link_to "Synchronize", lit.sources_path %></li>
14 |     <li class="dropdown">
15 |       <a href="#" class="dropdown-toggle" data-toggle="dropdown">
16 |         Settings
17 |         <b class="caret"></b>
18 |       </a>
19 |       <ul class="dropdown-menu">
20 |         <li><%= link_to "Locales", lit.locales_path %></li>
21 |       </ul>
22 |     </li>
23 |   </ul>
24 | 


--------------------------------------------------------------------------------
/app/views/layouts/lit/application.html.erb:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |   <head>
 4 |     <title>Lost in translation</title>
 5 |     <meta charset="utf-8" />
 6 |     <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
 7 |     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1" />
 8 |     <%= stylesheet_link_tag    '//netdna.bootstrapcdn.com/bootstrap/3.0.3/css/bootstrap.min.css', media: 'all' %>
 9 |     <%= stylesheet_link_tag    '//netdna.bootstrapcdn.com/font-awesome/4.0.3/css/font-awesome.min.css', media: 'all' %>
10 |     <%= stylesheet_link_tag    '//netdna.bootstrapcdn.com/bootswatch/3.0.3/yeti/bootstrap.min.css', media: 'all' %>
11 |     <%= stylesheet_link_tag    'lit/application', media: 'all' %>
12 |     <%= javascript_include_tag 'lit/application' %>
13 |     <%= csrf_meta_tags %>
14 |   </head>
15 |   <body class="<%= params[:controller] %>">
16 |     <nav class="navbar navbar-default" role="navigation">
17 |       <%= render 'layouts/lit/navigation' %>
18 |     </nav>
19 |     <div id="main" class="container <%= params[:action] %>" role="main">
20 |       <div class="row">
21 |         <% if content_for?(:sidebar) %>
22 |           <div class="col-lg-3 col-xs-12 col-sm-3 col-md-3">
23 |             <%= yield(:sidebar) %>
24 |           </div>
25 |           <div class="col-lg-9 col-xs-12 col-sm-9 col-md-9">
26 |             <%= render 'layouts/lit/messages' %>
27 |             <%= yield %>
28 |           </div>
29 |         <% else %>
30 |           <div class="col-lg-12 col-xs-12 col-sm-12 col-md-12">
31 |             <%= render 'layouts/lit/messages' %>
32 |             <%= yield %>
33 |           </div>
34 |         <% end %>
35 |       </div>
36 |       <footer>
37 |         <hr/>
38 |         <p>
39 |           Brought to you by
40 |           <a href="http://prograils.com/" target="_blank">Prograils.com</a>
41 |         </p>
42 |       </footer>
43 |     </div>
44 |   </body>
45 | </html>
46 | 


--------------------------------------------------------------------------------
/app/views/lit/cloud_translations/show.js.erb:
--------------------------------------------------------------------------------
 1 | <% if @translated_text.is_a?(String) %>
 2 |   $('.localization_row[data-id="<%= @target_localization.id %>"] textarea').val("<%= j @translated_text %>");
 3 | <% elsif @translated_text.is_a?(Array) %>
 4 |   $inputs = $('.localization_row[data-id="<%= @target_localization.id %>"] input[type=text]');
 5 |   var translated_elements = JSON.parse("<%= j @translated_text.to_json.html_safe %>");
 6 |   for (i in $inputs.toArray()) {
 7 |     $input = $($inputs[i]);
 8 |     $input.val(translated_elements[i]);
 9 |   }
10 | <% elsif @error_message.present? %>
11 |   alert("<%= j @error_message %>")
12 | <% else %>
13 |   alert("An unknown error has occurred while translating.")
14 | <% end %>
15 | 


--------------------------------------------------------------------------------
/app/views/lit/dashboard/index.html.erb:
--------------------------------------------------------------------------------
1 | <strong>All localization keys</strong> <%= Lit::LocalizationKey.active.count(:id) %><br/>
2 | <% @locales.each do |l| %>
3 |   <strong><%= EmojiFlag.new(l.locale) %> <%= I18n.t("lit.locale_to_languages.#{l.locale}", :default=>l.locale) %>:</strong> <span title="<%= "#{l.changed_localizations_count}/#{l.all_localizations_count}" %>"><%= l.translated_percentage %>%</span><br/>
4 | <% end %>
5 | 
6 | 


--------------------------------------------------------------------------------
/app/views/lit/incomming_localizations/accept.js.erb:
--------------------------------------------------------------------------------
1 | $('table.incomming-localizations-table tr[data-id="<%= @incomming_localization.id %>"]').remove();
2 | 
3 | 


--------------------------------------------------------------------------------
/app/views/lit/incomming_localizations/destroy.js.erb:
--------------------------------------------------------------------------------
1 | $('table.incomming-localizations-table tr[data-id="<%= @incomming_localization.id %>"]').remove();
2 | 


--------------------------------------------------------------------------------
/app/views/lit/incomming_localizations/index.html.erb:
--------------------------------------------------------------------------------
 1 | <h1>Incomming localizations</h1>
 2 | <input type="hidden" id="source_id" value="<%= @source.id %>">
 3 | <div class="container">
 4 |   <div class="row inline-headers">
 5 |     <h4 class="<%= source_loading_class(@source) %>">Synchronization in progress, please wait. The page will refresh automatically when done.</h2>
 6 |     <span class="pull-right">
 7 |       <%= link_to accept_all_source_incomming_localizations_path(@source), :class=>"btn btn-success btn-sm", :data=>{:confirm=>t('lit.common.you_sure', :default=>"Are you sure?")} do %>
 8 |         <%= I18n.t('lit.common.accept_all', :default=>"Accept all") %>
 9 |       <% end %>
10 |       <%= link_to reject_all_source_incomming_localizations_path(@source), :class=>"btn btn-danger btn-sm", :method=>:post, :data=>{:confirm=>t('lit.common.you_sure', :default=>"Are you sure?")} do %>
11 |         <%= I18n.t('lit.common.reject_all', :default=>"Reject all") %>
12 |       <% end %>
13 |     </span>
14 |   </div>
15 | </div>
16 | 
17 | 
18 | <table class="table table-bordered table-striped incomming-localizations-table">
19 |   <tr>
20 |     <th>Current value</th>
21 |     <th>Imported value</th>
22 |     <th>Is deleted</th>
23 |     <th width="200px"></th>
24 |   </tr>
25 |   <% @incomming_localizations.each do |il| %>
26 |     <tr data-id="<%= il.id %>">
27 |       <td colspan="3">
28 |         <%= image_tag EmojiFlag.new(il.locale_str) %>
29 |         <strong><%= il.full_key %></strong>
30 |       </td>
31 |     </tr>
32 |     <tr data-id="<%= il.id %>">
33 |       <td>
34 |         <% if il.localization %>
35 |           <%= render partial: '/lit/localization_keys/localization_row', locals: {localization: il.localization.translation} %>
36 |         <% end %>
37 |       </td>
38 |       <td>
39 |         <%= render partial: '/lit/localization_keys/localization_row', locals: {localization: il.translation} %>
40 |       </td>
41 |       <td>
42 |         <%= il.localization_key_is_deleted %>
43 |       </td>
44 |       <td>
45 |         <%= link_to accept_source_incomming_localization_path(@source, il, format: :js), class: 'btn btn-success btn-sm', remote: true do %>
46 |           <%= draw_icon 'check', class: 'icon-white' %>
47 |           <%= I18n.t('lit.common.accept', default: 'Accept') %>
48 |         <% end %>
49 |         <%= link_to source_incomming_localization_path(@source, il, format: :js), class: 'btn btn-danger btn-sm', remote: true, method: :delete, data: {confirm: I18n.t('lit.common.you_sure', default: 'Are you sure?')} do %>
50 |           <%= draw_icon 'times', class: "icon-white" %>
51 |           <%= I18n.t('lit.common.reject', :default=>"Reject") %>
52 |         <% end %>
53 |       </td>
54 |     </tr>
55 |   <% end %>
56 | </table>
57 | 


--------------------------------------------------------------------------------
/app/views/lit/locales/_hide_link.html.erb:
--------------------------------------------------------------------------------
1 | <%= link_to locale.is_hidden? ? 'Show' : 'Hide', hide_locale_path(locale), :method=>:put, :remote=>true %>
2 | 


--------------------------------------------------------------------------------
/app/views/lit/locales/hide.js.erb:
--------------------------------------------------------------------------------
1 | $('#hide_link_<%= @locale.id %>').html("<%= j render(:partial=>"hide_link", :locals=>{:locale=>@locale}) %>");
2 | 


--------------------------------------------------------------------------------
/app/views/lit/locales/index.html.erb:
--------------------------------------------------------------------------------
 1 | <h1>Listing locales</h1>
 2 | 
 3 | <table class="table table-stripped">
 4 |   <tr>
 5 |     <th>Locale</th>
 6 |     <th width="130">Options</th>
 7 |   </tr>
 8 | 
 9 | <% @locales.each do |locale| %>
10 |   <tr>
11 |     <td><%= locale %></td>
12 |     <td>
13 |       <span id="hide_link_<%= locale.id %>"><%= render :partial=>"hide_link", :locals=>{:locale=>locale} %></span>
14 |       <%= link_to 'Destroy', locale, method: :delete, data: { confirm: 'Are you sure?' } %>
15 |     </td>
16 |   </tr>
17 | <% end %>
18 | </table>
19 | 
20 | 
21 | 


--------------------------------------------------------------------------------
/app/views/lit/localization_keys/_localization_row.html.erb:
--------------------------------------------------------------------------------
 1 | <% if localization.is_a?(Array) %>
 2 |   <ul>
 3 |     <% localization.each do |l| %>
 4 |       <li><%= l %></li>
 5 |     <% end %>
 6 |   </ul>
 7 | <% else %>
 8 |   <% if localization.nil? %>
 9 |     <em title="<%= I18n.t('lit.value_not_yet_translated', default: 'Value not yet translated') %>">null</em>
10 |   <% else %>
11 |     <%= localization %>
12 |   <% end %>
13 | <% end %>
14 | 
15 | 


--------------------------------------------------------------------------------
/app/views/lit/localization_keys/_sidebar.html.erb:
--------------------------------------------------------------------------------
 1 | <% content_for(:sidebar) do %>
 2 |   <div class="well">
 3 |     <%= form_tag '', :class=>"form-search", :method=>:get do |f| %>
 4 |       <% if @search_options.has_key?(:key_prefix) %>
 5 |         <%= hidden_field_tag :key_prefix, @search_options[:key_prefix] %>
 6 |       <% end %>
 7 |       <div class="input-group">
 8 |         <%= text_field_tag :key, @search_options[:key], :class=>"form-control search-query" %>
 9 |         <div class="input-group-btn">
10 |           <button type="submit" class="btn btn-default"><%= draw_icon 'search' %></button>
11 |         </div>
12 |       </div>
13 |     <% end %>
14 |     <ul class="nav nav-pills nav-stacked">
15 |       <li class="<%= "active" if params[:action]=='not_translated' %>">
16 |         <%= link_to lit.not_translated_localization_keys_path do -%>
17 |           <%= draw_icon 'pencil' %>
18 |           not translated
19 |         <% end %>
20 |       </li>
21 |       <li class="<%= "active" if params[:action]=='index' %>">
22 |         <%= link_to lit.localization_keys_path do -%>
23 |           <%= draw_icon 'list' %>
24 |           all
25 |         <% end %>
26 |       </li>
27 |       <li class="<%= "active" if params[:action]=='starred' %>">
28 |         <%= link_to lit.starred_localization_keys_path do -%>
29 |           <%= draw_icon 'star' %>
30 |           starred
31 |         <% end %>
32 |       </li>
33 |       <li class="<%= "active" if params[:action]=='visited_again' %>">
34 |         <%= link_to lit.visited_again_localization_keys_path do -%>
35 |           <%= draw_icon 'undo' %>
36 |           deleted and visited again
37 |         <% end %>
38 |       </li>
39 |       <li class="nav-header"><%= I18n.t(".order_by", :default => "Order by") %>:</li>
40 |       <% Lit::LocalizationKey.order_options.each do |order| %>
41 |         <li class="<%= "active" if order == @search_options[:order]  %>">
42 |           <%= link_to url_for(@search_options.merge(:order => order)) do %>
43 |             <%= I18n.t("lit.order_options.#{order.gsub(" ", "_")}", :default => order.humanize) %>
44 |           <% end %>
45 |         </li>
46 |       <% end %>
47 |       <li class="nav-header">Narrow with prefix</li>
48 |       <% if @search_options[:key_prefix].present? %>
49 |         <li>
50 |           <%= link_to url_for(@search_options.merge(:key_prefix=>@parent_prefix.present? ? @parent_prefix : nil)), :title=>(@parent_prefix.present? ? @parent_prefix : 'show all') do %>
51 |             <%= draw_icon('chevron-left') %>
52 |             <%= @parent_prefix.present? ? @parent_prefix.split('.').last : 'show all' %>
53 |           <% end %>
54 |         </li>
55 |       <% end %>
56 |       <% @prefixes.each do |p| %>
57 |         <li class="key_prefix">
58 |         <%= link_to url_for(@search_options.merge(:key_prefix=>p)) do %>
59 |           <%= draw_icon('chevron-right') %>
60 |           <%=  p.split('.').last %>
61 |         <% end %>
62 |         </li>
63 |       <% end %>
64 |     </ul>
65 |   </div>
66 | <% end %>
67 | 


--------------------------------------------------------------------------------
/app/views/lit/localization_keys/batch_touch.js.erb:
--------------------------------------------------------------------------------
1 | alert('All of search results have been marked as updated now, please retry synchronizing now');
2 | 


--------------------------------------------------------------------------------
/app/views/lit/localization_keys/change_completed.js.erb:
--------------------------------------------------------------------------------
1 | $('tr.localization_key_row[data-id="<%= @localization_key.id %>"] a.check_icon').html("<%= ejs(draw_icon(@localization_key.is_completed? ? 'check-circle' : 'check-circle-o')) %>");
2 | $('tr.localization_key_row[data-id="<%= @localization_key.id %>"] input[type=checkbox]').prop("checked", <%= @localization_key.is_completed? %>);
3 | 


--------------------------------------------------------------------------------
/app/views/lit/localization_keys/destroy.js.erb:
--------------------------------------------------------------------------------
1 | $('tr.localization_key_row[data-id="<%= @localization_key.id %>"]').fadeOut();


--------------------------------------------------------------------------------
/app/views/lit/localization_keys/index.html.erb:
--------------------------------------------------------------------------------
 1 | <h3><%= I18n.t('lit.header', default: 'Localization keys') %></h3>
 2 | 
 3 | <%= render 'localizations_list', available_locales: I18n.backend.available_locales %>
 4 | 
 5 | <% if defined?(Kaminari)  %>
 6 |   <%= paginate @localization_keys, :theme=>"lit" %>
 7 | <% elsif defined?(WillPaginate)  %>
 8 |   <%= will_paginate @localization_keys %>
 9 | <% end %>
10 | 
11 | <%= render 'sidebar' %>
12 | 


--------------------------------------------------------------------------------
/app/views/lit/localization_keys/not_translated.html.erb:
--------------------------------------------------------------------------------
 1 | <h3><%= I18n.t('lit.not_translated_header', default: 'Not translated localization keys') %></h3>
 2 | 
 3 | <%= render 'localizations_list', available_locales: I18n.backend.available_locales %>
 4 | 
 5 | <% if defined?(Kaminari)  %>
 6 |   <%= paginate @localization_keys, :theme=>"lit" %>
 7 | <% elsif defined?(WillPaginate)  %>
 8 |   <%= will_paginate @localization_keys %>
 9 | <% end %>
10 | 
11 | <%= render 'sidebar' %>
12 | 


--------------------------------------------------------------------------------
/app/views/lit/localization_keys/restore_deleted.js.erb:
--------------------------------------------------------------------------------
1 | $('tr.localization_key_row[data-id="<%= @localization_key.id %>"]').fadeOut();
2 | 


--------------------------------------------------------------------------------
/app/views/lit/localization_keys/star.js.erb:
--------------------------------------------------------------------------------
1 | $('tr.localization_key_row[data-id="<%= @localization_key.id %>"] a.star_icon').html("<%= ejs(draw_icon(@localization_key.is_starred? ? 'star' : 'star-o')) %>");
2 | 


--------------------------------------------------------------------------------
/app/views/lit/localization_keys/visited_again.html.erb:
--------------------------------------------------------------------------------
 1 | <h3><%= I18n.t('lit.visited_again_header', default: 'Deleted and visited again localization keys') %></h3>
 2 | 
 3 | <%= render 'localizations_list', available_locales: I18n.backend.available_locales %>
 4 | 
 5 | <% if defined?(Kaminari)  %>
 6 |   <%= paginate @localization_keys, :theme=>"lit" %>
 7 | <% elsif defined?(WillPaginate)  %>
 8 |   <%= will_paginate @localization_keys %>
 9 | <% end %>
10 | 
11 | 
12 | <%= render 'sidebar' %>
13 | 


--------------------------------------------------------------------------------
/app/views/lit/localizations/_form.html.erb:
--------------------------------------------------------------------------------
 1 | <%= form_for @localization, url: lit.localization_key_localization_path(@localization_key, @localization, format: :js), html: {remote: true} do |f| %>
 2 |   <%- f.label :translated_value %>
 3 |   <% if @localization.translated_value.is_a?(Array) %>
 4 |     <ul style="list-style: none;">
 5 |       <% @localization.translated_value.each do |l| %>
 6 |         <li><%= text_field_tag 'localization[translated_value][]', l, class: 'form-control input-xlarge' %></li>
 7 |       <% end %>
 8 |     </ul>
 9 |   <% else %>
10 |     <%= f.text_area :translated_value, size: '40x2', class: 'form-control input-xxlarge' %>
11 |     <% if allow_wysiwyg_editor?(@localization_key.localization_key) %>
12 |       <br />
13 |       <label>
14 |         <input type="checkbox" class="wysiwyg_switch" /> use wysiwyg editor
15 |       </label>
16 |       <br />
17 |     <% end %>
18 |   <% end %>
19 | 
20 |   <button class="btn btn-primary btn-sm" type="submit"><%= I18n.t('lit.common.update', default: "Update") %></button>
21 |   <button class="btn btn-default btn-sm cancel" type="reset"><%= I18n.t('lit.common.cancel', default: 'Cancel') %></button>
22 | 
23 |   <% if Lit::CloudTranslation.provider %>
24 |     <div class="btn-group pull-right">
25 |       <%= link_to "Translate using #{Lit::CloudTranslation.provider.name.demodulize}", cloud_translation_path(from: I18n.default_locale, localization_id: @localization.id), remote: true, class: 'btn btn-sm btn-default' %>
26 |       <button class="btn btn-sm dropdown-toggle" data-toggle="dropdown">
27 |         <span class="caret"></span>
28 |         <span class="sr-only">Source languages</span>
29 |       </button>
30 |       <ul class="dropdown-menu">
31 |         <li>
32 |           <a>Translate from:</a>
33 |         </li>
34 |         <li role="separator" class="divider"></li>
35 |         <% (available_locales_with_default_first + [:auto]).each_with_index do |source_locale, i| %>
36 |           <li>
37 |             <%= link_to cloud_translation_path(from: source_locale, localization_id: @localization.id), remote: true do %>
38 |               <% if i == 0 %>
39 |                 <strong><%= source_locale.to_s %></strong>
40 |               <% else %>
41 |                 <%= source_locale.to_s %>
42 |               <% end %>
43 |             <% end %>
44 |           </li>
45 |         <% end %>
46 |       </ul>
47 |     </div>
48 |   <% end %>
49 | <% end %>
50 | 
51 | 


--------------------------------------------------------------------------------
/app/views/lit/localizations/_previous_versions_rows.html.erb:
--------------------------------------------------------------------------------
 1 | <span class="pull-right"><%= draw_icon 'times', :class=>"close_versions" %></span>
 2 | <table class="table table-condensed">
 3 |   <tr>
 4 |     <th><%= I18n.t('lit.common.previous_versions') %></th>
 5 |     <th width="25%"><%= I18n.t('lit.common.changed_at') %></th>
 6 |   </tr>
 7 |   <% @versions.each do |v| %>
 8 |     <tr>
 9 |       <td>
10 |         <%= render :partial=>"/lit/localization_keys/localization_row", formats: ['html'], :locals=>{:localization=>v.translated_value} %>
11 |       </td>
12 |       <td><%= I18n.l v.created_at, format: :long %></td>
13 |     </tr>
14 |   <% end %>
15 | </table>
16 | 


--------------------------------------------------------------------------------
/app/views/lit/localizations/change_completed.js.erb:
--------------------------------------------------------------------------------
1 | var input = $('a.change_completed_<%= @localization.id %> input[type=checkbox]');
2 | input.prop("checked", !input.prop("checked"));
3 | 


--------------------------------------------------------------------------------
/app/views/lit/localizations/edit.js.erb:
--------------------------------------------------------------------------------
1 | var $row = $('td.localization_row[data-id="<%= @localization.id %>"]');
2 | $row.data('editing', 1);
3 | $row.html("<%= ejs render(partial: 'form', formats: ['html']) %>");
4 | $row.find('textarea').focus();
5 | <% if @localization.full_key.ends_with?('_html') -%>
6 |   $row.find('.wysiwyg_switch').click();
7 | <% end %>
8 | 


--------------------------------------------------------------------------------
/app/views/lit/localizations/previous_versions.js.erb:
--------------------------------------------------------------------------------
1 | var row = $('.localization_versions_row[data-id="<%= @localization.id %>"]');
2 | row.removeClass('hidden');
3 | row.children('td').html("<%= j render(:partial=>'previous_versions_rows', formats: ['html'], :locals=>{:localization=>@localization, :versions=>@versions}) %>");
4 | 


--------------------------------------------------------------------------------
/app/views/lit/localizations/update.js.erb:
--------------------------------------------------------------------------------
1 | var $row = $('td.localization_row[data-id="<%= @localization.id %>"]');
2 | $row.data('editing', 0);
3 | $row.html("<%= ejs render(:partial=>"/lit/localization_keys/localization_row", formats: ['html'], :locals=>{:localization=>@localization.translated_value }) %>");
4 | $row.siblings().find('.js-show_prev_versions').removeClass('hidden');
5 | $('a.change_completed_<%= @localization.id %> input[type=checkbox]').prop("checked", true);
6 | 
7 | 


--------------------------------------------------------------------------------
/app/views/lit/sources/_form.html.erb:
--------------------------------------------------------------------------------
 1 | <%= form_for(@source, :class=>"form-horizontal") do |f| %>
 2 |   <% if @source.errors.any? %>
 3 |     <div id="error_explanation">
 4 |       <h2><%= pluralize(@source.errors.count, "error") %> prohibited this source from being saved:</h2>
 5 | 
 6 |       <ul>
 7 |       <% @source.errors.full_messages.each do |msg| %>
 8 |         <li><%= msg %></li>
 9 |       <% end %>
10 |       </ul>
11 |     </div>
12 |   <% end %>
13 |   <div class="control-group">
14 |     <%= f.label :identifier, :class=>"control-label" %>
15 |     <div class="controls">
16 |       <%= f.text_field :identifier, :class=>"form-control" %>
17 |     </div>
18 |   </div>
19 |   <div class="control-group">
20 |     <%= f.label :url, :class=>"control-label" %>
21 |     <div class="controls">
22 |       <%= f.text_field :url, :placeholder=>"http://your_other_env.host/lit", :class=>"form-control" %>
23 |     </div>
24 |   </div>
25 |   <div class="control-group">
26 |     <%= f.label :api_key, :class=>"control-label" %>
27 |     <div class="controls">
28 |       <%= f.text_field :api_key, :class=>"form-control" %>
29 |     </div>
30 |   </div>
31 | 
32 |   <div class="actions">
33 |     <%= f.submit I18n.t('lit.common.save', :default => "Save"), :class=>"btn btn-primary btn-sm" %>
34 |   </div>
35 | <% end %>
36 | 


--------------------------------------------------------------------------------
/app/views/lit/sources/edit.html.erb:
--------------------------------------------------------------------------------
1 | <h1>Editing source</h1>
2 | 
3 | <%= render 'form' %>
4 | 
5 | <%= link_to 'Show', @source %> |
6 | <%= link_to 'Back', sources_path %>
7 | 


--------------------------------------------------------------------------------
/app/views/lit/sources/index.html.erb:
--------------------------------------------------------------------------------
 1 | <h1>Synchronization sources</h1>
 2 | 
 3 | <table class="table">
 4 |   <tr>
 5 |     <th>Identifier</th>
 6 |     <th>Last synchronization</th>
 7 |     <th>Last change (remote)</th>
 8 |     <th width="95px"></th>
 9 |   </tr>
10 | 
11 | <% @sources.each do |source| %>
12 |   <tr>
13 |     <td><%= link_to source.identifier, lit.source_path(source) %></td>
14 |     <td><%= source.last_updated_at.to_s(:db) unless source.last_updated_at.nil? %></td>
15 |     <td><%= source.last_change %></td>
16 |     <td>
17 |       <%= link_to lit.source_incomming_localizations_path(source), :title=>t('lit.common.browse_incomming', :default=>"Browse incomming localizations") do %>
18 |         <%= draw_icon 'search' %>
19 |       <% end %>
20 |       <%= link_to lit.synchronize_source_path(source), :title=>t('lit.common.synchronize', :default=>"Synchronize") do %>
21 |         <%= draw_icon 'refresh' %>
22 |       <% end %>
23 |       <%= link_to lit.source_path(source), :title=>t('lit.common.show', :default=>"Show") do %>
24 |         <%= draw_icon 'zoom-in' %>
25 |       <% end %>
26 |       <%= link_to lit.edit_source_path(source), :title=>t('lit.common.edit', :default=>"Edit") do %>
27 |         <%= draw_icon 'pencil' %>
28 |       <% end %>
29 |       <%= link_to lit.touch_source_path(source), :title=>t('lit.common.touch', :default=>"Touch (update) last_updated_at"), :method => :put, :data => { :confirm => 'Are you sure?' } do %>
30 |         <%= draw_icon 'clock-o' %>
31 |       <% end %>
32 |       <%= link_to lit.source_path(source), :method => :delete, :data => { :confirm => 'Are you sure?' }, :title=>t('lit.common.delete', :default=>"Delete") do %>
33 |         <%= draw_icon 'trash-o' %>
34 |       <% end %>
35 |     </td>
36 |   </tr>
37 | <% end %>
38 | </table>
39 | 
40 | <br />
41 | 
42 | <%= link_to 'New Source', new_source_path %>
43 | 


--------------------------------------------------------------------------------
/app/views/lit/sources/new.html.erb:
--------------------------------------------------------------------------------
1 | <h1>New source</h1>
2 | 
3 | <%= render 'form' %>
4 | 
5 | <%= link_to 'Back', sources_path %>
6 | 


--------------------------------------------------------------------------------
/app/views/lit/sources/show.html.erb:
--------------------------------------------------------------------------------
 1 | <p id="notice"><%= notice %></p>
 2 | 
 3 | <strong>Indetifier:</strong>
 4 | <%= @source.identifier %>
 5 | <br/>
 6 | <strong>Url:</strong>
 7 | <%= @source.url %>
 8 | <br/>
 9 | <strong>API key:</strong>
10 | <%= @source.api_key %>
11 | <br/>
12 | <strong>Last updated at:</strong>
13 | <%= @source.last_updated_at.to_s(:db) unless @source.last_updated_at.nil? %>
14 | <%= link_to '(touch!)', touch_source_path(@source), :method => :put, :data => { :confirm => 'Are you sure?' } %>
15 | <br/>
16 | 
17 | 
18 | <%= link_to 'Edit', edit_source_path(@source) %> |
19 | <%= link_to 'Back', sources_path %>
20 | 


--------------------------------------------------------------------------------
/config/routes.rb:
--------------------------------------------------------------------------------
 1 | Lit::Engine.routes.draw do
 2 |   if Lit.api_enabled
 3 |     namespace :api do
 4 |       namespace :v1 do
 5 |         get '/last_change' => 'localizations#last_change'
 6 |         resources :locales, only: [:index]
 7 |         resources :localization_keys, only: [:index]
 8 |         resources :localizations, only: [:index] do
 9 |           get 'last_change', on: :collection
10 |         end
11 |       end
12 |     end
13 |   end
14 |   resources :locales, only: [:index, :destroy] do
15 |     put :hide, on: :member
16 |   end
17 |   resources :localization_keys, only: [:index, :destroy] do
18 |     member do
19 |       get :star
20 |       put :change_completed
21 |       put :restore_deleted
22 |     end
23 |     collection do
24 |       get :starred
25 |       get :find_localization
26 |       get :not_translated
27 |       get :visited_again
28 |       post :batch_touch
29 |     end
30 |     resources :localizations, only: [:edit, :update, :show] do
31 |       member do
32 |         put :change_completed
33 |         get :previous_versions
34 |       end
35 |     end
36 |   end
37 |   resources :sources do
38 |     member do
39 |       get :synchronize
40 |       get :sync_complete
41 |       put :touch
42 |     end
43 |     resources :incomming_localizations, only: [:index, :destroy] do
44 |       member do
45 |         get :accept
46 |       end
47 |       collection do
48 |         get :accept_all
49 |         post :reject_all
50 |       end
51 |     end
52 |   end
53 | 
54 |   resource :cloud_translation, only: :show
55 | 
56 |   root to: 'dashboard#index'
57 | end
58 | 


--------------------------------------------------------------------------------
/db/migrate/20180101010101_lit_create_lit_locales.rb:
--------------------------------------------------------------------------------
 1 | class LitCreateLitLocales < Rails::VERSION::MAJOR >= 5   ?
 2 |                             ActiveRecord::Migration[4.2] :
 3 |                             ActiveRecord::Migration
 4 |   def up
 5 |     return if table_exists?(:lit_locales)
 6 |     create_table :lit_locales do |t|
 7 |       t.string :locale
 8 | 
 9 |       t.timestamps
10 |     end
11 |   end
12 | 
13 |   def down
14 |     drop_table :lit_locales
15 |   end
16 | end
17 | 


--------------------------------------------------------------------------------
/db/migrate/20180101010102_lit_create_lit_localization_keys.rb:
--------------------------------------------------------------------------------
 1 | class LitCreateLitLocalizationKeys < Rails::VERSION::MAJOR >= 5   ?
 2 |                                      ActiveRecord::Migration[4.2] :
 3 |                                      ActiveRecord::Migration
 4 |   def up
 5 |     return if table_exists?(:lit_localization_keys)
 6 |     create_table :lit_localization_keys do |t|
 7 |       t.string :localization_key
 8 | 
 9 |       t.timestamps
10 |     end
11 |     add_index :lit_localization_keys, :localization_key, unique: true
12 |   end
13 | 
14 |   def down
15 |     remove_index :lit_localization_keys, :localization_key
16 |     drop_table :lit_localization_keys
17 |   end
18 | end
19 | 


--------------------------------------------------------------------------------
/db/migrate/20180101010103_lit_create_lit_localizations.rb:
--------------------------------------------------------------------------------
 1 | class LitCreateLitLocalizations < Rails::VERSION::MAJOR >= 5   ?
 2 |                                   ActiveRecord::Migration[4.2] :
 3 |                                   ActiveRecord::Migration
 4 |   def up
 5 |     return if table_exists?(:lit_localizations)
 6 |     create_table :lit_localizations do |t|
 7 |       t.integer :locale_id
 8 |       t.integer :localization_key_id
 9 |       t.text :default_value
10 |       t.text :translated_value
11 |       t.boolean :is_changed, default: false
12 | 
13 |       t.timestamps
14 |     end
15 | 
16 |     add_index :lit_localizations, :locale_id
17 |     add_index :lit_localizations, :localization_key_id
18 |   end
19 | 
20 |   def down
21 |     remove_index :lit_localizations, :locale_id
22 |     remove_index :lit_localizations, :localization_key_id
23 |   end
24 | end
25 | 


--------------------------------------------------------------------------------
/db/migrate/20180101010104_lit_add_is_completed_and_is_starred_to_localization_keys.rb:
--------------------------------------------------------------------------------
 1 | class LitAddIsCompletedAndIsStarredToLocalizationKeys < Rails::VERSION::MAJOR >= 5   ?
 2 |                                                         ActiveRecord::Migration[4.2] :
 3 |                                                         ActiveRecord::Migration
 4 |   def up
 5 |     unless column_exists?(:lit_localization_keys, :is_completed)
 6 |       add_column :lit_localization_keys, :is_completed, :boolean, default: false
 7 |     end
 8 |     unless column_exists?(:lit_localization_keys, :is_starred)
 9 |       add_column :lit_localization_keys, :is_starred, :boolean, default: false
10 |     end
11 |   end
12 | 
13 |   def down
14 |     remove_column :lit_localization_keys, :is_completed
15 |     remove_column :lit_localization_keys, :is_starred
16 |   end
17 | end
18 | 


--------------------------------------------------------------------------------
/db/migrate/20180101010105_lit_add_is_hidden_to_locales.rb:
--------------------------------------------------------------------------------
 1 | class LitAddIsHiddenToLocales < Rails::VERSION::MAJOR >= 5   ?
 2 |                                 ActiveRecord::Migration[4.2] :
 3 |                                 ActiveRecord::Migration
 4 |   def up
 5 |     return if column_exists?(:lit_locales, :is_hidden)
 6 |     add_column :lit_locales, :is_hidden, :boolean, default: false
 7 |   end
 8 | 
 9 |   def down
10 |     remove_column :lit_locales, :is_hidden
11 |   end
12 | end
13 | 


--------------------------------------------------------------------------------
/db/migrate/20180101010106_lit_create_lit_localization_versions.rb:
--------------------------------------------------------------------------------
 1 | class LitCreateLitLocalizationVersions < Rails::VERSION::MAJOR >= 5   ?
 2 |                                          ActiveRecord::Migration[4.2] :
 3 |                                          ActiveRecord::Migration
 4 |   def up
 5 |     return if table_exists?(:lit_localization_versions)
 6 |     create_table :lit_localization_versions do |t|
 7 |       t.text :translated_value
 8 |       t.integer :localization_id
 9 | 
10 |       t.timestamps
11 |     end
12 | 
13 |     add_index :lit_localization_versions, :localization_id
14 |   end
15 | 
16 |   def down
17 |     remove_index :lit_localization_versions, :localization_id
18 |     drop_table :lit_localization_versions
19 |   end
20 | end
21 | 


--------------------------------------------------------------------------------
/db/migrate/20180101010107_lit_create_lit_sources.rb:
--------------------------------------------------------------------------------
 1 | class LitCreateLitSources < Rails::VERSION::MAJOR >= 5   ?
 2 |                             ActiveRecord::Migration[4.2] :
 3 |                             ActiveRecord::Migration
 4 |   def up
 5 |     return if table_exists?(:lit_sources)
 6 |     create_table :lit_sources do |t|
 7 |       t.string :identifier
 8 |       t.string :url
 9 |       t.string :api_key
10 |       t.datetime :last_updated_at
11 | 
12 |       t.timestamps
13 |     end
14 |   end
15 | 
16 |   def down
17 |     drop_table :lit_sources
18 |   end
19 | end
20 | 


--------------------------------------------------------------------------------
/db/migrate/20180101010108_lit_create_lit_incomming_localizations.rb:
--------------------------------------------------------------------------------
 1 | class LitCreateLitIncommingLocalizations < Rails::VERSION::MAJOR >= 5  ?
 2 |                                           ActiveRecord::Migration[4.2] :
 3 |                                           ActiveRecord::Migration
 4 |   def up
 5 |     return if table_exists?(:lit_incomming_localizations)
 6 |     create_table :lit_incomming_localizations do |t|
 7 |       t.text :translated_value
 8 |       t.integer :locale_id
 9 |       t.integer :localization_key_id
10 |       t.integer :localization_id
11 |       t.string :locale_str
12 |       t.string :localization_key_str
13 |       t.integer :source_id
14 |       t.integer :incomming_id
15 | 
16 |       t.timestamps
17 |     end
18 | 
19 |     add_index :lit_incomming_localizations, :locale_id
20 |     add_index :lit_incomming_localizations, :localization_key_id
21 |     add_index :lit_incomming_localizations, :localization_id
22 |     add_index :lit_incomming_localizations, :source_id
23 |     add_index :lit_incomming_localizations, :incomming_id
24 |   end
25 | 
26 |   def down
27 |     remove_index :lit_incomming_localizations, :locale_id
28 |     remove_index :lit_incomming_localizations, :localization_key_id
29 |     remove_index :lit_incomming_localizations, :localization_id
30 |     remove_index :lit_incomming_localizations, :source_id
31 |     remove_index :lit_incomming_localizations, :incomming_id
32 |     drop_table :lit_incomming_localizations
33 |   end
34 | end
35 | 


--------------------------------------------------------------------------------
/db/migrate/20180101010109_lit_add_sync_complete_to_lit_sources.rb:
--------------------------------------------------------------------------------
 1 | class LitAddSyncCompleteToLitSources < Rails::VERSION::MAJOR >= 5   ?
 2 |                                        ActiveRecord::Migration[4.2] :
 3 |                                        ActiveRecord::Migration
 4 |   def up
 5 |     return if column_exists?(:lit_sources, :sync_complete)
 6 |     add_column :lit_sources, :sync_complete, :boolean
 7 |   end
 8 | 
 9 |   def down
10 |     remove_column :lit_sources, :sync_complete
11 |   end
12 | end
13 | 


--------------------------------------------------------------------------------
/db/migrate/20181017123839_lit_add_is_deleted_to_localization_keys.rb:
--------------------------------------------------------------------------------
1 | class LitAddIsDeletedToLocalizationKeys < Rails::VERSION::MAJOR >= 5   ?
2 |                                        ActiveRecord::Migration[4.2] :
3 |                                        ActiveRecord::Migration
4 |   def change
5 |     add_column :lit_localization_keys, :is_deleted, :boolean,
6 |                default: false, null: false
7 |   end
8 | end
9 | 


--------------------------------------------------------------------------------
/db/migrate/20181018075955_lit_add_localization_key_is_deleted_to_localization_keys.rb:
--------------------------------------------------------------------------------
1 | class LitAddLocalizationKeyIsDeletedToLocalizationKeys < Rails::VERSION::MAJOR >= 5   ?
2 |                                                       ActiveRecord::Migration[4.2] :
3 |                                                       ActiveRecord::Migration
4 |   def change
5 |     add_column :lit_incomming_localizations, :localization_key_is_deleted,
6 |                :boolean, null: false, default: false
7 |   end
8 | end
9 | 


--------------------------------------------------------------------------------
/db/migrate/20181030111522_lit_add_is_visited_again_to_localization_keys.rb:
--------------------------------------------------------------------------------
1 | class LitAddIsVisitedAgainToLocalizationKeys < Rails::VERSION::MAJOR >= 5   ?
2 |                                                ActiveRecord::Migration[4.2] :
3 |                                                ActiveRecord::Migration
4 |   def change
5 |     add_column :lit_localization_keys, :is_visited_again, :boolean,
6 |                null: false, default: false
7 |   end
8 | end
9 | 


--------------------------------------------------------------------------------
/db/migrate/20181129103819_lit_add_localization_key_locale_unique_index_to_localizations.rb:
--------------------------------------------------------------------------------
1 | class LitAddLocalizationKeyLocaleUniqueIndexToLocalizations < Rails::VERSION::MAJOR >= 5   ?
2 |                                                               ActiveRecord::Migration[4.2] :
3 |                                                               ActiveRecord::Migration
4 |   def change
5 |     add_index :lit_localizations, [:localization_key_id, :locale_id], unique: true
6 |   end
7 | end
8 | 


--------------------------------------------------------------------------------
/gemfiles/rails_5.2.gemfile:
--------------------------------------------------------------------------------
 1 | # This file was generated by Appraisal
 2 | 
 3 | source "https://rubygems.org"
 4 | 
 5 | gem "rails", "~> 5.2.0"
 6 | gem "devise"
 7 | gem "pg", "~> 1.2.3"
 8 | gem "redis"
 9 | gem "capybara"
10 | gem "database_cleaner"
11 | gem "test_declarative"
12 | gem "mocha"
13 | gem "webmock"
14 | gem "sass-rails"
15 | gem "jquery-rails"
16 | gem "coffee-rails"
17 | gem "pry-rails"
18 | gem "rails-controller-testing"
19 | gem "minitest"
20 | gem "m", "~> 1.5.0"
21 | gem "google-cloud-translate", "~> 1.2.4"
22 | 
23 | gemspec path: "../"
24 | 


--------------------------------------------------------------------------------
/gemfiles/rails_6.0.gemfile:
--------------------------------------------------------------------------------
 1 | # This file was generated by Appraisal
 2 | 
 3 | source "https://rubygems.org"
 4 | 
 5 | gem "rails", "~> 6.0.3"
 6 | gem "devise"
 7 | gem "pg", "~> 1.2.3"
 8 | gem "redis"
 9 | gem "capybara"
10 | gem "database_cleaner"
11 | gem "test_declarative"
12 | gem "mocha"
13 | gem "webmock"
14 | gem "sass-rails"
15 | gem "jquery-rails"
16 | gem "coffee-rails"
17 | gem "pry-rails"
18 | gem "rails-controller-testing"
19 | gem "minitest"
20 | gem "m", "~> 1.5.0"
21 | gem "google-cloud-translate", "~> 1.2.4"
22 | 
23 | gemspec path: "../"
24 | 


--------------------------------------------------------------------------------
/gemfiles/rails_6.1.gemfile:
--------------------------------------------------------------------------------
 1 | # This file was generated by Appraisal
 2 | 
 3 | source "https://rubygems.org"
 4 | 
 5 | gem "rails", "~> 6.1.4.1"
 6 | gem "devise"
 7 | gem "pg", "~> 1.2.3"
 8 | gem "redis"
 9 | gem "capybara"
10 | gem "database_cleaner"
11 | gem "test_declarative"
12 | gem "mocha"
13 | gem "webmock"
14 | gem "sass-rails"
15 | gem "jquery-rails"
16 | gem "coffee-rails"
17 | gem "pry-rails"
18 | gem "rails-controller-testing"
19 | gem "minitest"
20 | gem "m", "~> 1.5.0"
21 | gem "google-cloud-translate", "~> 2.1.2"
22 | 
23 | gemspec path: "../"
24 | 


--------------------------------------------------------------------------------
/lib/generators/lit/install/templates/initializer.erb:
--------------------------------------------------------------------------------
 1 | 
 2 | # Which authentication function to use (ie. :authenticate_user!)? When set to
 3 | # `nil` will let everyone in.
 4 | Lit.authentication_function = <%= @authentication_function || 'nil' %>
 5 | 
 6 | # Which authentication verification function to use (ie. :user_signed_in?)?
 7 | # This is used together with frontend translation module to determine, if
 8 | # helper button should be applied and translations wrapped in custom span
 9 | Lit.authentication_verification = <%= @authentication_verification || 'nil' %>
10 | 
11 | # Either 'redis' or 'hash'. Hash is the fastest, but will fail in multiprocess
12 | # environment
13 | Lit.key_value_engine = '<%= @key_value_engine %>'
14 | 
15 | # Redis URL to use when key_value_engine is 'redis'
16 | # When set to `nil`, it uses the REDIS_URL environment variable.
17 | # Lit.redis_url = 'redis://redis-server:6379/0'
18 | 
19 | # Pass extra options to key_value_neinge, ie. prefix for redis (only one
20 | # supported at the moment)
21 | # Lit.storage_options = { prefix: "my_project" }
22 | 
23 | # If true all translations are returned as html_safe strings
24 | Lit.all_translations_are_html_safe = false
25 | 
26 | # Translations without default will be humanized (default string will be added)
27 | # ie. scope.page_header will become "Page header"
28 | # If `false` then will serve nil instead (but translation will be wrapped in
29 | # <span title="translation missing string"></span>
30 | Lit.humanize_key = false
31 | 
32 | # If set to `false` will always parse yaml files upon startup and update cached
33 | # values with ones with yaml (but only, if those keys haven't been changed via
34 | # web ui before)
35 | Lit.ignore_yaml_on_startup = true
36 | 
37 | # Array of ignored keys or key prefixes
38 | Lit.ignored_keys = ['i18n.transliterate'].freeze
39 | 
40 | # API enabled? API allows third party browsing your translations, as well as
41 | # synchronizing them between environments
42 | Lit.api_enabled = false
43 | 
44 | # API key is required to authorize third party, if API is enabled
45 | Lit.api_key = '<%= @api_key %>'
46 | 
47 | # If true, last_updated_at column of synchronizaton source will be set to now
48 | # upon record creation
49 | Lit.set_last_updated_at_upon_creation = true
50 | 
51 | # Store request info - this will store in cache additional info about request
52 | # path that triggered translation key to be displayed / accessed
53 | # For more information please check the README.md
54 | Lit.store_request_info = false
55 | 
56 | # Store request keys - this will store all keys used to render a page. Useful
57 | # only when combined with Lit::RequestKeysStore concern to view those keys in
58 | # frontend
59 | Lit.store_request_keys = false
60 | 
61 | # Initialize lit
62 | Lit.init
63 | 
64 | 
65 | 


--------------------------------------------------------------------------------
/lib/generators/lit/install_generator.rb:
--------------------------------------------------------------------------------
 1 | require 'rails/generators'
 2 | module Lit
 3 |   module Generators
 4 |     class InstallGenerator < ::Rails::Generators::Base
 5 |       class_option 'key-value-engine', type: :string
 6 |       class_option 'authentication-function', type: :string
 7 |       class_option 'no-migrate', type: :boolean
 8 | 
 9 |       source_root File.expand_path('../install/templates', __FILE__)
10 | 
11 |       desc 'Automates Lit installation'
12 | 
13 |       def set_authentication_function
14 |         @authentication_function =
15 |           options['authentication-function'].presence ||
16 |             ask("What's the authentication function, ie. :authenticate_user! :").presence || nil
17 |       end
18 | 
19 |       def set_key_value_engine
20 |         @key_value_engine =
21 |           options['key-value-engine'].presence || ask("What's the key value engine? ([hash] OR redis):").presence ||
22 |             :hash
23 |       end
24 | 
25 |       def add_redis_dependency
26 |         if @key_value_engine == 'redis'
27 |           puts 'Adding redis dependency'
28 |           gem 'redis'
29 |           Bundler.with_clean_env { run 'bundle install' }
30 |         end
31 |       end
32 | 
33 |       def generate_api_key
34 |         @api_key = SecureRandom.base64 32
35 |       end
36 | 
37 |       def add_lit_initializer
38 |         path = "#{::Rails.root}/config/initializers/lit.rb"
39 |         if File.exist?(path)
40 |           puts 'Skipping config/initializers/lit.rb creation, file already exists!'
41 |         else
42 |           puts 'Adding lit initializer (config/initializers/lit.rb)...'
43 |           template 'initializer.erb', path
44 |         end
45 |       end
46 | 
47 |       def run_migrations
48 |         unless options['no-migrate']
49 |           puts 'Running rake db:migrate'
50 |           `rake db:migrate`
51 |         end
52 |       end
53 | 
54 |       def clear_cache
55 |         Lit.init.cache.reset
56 |       end
57 | 
58 |       def mount_engine
59 |         puts "Mounting Lit::Engine at \"/lit\" in config/routes.rb..."
60 |         route "mount Lit::Engine => '/lit'"
61 |       end
62 |     end
63 |   end
64 | end
65 | 


--------------------------------------------------------------------------------
/lib/lit/adapters.rb:
--------------------------------------------------------------------------------
1 | module Lit::Adapters
2 | end
3 | 


--------------------------------------------------------------------------------
/lib/lit/adapters/hash_storage.rb:
--------------------------------------------------------------------------------
 1 | module Lit::Adapters
 2 |   class HashStorage < Hash
 3 |     def incr(key)
 4 |       self[key] ||= 0
 5 |       if self[key].is_a?(Integer)
 6 |         self[key] += 1
 7 |       else
 8 |         subtree_keys(key).each { |k| self[k] += 1 }
 9 |       end
10 |     end
11 | 
12 |     def prefix
13 |       nil
14 |     end
15 | 
16 |     def [](key)
17 |       super || subtree_of_key(key)
18 |     end
19 | 
20 |     private
21 | 
22 |     def subtree_of_key(key)
23 |       keys_of_subtree = subtree_keys(key)
24 |       return nil if keys_of_subtree.empty?
25 | 
26 |       cache_localizations = form_cache_localizations(keys_of_subtree)
27 | 
28 |       full_subtree = Lit::Services::LocalizationKeysToHashService.call(cache_localizations)
29 |       requested_part = full_subtree.dig(*key.split('.'))
30 |       return nil if requested_part.blank?
31 |       return requested_part if requested_part.is_a?(String)
32 | 
33 |       requested_part.deep_transform_keys(&:to_sym)
34 |     end
35 | 
36 |     def subtree_keys(key)
37 |       keys.select { |k| k.match?(/\A#{Regexp.quote(key)}*/) }
38 |     end
39 | 
40 |     def form_cache_localizations(keys_of_subtree)
41 |       self_copy = self.select { |k, _| k.in?(keys_of_subtree) }
42 |       values_of_subtree = keys_of_subtree.map { |k| self_copy[k] }
43 |       Hash[keys_of_subtree.zip(values_of_subtree)]
44 |     end
45 |   end
46 | end
47 | 


--------------------------------------------------------------------------------
/lib/lit/cloud_translation.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | module Lit
 4 |   module CloudTranslation
 5 |     class TranslationError < StandardError; end
 6 | 
 7 |     module_function
 8 | 
 9 |     # Sets the provider for cloud translations.
10 |     # @param [Class] provider Selected translation provider,
11 |     #   descending from Lit::CloudTranslation::Providers::Base
12 |     def provider=(provider)
13 |       @provider = provider
14 |     end
15 | 
16 |     # Returns the currently active cloud translation provider,
17 |     # descending from Lit::CloudTranslation::Providers::Base.
18 |     def provider
19 |       @provider
20 |     end
21 | 
22 |     # Uses the active translation provider to translate a text or array of
23 |     # texts.
24 |     # @param [String, Array] text The text (or array of texts) to translate
25 |     # @param [Symbol, String] from The language to translate from. If not given,
26 |     #   auto-detection will be attempted.
27 |     # @param [Symbol, String] to The language to translate to.
28 |     # @param [Hash] opts Additional, provider-specific optional parameters.
29 |     def translate(text:, from: nil, to:, **opts)
30 |       provider.translate(text: text, from: from, to: to, **opts)
31 |     end
32 | 
33 |     # Optional if provider-speciffic environment variables are set correctly.
34 |     # Configures the cloud translation provider with specific settings,
35 |     # overriding those from environment if needed.
36 |     #
37 |     # @example
38 |     #   Lit::CloudTranslation.configure do |config|
39 |     #     # For Yandex, this overrides the YANDEX_TRANSLATE_API_KEY env
40 |     #     config.api_key = 'my_awesome_api_key'
41 |     #   end
42 |     def configure(&block)
43 |       unless provider
44 |         raise 'Translation provider not selected yet. Use `Lit::CloudTranslation' \
45 |               '.provider = PROVIDER_KLASS` before calling #configure.'
46 |       end
47 |       provider.tap do |p|
48 |         p.configure(&block)
49 |       end
50 |     end
51 |   end
52 | end    # descending from Lit::CloudTranslation::Providers::Base.
53 | 
54 | 


--------------------------------------------------------------------------------
/lib/lit/cloud_translation/providers/base.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | module Lit::CloudTranslation::Providers
 4 |   # Abstract base class for cloud translation providers, providing a skeleton
 5 |   # for the provider's functionality (mainly the #translate method) as well as
 6 |   # a configuration management mechanism.
 7 |   class Base
 8 |     attr_reader :config
 9 | 
10 |     def initialize(config)
11 |       default_config.each do |key, value|
12 |         config[key] ||= value
13 |       end
14 |       @config = config
15 |     end
16 | 
17 |     # Translates a given text from a given language to a different one.
18 |     # @param [String, Array] text The text (or array of texts) to translate
19 |     # @param [Symbol, String] from The language to translate from. If not given,
20 |     #   auto-detection will be attempted.
21 |     # @param [Symbol, String] to The language to translate to.
22 |     # @param [Hash] opts Additional, provider-specific optional parameters.
23 |     def translate(text:, from: nil, to:, **opts) # rubocop:disable Lint/UnusedMethodArgument, Metrics/LineLength
24 |       raise NotImplementedError
25 |     end
26 | 
27 |     private
28 | 
29 |     # Loads specific information from environment variables or other sources
30 |     # as the default configuartion for the translation provider.
31 |     #
32 |     # This can be overridden using `Lit::CloudTranslation.configure`.
33 |     def default_config
34 |       {}
35 |     end
36 | 
37 |     private_class_method :new
38 | 
39 |     class << self
40 |       # Using the provider object's singleton instance, translates a given text from
41 |       # a given language to a different one.
42 |       # @param [String, Array] text The text (or array of texts) to translate
43 |       # @param [Symbol, String] from The language to translate from. If not given,
44 |       #   auto-detection will be attempted.
45 |       # @param [Symbol, String] to The language to translate to.
46 |       # @param [Hash] opts Additional, provider-specific optional parameters.
47 |       def translate(text:, from: nil, to:, **opts)
48 |         instance.translate(text: text, from: from, to: to, **opts)
49 |       end
50 | 
51 |       def configure
52 |         yield config if block_given?
53 |       end
54 | 
55 |       private
56 | 
57 |       def instance
58 |         @instance ||= new(config)
59 |       end
60 | 
61 |       def config
62 |         @config ||= OpenStruct.new
63 |       end
64 |     end
65 |   end
66 | end
67 | 


--------------------------------------------------------------------------------
/lib/lit/cloud_translation/providers/yandex.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | require_relative 'base'
 4 | require 'net/http'
 5 | 
 6 | module Lit::CloudTranslation::Providers
 7 |   # Yandex Translate API provider for Lit translation suggestions.
 8 |   #
 9 |   # Configuration:
10 |   #
11 |   #   require 'lit/cloud_translation/providers/yandex'
12 |   #
13 |   #   Lit::CloudTranslation.provider = Lit::CloudTranslation::Providers::Yandeex
14 |   #
15 |   #   # API key can be given via ENV['YANDEX_TRANSLATE_API_KEY'].
16 |   #   #
17 |   #   # Alternatively, it can be set programmatically after setting provider:
18 |   #
19 |   #   Lit::CloudTranslation.configure do |config|
20 |   #     config.api_key = 'the_api_key'
21 |   #   end
22 |   class Yandex < Base
23 |     def translate(text:, from: nil, to:, **opts) # rubocop:disable Metrics/MethodLength, Metrics/LineLength
24 |       # puts "api key is: #{config.api_key}"
25 |       # puts "translating #{text} from #{from} to #{to}"
26 |       uri = URI('https://translate.yandex.net/api/v1.5/tr.json/translate')
27 |       params = {
28 |         key: config.api_key,
29 |         text: sanitize_text(text),
30 |         lang: [from, to].compact.join('-'),
31 |         format: opts[:format],
32 |         options: opts[:options]
33 |       }.compact
34 |       uri.query = URI.encode_www_form(params)
35 |       res = Net::HTTP.get_response(uri)
36 | 
37 |       unsanitize_text(
38 |         case res
39 |         when Net::HTTPOK
40 |           translations = JSON.parse(res.body)['text']
41 |           translations.size == 1 ? translations.first : translations
42 |         else
43 |           raise ::Lit::CloudTranslation::TranslationError,
44 |                 (JSON.parse(res.body)['message'] rescue "Unknown error: #{res.body}") # rubocop:disable Style/RescueModifier, Metrics/LineLength
45 |         end
46 |       )
47 |     end
48 | 
49 |     private
50 | 
51 |     def default_config
52 |       { api_key: ENV['YANDEX_TRANSLATE_API_KEY'] }
53 |     end
54 | 
55 |     def require_config!
56 |       return if config.api_key.present?
57 |       raise 'YANDEX_TRANSLATE_API_KEY env or `config.api_key` not given'
58 |     end
59 | 
60 |     def sanitize_text(text_or_array)
61 |       case text_or_array
62 |       when String
63 |         text_or_array.gsub(/%{(.+?)}/, '%{_LIT_\1_LIT_}')
64 |       when Array
65 |         text_or_array.map { |s| sanitize_text(s) }
66 |       when nil
67 |         ''
68 |       else
69 |         raise TypeError
70 |       end
71 |     end
72 | 
73 |     def unsanitize_text(text_or_array)
74 |       case text_or_array
75 |       when String
76 |         text_or_array.gsub(/%{_LIT_(.+?)_LIT_}/, '%{\1}')
77 |       when Array
78 |         text_or_array.map { |s| unsanitize_text(s) }
79 |       else
80 |         raise TypeError
81 |       end
82 |     end
83 |   end
84 | end
85 | 


--------------------------------------------------------------------------------
/lib/lit/engine.rb:
--------------------------------------------------------------------------------
 1 | module Lit
 2 |   class Engine < ::Rails::Engine
 3 |     require 'jquery-rails'
 4 | 
 5 |     config.autoload_paths += %W[#{Lit::Engine.root}/app/controllers/lit/concerns]
 6 | 
 7 |     paths.add 'lib'
 8 | 
 9 |     isolate_namespace Lit
10 | 
11 |     initializer 'lit.assets.precompile' do |app|
12 |       app.config.assets.precompile += %w[lit/application.css lit/application.js]
13 |       app.config.assets.precompile += %w[lit/lit_frontend.css lit/lit_frontend.js]
14 |     end
15 | 
16 |     initializer 'lit.reloader' do |app|
17 |       config.to_prepare { Lit.loader.cache.reset_local_cache if Lit.loader }
18 |     end
19 | 
20 |     initializer 'lit.migrations.append' do |app|
21 |       unless app.root.to_s.include?(root.to_s)
22 |         config.paths['db/migrate'].expanded.each { |expanded_path| app.config.paths['db/migrate'] << expanded_path }
23 |       end
24 |     end
25 | 
26 |     initializer :append_before_action do
27 |       ActionController::Base.send :before_action do
28 |         Thread.current[:lit_thread_cache] = {}
29 |       end
30 |     end
31 |   end
32 | end
33 | 


--------------------------------------------------------------------------------
/lib/lit/export.rb:
--------------------------------------------------------------------------------
 1 | require 'csv'
 2 | require 'lit/services/localization_keys_to_hash_service'
 3 | 
 4 | module Lit
 5 |   class Export
 6 |     def self.call(locale_keys:, format:, include_hits_count: false)
 7 |       raise ArgumentError, 'format must be yaml or csv' if %i[yaml csv].exclude?(format)
 8 |       Lit.loader.cache.load_all_translations
 9 |       localizations_scope = Lit::Localization.active
10 |       if locale_keys.present?
11 |         locale_ids = Lit::Locale.where(locale: locale_keys).pluck(:id)
12 |         localizations_scope = localizations_scope.where(locale_id: locale_ids) unless locale_ids.empty?
13 |       end
14 |       db_localizations = {}
15 |       localizations_scope.find_each { |l| db_localizations[l.full_key] = l.translation }
16 | 
17 |       case format
18 |       when :yaml
19 |         exported_keys = Lit::Services::LocalizationKeysToHashService.call(db_localizations)
20 |         exported_keys.to_yaml
21 |       when :csv
22 |         relevant_locales = locale_keys.presence || I18n.available_locales.map(&:to_s)
23 |         CSV.generate do |csv|
24 |           csv << ['key', *relevant_locales, ('hits' if include_hits_count)].compact
25 |           keys_without_locales = db_localizations.keys.map { |k| k.gsub(/(#{relevant_locales.join('|')})\./, '') }.uniq
26 |           keys_without_locales.each do |key_without_locale|
27 |             # Here, we need to determine if we're dealing with an array or a scalar.
28 |             # In the former case, for simplicity of editing (which is likely the main
29 |             # intent when exporting translations to CSV), let's make the "array" be simulated
30 |             # as a number of consecutive rows that have the same key.
31 |             #
32 |             # For example:
33 |             #
34 |             # key,en
35 |             # date.abbr_month_names,     <-- in this case it's empty because that array has nothing at [0]
36 |             # date.abbr_month_names,Jan
37 |             # date.abbr_month_names,Feb
38 |             # date.abbr_month_names,Mar
39 |             # date.abbr_month_names,Apr
40 |             # date.abbr_month_names,May
41 |             # ...
42 | 
43 |             key_localizations_per_locale =
44 |               relevant_locales.map { |l| Array.wrap(db_localizations["#{l}.#{key_without_locale}"]) }
45 |             transpose(key_localizations_per_locale).each do |translation_series|
46 |               csv_row = [key_without_locale, *translation_series]
47 |               csv_row << (Lit.init.cache.get_global_hits_counter(key_without_locale) || 0) if include_hits_count
48 |               csv << csv_row
49 |             end
50 |           end
51 |         end
52 |       end
53 |     end
54 | 
55 |     # This is like Array#transpose but ignores size differences between inner arrays.
56 |     private_class_method def self.transpose(matrix)
57 |       maxlen = matrix.max { |x| x.length }.length
58 |       matrix.each { |array| array[maxlen - 1] = nil if array.length < maxlen }
59 |       matrix.transpose
60 |     end
61 |   end
62 | end
63 | 


--------------------------------------------------------------------------------
/lib/lit/loader.rb:
--------------------------------------------------------------------------------
 1 | require 'logger'
 2 | require 'lit/i18n_backend'
 3 | require 'lit/cache'
 4 | require 'lit/export'
 5 | require 'lit/import'
 6 | require 'lit/cloud_translation'
 7 | require 'emoji_flag'
 8 | 
 9 | module Lit
10 |   class Loader
11 |     attr_accessor :cache
12 |     attr_accessor :logger
13 |     def initialize
14 |       self.logger ||= Logger.new($stdout)
15 |       self.logger.info 'initializing Lit' unless ::Rails.env.test?
16 |       self.cache ||= Cache.new
17 |       I18n.backend = I18nBackend.new(self.cache)
18 |     end
19 |   end
20 | end
21 | 


--------------------------------------------------------------------------------
/lib/lit/middleware.rb:
--------------------------------------------------------------------------------
 1 | require 'rack/body_proxy'
 2 | 
 3 | # A middleware that ensures the lit thread value is cleared after
 4 | # the last part of the body is rendered. This is useful when
 5 | # using streaming.j
 6 | #
 7 | # Uses Rack::BodyProxy, adapted from Rack::Lock's usage of the
 8 | # same pattern.
 9 | #
10 | 
11 | module Lit
12 |   class Middleware
13 |     def initialize(app)
14 |       @app = app
15 |     end
16 | 
17 |     def call(env)
18 |       Thread.current[:localization_cache_valid] = false
19 |       response = @app.call(env)
20 | 
21 |       # for streaming support wrap request in Rack::BodyProxy
22 |       response << Rack::BodyProxy.new(response.pop) do
23 |         Thread.current[:localization_cache_valid] = false
24 |       end
25 |     ensure
26 |       Thread.current[:localization_cache_valid] = false
27 |     end
28 |   end
29 | end
30 | 


--------------------------------------------------------------------------------
/lib/lit/rails.rb:
--------------------------------------------------------------------------------
 1 | require 'logger'
 2 | require 'lit/i18n_backend'
 3 | require 'lit/cache'
 4 | 
 5 | module Lit
 6 |   module Rails
 7 |     def self.initialize
 8 |       Lit.init
 9 |     end
10 |   end
11 | end
12 | 
13 | if defined?(Rails::Railtie)
14 |   require 'lit/middleware'
15 |   require 'lit/railtie'
16 | else
17 |   Lit::Rails.initialize
18 | end
19 | 


--------------------------------------------------------------------------------
/lib/lit/railtie.rb:
--------------------------------------------------------------------------------
 1 | module Lit
 2 |   class Railtie < ::Rails::Railtie
 3 |     initializer :lit_middleware do |app|
 4 |       app.config.middleware.insert_after ActionDispatch::RequestId, Lit::Middleware
 5 | 
 6 |       ActiveSupport::Reloader.to_complete do
 7 |         Thread.current[:localization_cache_valid] = false
 8 |       end
 9 |     end
10 |   end
11 | end
12 | 


--------------------------------------------------------------------------------
/lib/lit/services/humanize_service.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | module Lit
 4 |   module Services
 5 |     # Checks if should humanize based on config and blacklist.
 6 |     # Performs humanize if required
 7 |     # Caches the value of humanization
 8 |     class HumanizeService
 9 |       def self.should_humanize?(key)
10 |         Lit.humanize_key && Lit.humanize_key_ignored.match(key).nil?
11 |       end
12 | 
13 |       def self.humanize(key)
14 |         key.to_s.split('.').last.humanize
15 |       end
16 | 
17 |       def self.humanize_and_cache(key, options)
18 |         content = humanize(key)
19 |         parts = I18n.normalize_keys(
20 |           options[:locale] || I18n.locale, key, options[:scope], options[:separator]
21 |         )
22 |         key_with_locale = parts.join('.')
23 |         I18n.cache_store[key_with_locale] = content
24 |         I18n.cache_store[key_with_locale]
25 |       end
26 |     end
27 |   end
28 | end
29 | 


--------------------------------------------------------------------------------
/lib/lit/services/localization_keys_to_hash_service.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | module Lit
 4 |   module Services
 5 |     # Converts flat hash with localization_keys as keys and translations as values to nested hash
 6 |     # by nesting on '.' localization key dots
 7 |     class LocalizationKeysToHashService
 8 |       # http://subtech.g.hatena.ne.jp/cho45/20061122
 9 |       def self.call(db_localizations)
10 |         deep_proc =
11 |           proc do |_k, s, o|
12 |             next s.merge(o, &deep_proc) if s.is_a?(Hash) && o.is_a?(Hash)
13 | 
14 |             next o
15 |           end
16 |         nested_keys = {}
17 |         db_localizations.sort.each do |k, v|
18 |           key_parts = k.to_s.split('.')
19 |           converted = key_parts.reverse.reduce(v) { |a, n| { n => a } }
20 |           nested_keys.merge!(converted, &deep_proc)
21 |         end
22 |         nested_keys
23 |       end
24 |     end
25 |   end
26 | end
27 | 


--------------------------------------------------------------------------------
/lib/lit/version.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | module Lit
 4 |   module_function
 5 | 
 6 |   def version
 7 |     Gem::Version.new Version::STRING
 8 |   end
 9 | 
10 |   module Version
11 |     MAJOR = 1
12 |     MINOR = 1
13 |     TINY = 6
14 | 
15 |     STRING = [MAJOR, MINOR, TINY].compact.join('.')
16 |   end
17 | end
18 | 


--------------------------------------------------------------------------------
/lit.gemspec:
--------------------------------------------------------------------------------
 1 | $LOAD_PATH.push File.expand_path('../lib', __FILE__)
 2 | 
 3 | require 'lit/version'
 4 | 
 5 | Gem::Specification.new do |s|
 6 |   s.name = 'lit'
 7 |   s.version = Lit.version
 8 |   s.authors = ['Maciej Litwiniuk', 'Piotr Boniecki', 'Michał Buszkiewicz', 'Szymon Soppa']
 9 |   s.email = ['maciej@litwiniuk.net']
10 |   s.license = 'MIT'
11 |   s.homepage = 'https://github.com/prograils/lit'
12 |   s.summary = 'Database powered i18n backend with web gui'
13 |   s.description =
14 |     "Translate your apps with pleasure (sort of...) and for free.
15 |                    It's simple i18n web interface, build on top of twitter
16 |                    bootstrap, that one may find helpful in translating app by
17 |                    non-technicals. "
18 | 
19 |   s.files = Dir['{app,config,db,lib}/**/*'] + %w[MIT-LICENSE Rakefile README.md]
20 |   s.add_dependency 'rails', '>= 5.2.0'
21 |   s.add_dependency 'jquery-rails'
22 |   s.add_dependency 'coffee-rails'
23 |   s.add_dependency 'sass-rails'
24 |   s.add_dependency 'emoji_flag'
25 | 
26 |   s.add_development_dependency 'appraisal', '~> 2.4.0'
27 |   s.add_development_dependency 'devise', '~> 4.7.1'
28 |   s.add_development_dependency 'minitest', '~> 5.11.3'
29 |   s.add_development_dependency 'minitest-vcr', '~> 1.4.0'
30 |   s.add_development_dependency 'pry-byebug', '~> 3.9.0'
31 |   s.add_development_dependency 'vcr', '~> 4.0.0'
32 |   s.add_development_dependency 'webmock', '~> 3.4.2'
33 | end
34 | 


--------------------------------------------------------------------------------
/script/rails:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env ruby
2 | # This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
3 | 
4 | ENGINE_ROOT = File.expand_path('../..', __FILE__)
5 | ENGINE_PATH = File.expand_path('../../lib/lit/engine', __FILE__)
6 | 
7 | require 'rails/all'
8 | require 'rails/engine/commands'
9 | 


--------------------------------------------------------------------------------
/test/.rubocop.yml:
--------------------------------------------------------------------------------
1 | # Let's ensure that having good, thorough tests is no longer considered an offence.
2 | 
3 | Metrics/ClassLength:
4 |   Enabled: false
5 | 
6 | Metrics/BlockLength:
7 |   Enabled: false
8 | 


--------------------------------------------------------------------------------
/test/cassettes/Lit_CloudTranslation_Providers_Google/when_from_and_to_languages_are_given/when_array_of_strings_is_given/translates_array_of_strings_to_target_language.yml:
--------------------------------------------------------------------------------
 1 | ---
 2 | http_interactions:
 3 | - request:
 4 |     method: post
 5 |     uri: https://translation.googleapis.com/language/translate/v2
 6 |     body:
 7 |       encoding: UTF-8
 8 |       string: '{"q":["awesome","stuff"],"target":"pl","source":"en"}'
 9 |     headers:
10 |       User-Agent:
11 |       - gcloud-ruby/1.2.4
12 |       Google-Cloud-Resource-Prefix:
13 |       - projects/litbox-1543326618593
14 |       Content-Type:
15 |       - application/json
16 |       X-Goog-Api-Client:
17 |       - gl-ruby/2.5.1 gccl/1.2.4
18 |       Authorization:
19 |       - Bearer REDACTED
20 |       Cache-Control:
21 |       - no-store
22 |       Accept-Encoding:
23 |       - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
24 |       Accept:
25 |       - "*/*"
26 |   response:
27 |     status:
28 |       code: 200
29 |       message: OK
30 |     headers:
31 |       Content-Type:
32 |       - application/json; charset=UTF-8
33 |       Vary:
34 |       - Origin
35 |       - Referer
36 |       - X-Origin
37 |       Date:
38 |       - Fri, 14 Dec 2018 11:07:07 GMT
39 |       Server:
40 |       - ESF
41 |       Cache-Control:
42 |       - private
43 |       X-Xss-Protection:
44 |       - 1; mode=block
45 |       X-Frame-Options:
46 |       - SAMEORIGIN
47 |       X-Content-Type-Options:
48 |       - nosniff
49 |       Alt-Svc:
50 |       - quic=":443"; ma=2592000; v="44,43,39,35"
51 |       Transfer-Encoding:
52 |       - chunked
53 |     body:
54 |       encoding: ASCII-8BIT
55 |       string: |
56 |         {
57 |           "data": {
58 |             "translations": [
59 |               {
60 |                 "translatedText": "niesamowite"
61 |               },
62 |               {
63 |                 "translatedText": "rzeczy"
64 |               }
65 |             ]
66 |           }
67 |         }
68 |     http_version:
69 |   recorded_at: Fri, 14 Dec 2018 11:07:07 GMT
70 | recorded_with: VCR 4.0.0
71 | 


--------------------------------------------------------------------------------
/test/cassettes/Lit_CloudTranslation_Providers_Yandex/when_from_and_to_languages_are_given/when_array_of_strings_is_given/translates_array_of_strings_to_target_language.yml:
--------------------------------------------------------------------------------
 1 | ---
 2 | http_interactions:
 3 | - request:
 4 |     method: get
 5 |     uri: https://translate.yandex.net/api/v1.5/tr.json/translate?key=trnsl.1.1.20181127T145246Z.3e17e5c99c1ad299.38126a1782dbe6e5fa5a3d91c9789cfb178a0d78&lang=en-pl&text=stuff
 6 |     body:
 7 |       encoding: US-ASCII
 8 |       string: ''
 9 |     headers:
10 |       Accept-Encoding:
11 |       - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
12 |       Accept:
13 |       - "*/*"
14 |       User-Agent:
15 |       - Ruby
16 |       Host:
17 |       - translate.yandex.net
18 |   response:
19 |     status:
20 |       code: 200
21 |       message: OK
22 |     headers:
23 |       Server:
24 |       - nginx/1.6.2
25 |       Date:
26 |       - Tue, 11 Dec 2018 16:32:58 GMT
27 |       Content-Type:
28 |       - application/json; charset=utf-8
29 |       Content-Length:
30 |       - '59'
31 |       Connection:
32 |       - keep-alive
33 |       Keep-Alive:
34 |       - timeout=120
35 |       Cache-Control:
36 |       - no-store
37 |       X-Content-Type-Options:
38 |       - nosniff
39 |     body:
40 |       encoding: UTF-8
41 |       string: '{"code":200,"lang":"en-pl","text":["niesamowite","rzeczy"]}'
42 |     http_version: 
43 |   recorded_at: Tue, 11 Dec 2018 16:32:58 GMT
44 | recorded_with: VCR 4.0.0
45 | 


--------------------------------------------------------------------------------
/test/cassettes/Lit_CloudTranslation_Providers_Yandex/when_from_and_to_languages_are_given/when_single_string_is_given/translates_single_string_to_target_language.yml:
--------------------------------------------------------------------------------
 1 | ---
 2 | http_interactions:
 3 | - request:
 4 |     method: get
 5 |     uri: https://translate.yandex.net/api/v1.5/tr.json/translate?key=trnsl.1.1.20181127T145246Z.3e17e5c99c1ad299.38126a1782dbe6e5fa5a3d91c9789cfb178a0d78&lang=en-pl&text=The%20quick%20brown%20fox%20jumps%20over%20the%20lazy%20dog.
 6 |     body:
 7 |       encoding: US-ASCII
 8 |       string: ''
 9 |     headers:
10 |       Accept-Encoding:
11 |       - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
12 |       Accept:
13 |       - "*/*"
14 |       User-Agent:
15 |       - Ruby
16 |       Host:
17 |       - translate.yandex.net
18 |   response:
19 |     status:
20 |       code: 200
21 |       message: OK
22 |     headers:
23 |       Server:
24 |       - nginx/1.6.2
25 |       Date:
26 |       - Tue, 11 Dec 2018 16:32:58 GMT
27 |       Content-Type:
28 |       - application/json; charset=utf-8
29 |       Content-Length:
30 |       - '84'
31 |       Connection:
32 |       - keep-alive
33 |       Keep-Alive:
34 |       - timeout=120
35 |       Cache-Control:
36 |       - no-store
37 |       X-Content-Type-Options:
38 |       - nosniff
39 |     body:
40 |       encoding: ASCII-8BIT
41 |       string: !binary |-
42 |         eyJjb2RlIjoyMDAsImxhbmciOiJlbi1wbCIsInRleHQiOlsiU3p5YmtpIGJyxIV6b3d5IGxpcyBza2FjemUgcHJ6ZXogbGVuaXfEhSBwc2EuIl19
43 |     http_version: 
44 |   recorded_at: Tue, 11 Dec 2018 16:32:58 GMT
45 | recorded_with: VCR 4.0.0
46 | 


--------------------------------------------------------------------------------
/test/cassettes/Lit_CloudTranslation_Providers_Yandex/when_only_to_language_is_given/when_array_containing_nil_values_is_given/translates_array_to_target_language_converting_nil_to_.yml:
--------------------------------------------------------------------------------
 1 | ---
 2 | http_interactions:
 3 | - request:
 4 |     method: get
 5 |     uri: https://translate.yandex.net/api/v1.5/tr.json/translate?key=trnsl.1.1.20181127T145246Z.3e17e5c99c1ad299.38126a1782dbe6e5fa5a3d91c9789cfb178a0d78&lang=pl&text=stuff
 6 |     body:
 7 |       encoding: US-ASCII
 8 |       string: ''
 9 |     headers:
10 |       Accept-Encoding:
11 |       - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
12 |       Accept:
13 |       - "*/*"
14 |       User-Agent:
15 |       - Ruby
16 |       Host:
17 |       - translate.yandex.net
18 |   response:
19 |     status:
20 |       code: 200
21 |       message: OK
22 |     headers:
23 |       Server:
24 |       - nginx/1.6.2
25 |       Date:
26 |       - Thu, 10 Jan 2019 13:44:43 GMT
27 |       Content-Type:
28 |       - application/json; charset=utf-8
29 |       Content-Length:
30 |       - '65'
31 |       Connection:
32 |       - keep-alive
33 |       Keep-Alive:
34 |       - timeout=120
35 |       X-Content-Type-Options:
36 |       - nosniff
37 |       Cache-Control:
38 |       - no-store
39 |     body:
40 |       encoding: UTF-8
41 |       string: '{"code":200,"lang":"en-pl","text":["","niesamowite","","rzeczy"]}'
42 |     http_version: 
43 |   recorded_at: Thu, 10 Jan 2019 13:44:43 GMT
44 | recorded_with: VCR 4.0.0
45 | 


--------------------------------------------------------------------------------
/test/cassettes/Lit_CloudTranslation_Providers_Yandex/when_only_to_language_is_given/when_array_of_strings_is_given/translates_array_of_strings_to_target_language.yml:
--------------------------------------------------------------------------------
 1 | ---
 2 | http_interactions:
 3 | - request:
 4 |     method: get
 5 |     uri: https://translate.yandex.net/api/v1.5/tr.json/translate?key=trnsl.1.1.20181127T145246Z.3e17e5c99c1ad299.38126a1782dbe6e5fa5a3d91c9789cfb178a0d78&lang=pl&text=stuff
 6 |     body:
 7 |       encoding: US-ASCII
 8 |       string: ''
 9 |     headers:
10 |       Accept-Encoding:
11 |       - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
12 |       Accept:
13 |       - "*/*"
14 |       User-Agent:
15 |       - Ruby
16 |       Host:
17 |       - translate.yandex.net
18 |   response:
19 |     status:
20 |       code: 200
21 |       message: OK
22 |     headers:
23 |       Server:
24 |       - nginx/1.6.2
25 |       Date:
26 |       - Tue, 11 Dec 2018 16:32:58 GMT
27 |       Content-Type:
28 |       - application/json; charset=utf-8
29 |       Content-Length:
30 |       - '59'
31 |       Connection:
32 |       - keep-alive
33 |       Keep-Alive:
34 |       - timeout=120
35 |       X-Content-Type-Options:
36 |       - nosniff
37 |       Cache-Control:
38 |       - no-store
39 |     body:
40 |       encoding: UTF-8
41 |       string: '{"code":200,"lang":"en-pl","text":["niesamowite","rzeczy"]}'
42 |     http_version: 
43 |   recorded_at: Tue, 11 Dec 2018 16:32:58 GMT
44 | recorded_with: VCR 4.0.0
45 | 


--------------------------------------------------------------------------------
/test/cassettes/Lit_CloudTranslation_Providers_Yandex/when_only_to_language_is_given/when_single_string_is_given/translates_single_string_to_target_language.yml:
--------------------------------------------------------------------------------
 1 | ---
 2 | http_interactions:
 3 | - request:
 4 |     method: get
 5 |     uri: https://translate.yandex.net/api/v1.5/tr.json/translate?key=trnsl.1.1.20181127T145246Z.3e17e5c99c1ad299.38126a1782dbe6e5fa5a3d91c9789cfb178a0d78&lang=pl&text=The%20quick%20brown%20fox%20jumps%20over%20the%20lazy%20dog.
 6 |     body:
 7 |       encoding: US-ASCII
 8 |       string: ''
 9 |     headers:
10 |       Accept-Encoding:
11 |       - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
12 |       Accept:
13 |       - "*/*"
14 |       User-Agent:
15 |       - Ruby
16 |       Host:
17 |       - translate.yandex.net
18 |   response:
19 |     status:
20 |       code: 200
21 |       message: OK
22 |     headers:
23 |       Server:
24 |       - nginx/1.6.2
25 |       Date:
26 |       - Tue, 11 Dec 2018 16:32:57 GMT
27 |       Content-Type:
28 |       - application/json; charset=utf-8
29 |       Content-Length:
30 |       - '84'
31 |       Connection:
32 |       - keep-alive
33 |       Keep-Alive:
34 |       - timeout=120
35 |       Cache-Control:
36 |       - no-store
37 |       X-Content-Type-Options:
38 |       - nosniff
39 |     body:
40 |       encoding: ASCII-8BIT
41 |       string: !binary |-
42 |         eyJjb2RlIjoyMDAsImxhbmciOiJlbi1wbCIsInRleHQiOlsiU3p5YmtpIGJyxIV6b3d5IGxpcyBza2FjemUgcHJ6ZXogbGVuaXfEhSBwc2EuIl19
43 |     http_version: 
44 |   recorded_at: Tue, 11 Dec 2018 16:32:57 GMT
45 | recorded_with: VCR 4.0.0
46 | 


--------------------------------------------------------------------------------
/test/cassettes/Lit_CloudTranslation_Providers_Yandex/when_only_to_language_is_given/when_single_string_is_given/when_string_contains_interpolation/does_not_translate_stuff_enclosed_in_.yml:
--------------------------------------------------------------------------------
 1 | ---
 2 | http_interactions:
 3 | - request:
 4 |     method: get
 5 |     uri: https://translate.yandex.net/api/v1.5/tr.json/translate?key=trnsl.1.1.20181127T145246Z.3e17e5c99c1ad299.38126a1782dbe6e5fa5a3d91c9789cfb178a0d78&lang=pl&text=here%20is%20your%20%25%7B_LIT_meal_LIT_%7D,%20enjoy
 6 |     body:
 7 |       encoding: US-ASCII
 8 |       string: ''
 9 |     headers:
10 |       Accept-Encoding:
11 |       - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
12 |       Accept:
13 |       - "*/*"
14 |       User-Agent:
15 |       - Ruby
16 |       Host:
17 |       - translate.yandex.net
18 |   response:
19 |     status:
20 |       code: 200
21 |       message: OK
22 |     headers:
23 |       Server:
24 |       - nginx/1.6.2
25 |       Date:
26 |       - Mon, 24 Dec 2018 12:16:08 GMT
27 |       Content-Type:
28 |       - application/json; charset=utf-8
29 |       Content-Length:
30 |       - '71'
31 |       Connection:
32 |       - keep-alive
33 |       Keep-Alive:
34 |       - timeout=120
35 |       X-Content-Type-Options:
36 |       - nosniff
37 |       Cache-Control:
38 |       - no-store
39 |     body:
40 |       encoding: ASCII-8BIT
41 |       string: !binary |-
42 |         eyJjb2RlIjoyMDAsImxhbmciOiJlbi1wbCIsInRleHQiOlsidG8gJXtfTElUX21lYWxfTElUX30sIGNpZXN6IHNpxJkiXX0=
43 |     http_version: 
44 |   recorded_at: Mon, 24 Dec 2018 12:15:00 GMT
45 | recorded_with: VCR 4.0.0
46 | 


--------------------------------------------------------------------------------
/test/dummy/Rakefile:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env rake
2 | # Add your own tasks in files placed in lib/tasks ending in .rake,
3 | # for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
4 | 
5 | require File.expand_path('../config/application', __FILE__)
6 | 
7 | Dummy::Application.load_tasks
8 | 


--------------------------------------------------------------------------------
/test/dummy/app/assets/config/manifest.js:
--------------------------------------------------------------------------------
1 | //= link_directory ../javascripts .js
2 | //= link_directory ../stylesheets .css
3 | 
4 | 


--------------------------------------------------------------------------------
/test/dummy/app/assets/javascripts/application.js:
--------------------------------------------------------------------------------
 1 | // This is a manifest file that'll be compiled into application.js, which will include all the files
 2 | // listed below.
 3 | //
 4 | // Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
 5 | // or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
 6 | //
 7 | // It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
 8 | // the compiled file.
 9 | //
10 | // WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
11 | // GO AFTER THE REQUIRES BELOW.
12 | //
13 | //= require jquery
14 | //= require jquery_ujs
15 | //= require_tree .
16 | 


--------------------------------------------------------------------------------
/test/dummy/app/assets/javascripts/projects.js:
--------------------------------------------------------------------------------
1 | // Place all the behaviors and hooks related to the matching controller here.
2 | // All this logic will automatically be available in application.js.
3 | 


--------------------------------------------------------------------------------
/test/dummy/app/assets/stylesheets/application.css:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * This is a manifest file that'll be compiled into application.css, which will include all the files
 3 |  * listed below.
 4 |  *
 5 |  * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
 6 |  * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
 7 |  *
 8 |  * You're free to add application-wide styles to this file and they'll appear at the top of the
 9 |  * compiled file, but it's generally better to create a new file per style scope.
10 |  *
11 |  *= require_self
12 |  *= require_tree .
13 |  */
14 | 


--------------------------------------------------------------------------------
/test/dummy/app/assets/stylesheets/projects.css.scss:
--------------------------------------------------------------------------------
1 | // Place all the styles related to the Projects controller here.
2 | // They will automatically be included in application.css.
3 | // You can use Sass (SCSS) here: http://sass-lang.com/
4 | 


--------------------------------------------------------------------------------
/test/dummy/app/assets/stylesheets/scaffolds.css.scss:
--------------------------------------------------------------------------------
 1 | body {
 2 |   background-color: #fff;
 3 |   color: #333;
 4 |   font-family: verdana, arial, helvetica, sans-serif;
 5 |   font-size: 13px;
 6 |   line-height: 18px;
 7 | }
 8 | 
 9 | p, ol, ul, td {
10 |   font-family: verdana, arial, helvetica, sans-serif;
11 |   font-size: 13px;
12 |   line-height: 18px;
13 | }
14 | 
15 | pre {
16 |   background-color: #eee;
17 |   padding: 10px;
18 |   font-size: 11px;
19 | }
20 | 
21 | a {
22 |   color: #000;
23 |   &:visited {
24 |     color: #666;
25 |   }
26 |   &:hover {
27 |     color: #fff;
28 |     background-color: #000;
29 |   }
30 | }
31 | 
32 | div {
33 |   &.field, &.actions {
34 |     margin-bottom: 10px;
35 |   }
36 | }
37 | 
38 | #notice {
39 |   color: green;
40 | }
41 | 
42 | .field_with_errors {
43 |   padding: 2px;
44 |   background-color: red;
45 |   display: table;
46 | }
47 | 
48 | #error_explanation {
49 |   width: 450px;
50 |   border: 2px solid red;
51 |   padding: 7px;
52 |   padding-bottom: 0;
53 |   margin-bottom: 20px;
54 |   background-color: #f0f0f0;
55 |   h2 {
56 |     text-align: left;
57 |     font-weight: bold;
58 |     padding: 5px 5px 5px 15px;
59 |     font-size: 12px;
60 |     margin: -7px;
61 |     margin-bottom: 0px;
62 |     background-color: #c00;
63 |     color: #fff;
64 |   }
65 |   ul li {
66 |     font-size: 12px;
67 |     list-style: square;
68 |   }
69 | }
70 | 


--------------------------------------------------------------------------------
/test/dummy/app/controllers/application_controller.rb:
--------------------------------------------------------------------------------
 1 | class ApplicationController < ActionController::Base
 2 |   protect_from_forgery
 3 | 
 4 |   unless respond_to?(:before_action)
 5 |     alias_method :before_action, :before_filter
 6 |   end
 7 | 
 8 |   helper Lit::FrontendHelper
 9 | 
10 |   before_action :set_locale
11 | 
12 |   def set_locale
13 |     I18n.locale = params[:locale] if params[:locale]
14 |   end
15 | end
16 | 


--------------------------------------------------------------------------------
/test/dummy/app/controllers/projects_controller.rb:
--------------------------------------------------------------------------------
 1 | class ProjectsController < ApplicationController
 2 |   # GET /projects
 3 |   # GET /projects.json
 4 |   def index
 5 |     @projects = Project.all
 6 | 
 7 |     respond_to do |format|
 8 |       format.html # index.html.erb
 9 |       format.json { render json: @projects }
10 |     end
11 |   end
12 | 
13 |   # GET /projects/1
14 |   # GET /projects/1.json
15 |   def show
16 |     @project = Project.find(params[:id])
17 | 
18 |     respond_to do |format|
19 |       format.html # show.html.erb
20 |       format.json { render json: @project }
21 |     end
22 |   end
23 | 
24 |   # GET /projects/new
25 |   # GET /projects/new.json
26 |   def new
27 |     @project = Project.new
28 | 
29 |     respond_to do |format|
30 |       format.html # new.html.erb
31 |       format.json { render json: @project }
32 |     end
33 |   end
34 | 
35 |   # GET /projects/1/edit
36 |   def edit
37 |     @project = Project.find(params[:id])
38 |   end
39 | 
40 |   # POST /projects
41 |   # POST /projects.json
42 |   def create
43 |     @project = Project.new(project_params)
44 | 
45 |     respond_to do |format|
46 |       if @project.save
47 |         format.html { redirect_to project_path(@project, locale: I18n.locale), notice: 'Project was successfully created.' }
48 |         format.json { render json: @project, status: :created, location: @project }
49 |       else
50 |         format.html { render action: 'new' }
51 |         format.json { render json: @project.errors, status: :unprocessable_entity }
52 |       end
53 |     end
54 |   end
55 | 
56 |   # PUT /projects/1
57 |   # PUT /projects/1.json
58 |   def update
59 |     @project = Project.find(project_params)
60 | 
61 |     respond_to do |format|
62 |       if @project.update(params[:project])
63 |         format.html { redirect_to @project, notice: 'Project was successfully updated.' }
64 |         format.json { head :no_content }
65 |       else
66 |         format.html { render action: 'edit' }
67 |         format.json { render json: @project.errors, status: :unprocessable_entity }
68 |       end
69 |     end
70 |   end
71 | 
72 |   # DELETE /projects/1
73 |   # DELETE /projects/1.json
74 |   def destroy
75 |     @project = Project.find(params[:id])
76 |     @project.destroy
77 | 
78 |     respond_to do |format|
79 |       format.html { redirect_to projects_url }
80 |       format.json { head :no_content }
81 |     end
82 |   end
83 | 
84 |   private
85 | 
86 |   def project_params
87 |     params.require(:project).permit(:name)
88 |   end
89 | end
90 | 


--------------------------------------------------------------------------------
/test/dummy/app/controllers/welcome_controller.rb:
--------------------------------------------------------------------------------
1 | class WelcomeController < ApplicationController
2 |   before_action :authenticate_admin!, only: [:catan]
3 |   def index
4 |   end
5 | 
6 |   def catan
7 |   end
8 | end
9 | 


--------------------------------------------------------------------------------
/test/dummy/app/helpers/application_helper.rb:
--------------------------------------------------------------------------------
1 | module ApplicationHelper
2 | end
3 | 


--------------------------------------------------------------------------------
/test/dummy/app/helpers/projects_helper.rb:
--------------------------------------------------------------------------------
1 | module ProjectsHelper
2 | end
3 | 


--------------------------------------------------------------------------------
/test/dummy/app/mailers/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/prograils/lit/dc11ab3415524d16a6dfe40b130a07248dc65f2b/test/dummy/app/mailers/.gitkeep


--------------------------------------------------------------------------------
/test/dummy/app/models/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/prograils/lit/dc11ab3415524d16a6dfe40b130a07248dc65f2b/test/dummy/app/models/.gitkeep


--------------------------------------------------------------------------------
/test/dummy/app/models/admin.rb:
--------------------------------------------------------------------------------
 1 | class Admin < ActiveRecord::Base
 2 |   # Include default devise modules. Others available are:
 3 |   # :token_authenticatable, :confirmable,
 4 |   # :lockable, :timeoutable and :omniauthable
 5 |   devise :database_authenticatable, :registerable,
 6 |          :recoverable, :rememberable, :trackable, :validatable
 7 | 
 8 |   unless defined?(::ActionController::StrongParameters)
 9 |     # Setup accessible (or protected) attributes for your model
10 |     attr_accessible :email, :password, :password_confirmation, :remember_me
11 |   end
12 | end
13 | 


--------------------------------------------------------------------------------
/test/dummy/app/models/project.rb:
--------------------------------------------------------------------------------
1 | class Project < ActiveRecord::Base
2 | 
3 |   validates_presence_of :name
4 | 
5 | end
6 | 


--------------------------------------------------------------------------------
/test/dummy/app/views/layouts/application.html.erb:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <title>Dummy</title>
 5 |   <%= stylesheet_link_tag    "application", :media => "all" %>
 6 |   <%= javascript_include_tag "application" %>
 7 |   <%= csrf_meta_tags %>
 8 |   <%= lit_frontend_assets %>
 9 | </head>
10 | <body>
11 | 
12 | <%= yield %>
13 | 
14 | </body>
15 | </html>
16 | 


--------------------------------------------------------------------------------
/test/dummy/app/views/projects/_form.html.erb:
--------------------------------------------------------------------------------
 1 | <%= form_for(@project) do |f| %>
 2 |   <% if @project.errors.any? %>
 3 |     <div id="error_explanation">
 4 |       <h2><%= pluralize(@project.errors.count, "error") %> prohibited this project from being saved:</h2>
 5 | 
 6 |       <ul>
 7 |       <% @project.errors.full_messages.each do |msg| %>
 8 |         <li><%= msg %></li>
 9 |       <% end %>
10 |       </ul>
11 |     </div>
12 |   <% end %>
13 | 
14 |   <div><%= t('some_random.key') %></div>
15 |   <div><%= t('another_random.key', default: 'Random') %></div>
16 |   <div class="field">
17 |     <%= f.label :name %><br />
18 |     <%= f.text_field :name %>
19 |   </div>
20 |   <div class="actions">
21 |     <%= f.submit %>
22 |   </div>
23 | <% end %>
24 | 


--------------------------------------------------------------------------------
/test/dummy/app/views/projects/edit.html.erb:
--------------------------------------------------------------------------------
1 | <h1>Editing project</h1>
2 | 
3 | <%= render 'form' %>
4 | 
5 | <%= link_to 'Show', @project %> |
6 | <%= link_to 'Back', projects_path %>
7 | 


--------------------------------------------------------------------------------
/test/dummy/app/views/projects/index.html.erb:
--------------------------------------------------------------------------------
 1 | <h1>Listing projects</h1>
 2 | 
 3 | <table>
 4 |   <tr>
 5 |     <th>Name</th>
 6 |     <th></th>
 7 |     <th></th>
 8 |     <th></th>
 9 |   </tr>
10 | 
11 | <% @projects.each do |project| %>
12 |   <tr>
13 |     <td><%= project.name %></td>
14 |     <td><%= link_to 'Show', project %></td>
15 |     <td><%= link_to 'Edit', edit_project_path(project) %></td>
16 |     <td><%= link_to 'Destroy', project, method: :delete, data: { confirm: 'Are you sure?' } %></td>
17 |   </tr>
18 | <% end %>
19 | </table>
20 | 
21 | <br />
22 | 
23 | <%= link_to 'New Project', new_project_path(I18n.locale) %>
24 | 


--------------------------------------------------------------------------------
/test/dummy/app/views/projects/new.html.erb:
--------------------------------------------------------------------------------
1 | <h1>New project</h1>
2 | 
3 | <%= render 'form' %>
4 | 
5 | <%= link_to 'Back', projects_path %>
6 | 


--------------------------------------------------------------------------------
/test/dummy/app/views/projects/show.html.erb:
--------------------------------------------------------------------------------
 1 | <p id="notice"><%= notice %></p>
 2 | 
 3 | <p>
 4 |   <b>Name:</b>
 5 |   <%= @project.name %>
 6 | </p>
 7 | 
 8 | 
 9 | <%= link_to 'Edit', edit_project_path(@project) %> |
10 | <%= link_to 'Back', projects_path %>
11 | 


--------------------------------------------------------------------------------
/test/dummy/app/views/welcome/index.html.erb:
--------------------------------------------------------------------------------
 1 | <h1>
 2 |   <%= t('.header', default: 'Hello header') %>
 3 | </h1>
 4 | <p id="welcome">
 5 | <%= t('scope.hello_world', default: 'Hello there') %>
 6 | </p>
 7 | <p>
 8 | <%= t('scope.text_without_default') %>
 9 | </p>
10 | <p>
11 | <%= t('scope.text_with_default', default: 'Default content') %>
12 | </p>
13 | <p>
14 | <%= t('scope.some_strange_key') %>
15 | </p>
16 | <p>
17 | <%= t('scope.simple_test_with_default_value', default: "Simple test with default value") %>
18 | </p>
19 | <p>
20 | <%= t('scope.text_with_translation_in_english') %>
21 | </p>
22 | <p>
23 | <%= t('date.abbr_day_names') %>
24 | </p>
25 | <hr />
26 | <a href="https://google.com"><%= t('.go_to_google') %></a>
27 | <hr />
28 |   <%= t('.lorem_ipsum_long_1_html') %>
29 | <p>
30 |   <%= t('.sentence_1') %>
31 |   <%= t('.sentence_2') %>
32 |   <%= t('.sentence_3') %>
33 |   <%= t('.sentence_4') %>
34 |   <%= t('.sentence_5') %>
35 |   <%= t('.sentence_6') %>
36 | </p>
37 | 


--------------------------------------------------------------------------------
/test/dummy/config.ru:
--------------------------------------------------------------------------------
1 | # This file is used by Rack-based servers to start the application.
2 | 
3 | require ::File.expand_path('../config/environment',  __FILE__)
4 | run Dummy::Application
5 | 


--------------------------------------------------------------------------------
/test/dummy/config/application.rb:
--------------------------------------------------------------------------------
 1 | require_relative 'boot'
 2 | 
 3 | require 'rails/all'
 4 | Bundler.require(*Rails.groups)
 5 | require 'lit'
 6 | 
 7 | module Dummy
 8 |   class Application < Rails::Application
 9 |     # Settings in config/environments/* take precedence over those specified here.
10 |     # Application configuration should go into files in config/initializers
11 |     # -- all .rb files in that directory are automatically loaded.
12 | 
13 |     # Custom directories with classes and modules you want to be autoloadable.
14 |     # config.autoload_paths += %W(#{config.root}/extras)
15 | 
16 |     # Only load the plugins named here, in the order given (default is alphabetical).
17 |     # :all can be used as a placeholder for all plugins not explicitly named.
18 |     # config.plugins = [ :exception_notification, :ssl_requirement, :all ]
19 | 
20 |     # Activate observers that should always be running.
21 |     # config.active_record.observers = :cacher, :garbage_collector, :forum_observer
22 | 
23 |     # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
24 |     # Run "rake -D time" for a list of tasks for finding time zone names. Default is UTC.
25 |     # config.time_zone = 'Central Time (US & Canada)'
26 | 
27 |     # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
28 |     config.i18n.load_path += Dir[Rails.root.join('config', 'locales', '**', '*.{rb,yml}').to_s]
29 |     config.i18n.enforce_available_locales = false
30 |     config.i18n.default_locale = :en
31 | 
32 |     # Configure the default encoding used in templates for Ruby 1.9.
33 |     config.encoding = 'utf-8'
34 | 
35 |     # Configure sensitive parameters which will be filtered from the log file.
36 |     config.filter_parameters += [:password]
37 | 
38 |     # Enable escaping HTML in JSON.
39 |     config.active_support.escape_html_entities_in_json = true
40 | 
41 |     # Use SQL instead of Active Record's schema dumper when creating the database.
42 |     # This is necessary if your schema can't be completely dumped by the schema dumper,
43 |     # like if you have constraints or database-specific column types
44 |     # config.active_record.schema_format = :sql
45 | 
46 |     if ::Rails::VERSION::MAJOR == 4
47 |       config.active_record.raise_in_transactional_callbacks = true
48 |     end
49 | 
50 |     # Enable the asset pipeline
51 |     config.assets.enabled = true
52 | 
53 |     # Version of your assets, change this if you want to expire all your assets
54 |     config.assets.version = '1.0'
55 |   end
56 | end
57 | 
58 | 


--------------------------------------------------------------------------------
/test/dummy/config/boot.rb:
--------------------------------------------------------------------------------
1 | ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
2 | 
3 | require 'bundler/setup' # Set up gems listed in the Gemfile.
4 | 
5 | $LOAD_PATH.unshift File.expand_path('../../../../lib', __FILE__)
6 | 
7 | 


--------------------------------------------------------------------------------
/test/dummy/config/database.yml.sample:
--------------------------------------------------------------------------------
 1 | # Warning: The database defined as "test" will be erased and
 2 | # re-generated from your development database when you run "rake".
 3 | # Do not set this db to the same as development or production.
 4 | test:
 5 |   adapter: postgresql
 6 |   database: lit_test
 7 |   username:
 8 |   password:
 9 |   host: localhost
10 |   pool: 5
11 |   timeout: 5000
12 | 


--------------------------------------------------------------------------------
/test/dummy/config/database.yml.travis:
--------------------------------------------------------------------------------
1 | test:
2 |   adapter: postgresql
3 |   encoding: unicode
4 |   database: lit_test
5 |   username: postgres
6 | 


--------------------------------------------------------------------------------
/test/dummy/config/environment.rb:
--------------------------------------------------------------------------------
1 | # Load the Rails application.
2 | require_relative 'application'
3 | 
4 | # Initialize the Rails application.
5 | Dummy::Application.initialize!
6 | 
7 | 


--------------------------------------------------------------------------------
/test/dummy/config/environments/development.rb:
--------------------------------------------------------------------------------
 1 | Dummy::Application.configure do
 2 |   # Settings specified here will take precedence over those in config/application.rb
 3 | 
 4 |   # In the development environment your application's code is reloaded on
 5 |   # every request. This slows down response time but is perfect for development
 6 |   # since you don't have to restart the web server when you make code changes.
 7 |   config.cache_classes = false
 8 | 
 9 |   # Log error messages when you accidentally call methods on nil.
10 |   config.whiny_nils = true
11 | 
12 |   # Show full error reports and disable caching
13 |   config.consider_all_requests_local       = true
14 |   config.action_controller.perform_caching = false
15 | 
16 |   # Don't care if the mailer can't send
17 |   config.action_mailer.raise_delivery_errors = false
18 | 
19 |   # Print deprecation notices to the Rails logger
20 |   config.active_support.deprecation = :log
21 | 
22 |   # Only use best-standards-support built into browsers
23 |   config.action_dispatch.best_standards_support = :builtin
24 | 
25 |   if ::Rails::VERSION::MAJOR < 4
26 |     # Raise exception on mass assignment protection for Active Record models
27 |     config.active_record.mass_assignment_sanitizer = :strict
28 |   end
29 | 
30 |   # Do not compress assets
31 |   config.assets.compress = false
32 | 
33 |   # Expands the lines which load the assets
34 |   config.assets.debug = true
35 | end
36 | 


--------------------------------------------------------------------------------
/test/dummy/config/environments/production.rb:
--------------------------------------------------------------------------------
 1 | Dummy::Application.configure do
 2 |   # Settings specified here will take precedence over those in config/application.rb
 3 | 
 4 |   # Code is not reloaded between requests
 5 |   config.cache_classes = true
 6 | 
 7 |   # Full error reports are disabled and caching is turned on
 8 |   config.consider_all_requests_local       = false
 9 |   config.action_controller.perform_caching = true
10 | 
11 |   # Disable Rails's static asset server (Apache or nginx will already do this)
12 |   config.serve_static_assets = false
13 | 
14 |   # Compress JavaScripts and CSS
15 |   config.assets.compress = true
16 | 
17 |   # Don't fallback to assets pipeline if a precompiled asset is missed
18 |   config.assets.compile = false
19 | 
20 |   # Generate digests for assets URLs
21 |   config.assets.digest = true
22 | 
23 |   # Defaults to nil and saved in location specified by config.assets.prefix
24 |   # config.assets.manifest = YOUR_PATH
25 | 
26 |   # Specifies the header that your server uses for sending files
27 |   # config.action_dispatch.x_sendfile_header = "X-Sendfile" # for apache
28 |   # config.action_dispatch.x_sendfile_header = 'X-Accel-Redirect' # for nginx
29 | 
30 |   # Force all access to the app over SSL, use Strict-Transport-Security, and use secure cookies.
31 |   # config.force_ssl = true
32 | 
33 |   # See everything in the log (default is :info)
34 |   # config.log_level = :debug
35 | 
36 |   # Prepend all log lines with the following tags
37 |   # config.log_tags = [ :subdomain, :uuid ]
38 | 
39 |   # Use a different logger for distributed setups
40 |   # config.logger = ActiveSupport::TaggedLogging.new(SyslogLogger.new)
41 | 
42 |   # Use a different cache store in production
43 |   # config.cache_store = :mem_cache_store
44 | 
45 |   # Enable serving of images, stylesheets, and JavaScripts from an asset server
46 |   # config.action_controller.asset_host = "http://assets.example.com"
47 | 
48 |   # Precompile additional assets (application.js, application.css, and all non-JS/CSS are already added)
49 |   # config.assets.precompile += %w( search.js )
50 | 
51 |   # Disable delivery errors, bad email addresses will be ignored
52 |   # config.action_mailer.raise_delivery_errors = false
53 | 
54 |   # Enable threaded mode
55 |   # config.threadsafe!
56 | 
57 |   # Enable locale fallbacks for I18n (makes lookups for any locale fall back to
58 |   # the I18n.default_locale when a translation can not be found)
59 |   config.i18n.fallbacks = true
60 | 
61 |   # Send deprecation notices to registered listeners
62 |   config.active_support.deprecation = :notify
63 | 
64 |   # Log the query plan for queries taking more than this (works
65 |   # with SQLite, MySQL, and PostgreSQL)
66 |   # config.active_record.auto_explain_threshold_in_seconds = 0.5
67 | end
68 | 


--------------------------------------------------------------------------------
/test/dummy/config/environments/test.rb:
--------------------------------------------------------------------------------
 1 | Dummy::Application.configure do
 2 |   # Settings specified here will take precedence over those in config/application.rb
 3 | 
 4 |   # The test environment is used exclusively to run your application's
 5 |   # test suite. You never need to work with it otherwise. Remember that
 6 |   # your test database is "scratch space" for the test suite and is wiped
 7 |   # and recreated between test runs. Don't rely on the data there!
 8 |   config.cache_classes = true
 9 | 
10 |   config.eager_load = false
11 | 
12 |   # Configure static asset server for tests with Cache-Control for performance
13 |   if config.respond_to?(:public_file_server)
14 |     config.public_file_server.enabled = true
15 |     config.public_file_server.headers = { 'Cache-Control' => 'public, max-age=3600' }
16 |   else
17 |     if config.respond_to?(:serve_static_files)
18 |       config.serve_static_files = true
19 |     else
20 |       config.serve_static_assets = true
21 |     end
22 |     config.static_cache_control = 'public, max-age=3600'
23 |   end
24 | 
25 |   if ::Rails::VERSION::MAJOR < 4
26 |     # Log error messages when you accidentally call methods on nil
27 |     config.whiny_nils = true
28 |   end
29 | 
30 |   # Show full error reports and disable caching
31 |   config.consider_all_requests_local       = true
32 |   config.action_controller.perform_caching = false
33 | 
34 |   # Raise exceptions instead of rendering exception templates
35 |   config.action_dispatch.show_exceptions = false
36 | 
37 |   # Disable request forgery protection in test environment
38 |   config.action_controller.allow_forgery_protection    = false
39 | 
40 |   # Tell Action Mailer not to deliver emails to the real world.
41 |   # The :test delivery method accumulates sent emails in the
42 |   # ActionMailer::Base.deliveries array.
43 |   config.action_mailer.delivery_method = :test
44 | 
45 |   if ::Rails::VERSION::MAJOR < 4
46 |     # Raise exception on mass assignment protection for Active Record models
47 |     config.active_record.mass_assignment_sanitizer = :strict
48 |   else
49 |     config.i18n.enforce_available_locales = false
50 |   end
51 | 
52 |   # Print deprecation notices to the stderr
53 |   config.active_support.deprecation = :stderr
54 | 
55 |   # See everything in the log (default is :info)
56 |   config.log_level = :debug
57 | 
58 |   config.i18n.fallbacks = false
59 | 
60 |   config.active_support.test_order = :sorted
61 | end
62 | 


--------------------------------------------------------------------------------
/test/dummy/config/initializers/assets.rb:
--------------------------------------------------------------------------------
1 | Rails.application.config.assets.precompile += %w(*.png *.jpg *.jpeg *.gif *.svg *.eot *.woff *.ttf *.ico)
2 | 


--------------------------------------------------------------------------------
/test/dummy/config/initializers/backtrace_silencers.rb:
--------------------------------------------------------------------------------
1 | # Be sure to restart your server when you modify this file.
2 | 
3 | # You can add backtrace silencers for libraries that you're using but don't wish to see in your backtraces.
4 | # Rails.backtrace_cleaner.add_silencer { |line| line =~ /my_noisy_library/ }
5 | 
6 | # You can also remove all the silencers if you're trying to debug a problem that might stem from framework code.
7 | # Rails.backtrace_cleaner.remove_silencers!
8 | 


--------------------------------------------------------------------------------
/test/dummy/config/initializers/i18n.rb:
--------------------------------------------------------------------------------
 1 | if ::Rails::VERSION::MAJOR == 3 ||
 2 |     (::Rails::VERSION::MAJOR == 4 && ::Rails::VERSION::MINOR == 0)
 3 |   require 'i18n'
 4 | 
 5 |   # Override exception handler to more carefully html-escape missing-key results.
 6 |   class HtmlSafeI18nExceptionHandler
 7 |     Missing = I18n.const_defined?(:MissingTranslation) ? I18n::MissingTranslation : I18n::MissingTranslationData
 8 | 
 9 |     def initialize(original_exception_handler)
10 |       @original_exception_handler = original_exception_handler
11 |     end
12 | 
13 |     def call(exception, locale, key, options)
14 |       if exception.is_a?(Missing) && options[:rescue_format] == :html
15 |         keys = exception.keys.map { |k| Rack::Utils.escape_html k }
16 |         key = keys.last.to_s.gsub('_', ' ').gsub(/\b('?[a-z])/) { $1.capitalize }
17 |         %(<span class="translation_missing" title="translation missing: #{keys.join('.')}">#{key}</span>)
18 |       else
19 |         @original_exception_handler.call(exception, locale, key, options)
20 |       end
21 |     end
22 |   end
23 | 
24 |   I18n.exception_handler = HtmlSafeI18nExceptionHandler.new(I18n.exception_handler)
25 | end
26 | 


--------------------------------------------------------------------------------
/test/dummy/config/initializers/inflections.rb:
--------------------------------------------------------------------------------
 1 | # Be sure to restart your server when you modify this file.
 2 | 
 3 | # Add new inflection rules using the following format
 4 | # (all these examples are active by default):
 5 | # ActiveSupport::Inflector.inflections do |inflect|
 6 | #   inflect.plural /^(ox)$/i, '\1en'
 7 | #   inflect.singular /^(ox)en/i, '\1'
 8 | #   inflect.irregular 'person', 'people'
 9 | #   inflect.uncountable %w( fish sheep )
10 | # end
11 | #
12 | # These inflection rules are supported but not enabled by default:
13 | # ActiveSupport::Inflector.inflections do |inflect|
14 | #   inflect.acronym 'RESTful'
15 | # end
16 | 


--------------------------------------------------------------------------------
/test/dummy/config/initializers/lit.rb:
--------------------------------------------------------------------------------
 1 | Lit.authentication_function = :authenticate_admin!
 2 | Lit.authentication_verification = :admin_signed_in?
 3 | Lit.key_value_engine = ENV['LIT_STORAGE'] || 'redis'
 4 | Lit.humanize_key = false
 5 | Lit.ignore_yaml_on_startup = true
 6 | Lit.api_enabled = true
 7 | Lit.api_key = 'ala'
 8 | Lit.all_translations_are_html_safe = true
 9 | Lit.init
10 | 


--------------------------------------------------------------------------------
/test/dummy/config/initializers/mime_types.rb:
--------------------------------------------------------------------------------
1 | # Be sure to restart your server when you modify this file.
2 | 
3 | # Add new mime types for use in respond_to blocks:
4 | # Mime::Type.register "text/richtext", :rtf
5 | # Mime::Type.register_alias "text/html", :iphone
6 | 


--------------------------------------------------------------------------------
/test/dummy/config/initializers/postgres_10_pg_sequence_fix.rb:
--------------------------------------------------------------------------------
 1 | # In PostgreSQL 10 each sequence does not know `increment_by` or `min_value`
 2 | # This fix is already in Rails master, this is just monkey patch "to make it
 3 | # work" in Rails 4.2
 4 | # More details here: https://github.com/rails/rails/pull/28864
 5 | # Original issue: https://github.com/rails/rails/issues/28780
 6 | module ActiveRecord
 7 |   module ConnectionAdapters
 8 |     module PostgreSQL
 9 |       module SchemaStatements
10 |         # Resets the sequence of a table's primary key to the maximum value.
11 |         def reset_pk_sequence!(table, pk = nil, sequence = nil) #:nodoc:
12 |           unless pk && sequence
13 |             default_pk, default_sequence = pk_and_sequence_for(table)
14 | 
15 |             pk ||= default_pk
16 |             sequence ||= default_sequence
17 |           end
18 | 
19 |           if @logger && pk && !sequence
20 |             @logger.warn "#{table} has primary key #{pk} with no default sequence."
21 |           end
22 | 
23 |           if pk && sequence
24 |             quoted_sequence = quote_table_name(sequence)
25 |             max_pk = select_value("select MAX(#{quote_column_name pk}) from #{quote_table_name(table)}")
26 |             if max_pk.nil?
27 |               if postgresql_version >= 100000
28 |                 minvalue = select_value("SELECT seqmin from pg_sequence where seqrelid = '#{quoted_sequence}'::regclass")
29 |               else
30 |                 minvalue = select_value("SELECT min_value FROM #{quoted_sequence}")
31 |               end
32 |             end
33 | 
34 |             select_value(<<-end_sql, "SCHEMA")
35 |               SELECT setval('#{quoted_sequence}', #{max_pk ? max_pk : minvalue}, #{max_pk ? true : false})
36 |             end_sql
37 |           end
38 |         end
39 |       end
40 |     end
41 |   end
42 | end
43 | 


--------------------------------------------------------------------------------
/test/dummy/config/initializers/secret_token.rb:
--------------------------------------------------------------------------------
 1 | # Be sure to restart your server when you modify this file.
 2 | 
 3 | # Your secret key for verifying the integrity of signed cookies.
 4 | # If you change this key, all old signed cookies will become invalid!
 5 | # Make sure the secret is at least 30 characters and all random,
 6 | # no regular words or you'll be exposed to dictionary attacks.
 7 | if ::Rails::VERSION::MAJOR < 4
 8 |   Dummy::Application.config.secret_token = '362b82703c06793883c00b35de475258c908cc0eadb14390268f1f17e40a60a53af28751de4cababe25abf13b11138051c8311dcdb802f8b581e60e1c24f70af'
 9 | else
10 |   Dummy::Application.config.secret_key_base = '362b82703c06793883c00b35de475258c908cc0eadb14390268f1f17e40a60a53af28751de4cababe25abf13b11138051c8311dcdb802f8b581e60e1c24f70af'
11 | end
12 | 


--------------------------------------------------------------------------------
/test/dummy/config/initializers/session_store.rb:
--------------------------------------------------------------------------------
1 | # Be sure to restart your server when you modify this file.
2 | 
3 | Dummy::Application.config.session_store :cookie_store, key: '_dummy_session'
4 | 
5 | # Use the database for sessions instead of the cookie-based default,
6 | # which shouldn't be used to store highly confidential information
7 | # (create the session table with "rails generate session_migration")
8 | # Dummy::Application.config.session_store :active_record_store
9 | 


--------------------------------------------------------------------------------
/test/dummy/config/initializers/wrap_parameters.rb:
--------------------------------------------------------------------------------
 1 | # Be sure to restart your server when you modify this file.
 2 | #
 3 | # This file contains settings for ActionController::ParamsWrapper which
 4 | # is enabled by default.
 5 | 
 6 | # Enable parameter wrapping for JSON. You can disable this by setting :format to an empty array.
 7 | ActiveSupport.on_load(:action_controller) do
 8 |   wrap_parameters format: [:json]
 9 | end
10 | 
11 | # Disable root element in JSON by default.
12 | ActiveSupport.on_load(:active_record) do
13 |   self.include_root_in_json = false
14 | end
15 | 


--------------------------------------------------------------------------------
/test/dummy/config/locales/active_support_extensions.yml:
--------------------------------------------------------------------------------
1 | en:
2 |   date:
3 |     formats:
4 |       long: '%B %d, %Y extended'
5 | 


--------------------------------------------------------------------------------
/test/dummy/config/locales/en.yml:
--------------------------------------------------------------------------------
 1 | en:
 2 |   date:
 3 |     abbr_day_names:
 4 |     - Sun
 5 |     - Mon
 6 |     - Tue
 7 |     - Wed
 8 |     - Thu
 9 |     - Fri
10 |     - Sat
11 |   scope:
12 |     hello_world: Hello World
13 |     text_with_translation_in_english: English translation
14 | 


--------------------------------------------------------------------------------
/test/dummy/config/locales/pl.yml:
--------------------------------------------------------------------------------
 1 | pl:
 2 |   date:
 3 |     abbr_day_names:
 4 |     - Nie
 5 |     - Pon
 6 |     - Wto
 7 |     - Śro
 8 |     - Czw
 9 |     - Pią
10 |     - Sob
11 |   scope:
12 |     hello_world: "Witaj świecie"
13 |     catan:
14 |       settlers: "Osadnicy z Catanu"
15 |     some_strange_key: "Abrakadabra dwa kije"
16 | 


--------------------------------------------------------------------------------
/test/dummy/config/locales/simple_form.en.yml:
--------------------------------------------------------------------------------
 1 | en:
 2 |   simple_form:
 3 |     "yes": 'Yes'
 4 |     "no": 'No'
 5 |     required:
 6 |       text: 'required'
 7 |       mark: '*'
 8 |       # You can uncomment the line below if you need to overwrite the whole required html.
 9 |       # When using html, text and mark won't be used.
10 |       # html: '<abbr title="required">*</abbr>'
11 |     error_notification:
12 |       default_message: "Please review the problems below:"
13 |     # Labels and hints examples
14 |     # labels:
15 |     #   defaults:
16 |     #     password: 'Password'
17 |     #   user:
18 |     #     new:
19 |     #       email: 'E-mail to sign in.'
20 |     #     edit:
21 |     #       email: 'E-mail.'
22 |     # hints:
23 |     #   defaults:
24 |     #     username: 'User name to sign in.'
25 |     #     password: 'No special characters, please.'
26 | 
27 | 


--------------------------------------------------------------------------------
/test/dummy/config/routes.rb:
--------------------------------------------------------------------------------
 1 | Rails.application.routes.draw do
 2 |   mount Lit::Engine => '/lit'
 3 | 
 4 |   devise_for :admins
 5 | 
 6 |   scope '(:locale)', locale: /en|pl|de/ do
 7 |     resources :projects
 8 |     get 'welcome' => 'welcome#index', :as => :welcome
 9 |     get 'catan' => 'welcome#catan', :as => :catan
10 |   end
11 | 
12 |   root to: 'welcome#index'
13 | 
14 | end
15 | 


--------------------------------------------------------------------------------
/test/dummy/db/migrate/20121106204557_devise_create_admins.rb:
--------------------------------------------------------------------------------
 1 | class DeviseCreateAdmins < Rails::VERSION::MAJOR >= 5   ?
 2 |                            ActiveRecord::Migration[4.2] :
 3 |                            ActiveRecord::Migration
 4 |   def change
 5 |     create_table(:admins) do |t|
 6 |       ## Database authenticatable
 7 |       t.string :email,              null: false, default: ''
 8 |       t.string :encrypted_password, null: false, default: ''
 9 | 
10 |       ## Recoverable
11 |       t.string :reset_password_token
12 |       t.datetime :reset_password_sent_at
13 | 
14 |       ## Rememberable
15 |       t.datetime :remember_created_at
16 | 
17 |       ## Trackable
18 |       t.integer :sign_in_count, default: 0
19 |       t.datetime :current_sign_in_at
20 |       t.datetime :last_sign_in_at
21 |       t.string :current_sign_in_ip
22 |       t.string :last_sign_in_ip
23 | 
24 |       ## Confirmable
25 |       # t.string   :confirmation_token
26 |       # t.datetime :confirmed_at
27 |       # t.datetime :confirmation_sent_at
28 |       # t.string   :unconfirmed_email # Only if using reconfirmable
29 | 
30 |       ## Lockable
31 |       # t.integer  :failed_attempts, :default => 0 # Only if lock strategy is :failed_attempts
32 |       # t.string   :unlock_token # Only if unlock strategy is :email or :both
33 |       # t.datetime :locked_at
34 | 
35 |       ## Token authenticatable
36 |       # t.string :authentication_token
37 | 
38 |       t.timestamps
39 |     end
40 | 
41 |     add_index :admins, :email,                unique: true
42 |     add_index :admins, :reset_password_token, unique: true
43 |     # add_index :admins, :confirmation_token,   :unique => true
44 |     # add_index :admins, :unlock_token,         :unique => true
45 |     # add_index :admins, :authentication_token, :unique => true
46 |   end
47 | end
48 | 


--------------------------------------------------------------------------------
/test/dummy/db/migrate/20121223141035_create_projects.rb:
--------------------------------------------------------------------------------
 1 | class CreateProjects < Rails::VERSION::MAJOR >= 5   ?
 2 |                        ActiveRecord::Migration[4.2] :
 3 |                        ActiveRecord::Migration
 4 | 
 5 |   def change
 6 |     create_table :projects do |t|
 7 |       t.string :name
 8 | 
 9 |       t.timestamps
10 |     end
11 |   end
12 | end
13 | 


--------------------------------------------------------------------------------
/test/dummy/lib/assets/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/prograils/lit/dc11ab3415524d16a6dfe40b130a07248dc65f2b/test/dummy/lib/assets/.gitkeep


--------------------------------------------------------------------------------
/test/dummy/log/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/prograils/lit/dc11ab3415524d16a6dfe40b130a07248dc65f2b/test/dummy/log/.gitkeep


--------------------------------------------------------------------------------
/test/dummy/public/404.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <title>The page you were looking for doesn't exist (404)</title>
 5 |   <style type="text/css">
 6 |     body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
 7 |     div.dialog {
 8 |       width: 25em;
 9 |       padding: 0 4em;
10 |       margin: 4em auto 0 auto;
11 |       border: 1px solid #ccc;
12 |       border-right-color: #999;
13 |       border-bottom-color: #999;
14 |     }
15 |     h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
16 |   </style>
17 | </head>
18 | 
19 | <body>
20 |   <!-- This file lives in public/404.html -->
21 |   <div class="dialog">
22 |     <h1>The page you were looking for doesn't exist.</h1>
23 |     <p>You may have mistyped the address or the page may have moved.</p>
24 |   </div>
25 | </body>
26 | </html>
27 | 


--------------------------------------------------------------------------------
/test/dummy/public/422.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <title>The change you wanted was rejected (422)</title>
 5 |   <style type="text/css">
 6 |     body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
 7 |     div.dialog {
 8 |       width: 25em;
 9 |       padding: 0 4em;
10 |       margin: 4em auto 0 auto;
11 |       border: 1px solid #ccc;
12 |       border-right-color: #999;
13 |       border-bottom-color: #999;
14 |     }
15 |     h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
16 |   </style>
17 | </head>
18 | 
19 | <body>
20 |   <!-- This file lives in public/422.html -->
21 |   <div class="dialog">
22 |     <h1>The change you wanted was rejected.</h1>
23 |     <p>Maybe you tried to change something you didn't have access to.</p>
24 |   </div>
25 | </body>
26 | </html>
27 | 


--------------------------------------------------------------------------------
/test/dummy/public/500.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <title>We're sorry, but something went wrong (500)</title>
 5 |   <style type="text/css">
 6 |     body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
 7 |     div.dialog {
 8 |       width: 25em;
 9 |       padding: 0 4em;
10 |       margin: 4em auto 0 auto;
11 |       border: 1px solid #ccc;
12 |       border-right-color: #999;
13 |       border-bottom-color: #999;
14 |     }
15 |     h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
16 |   </style>
17 | </head>
18 | 
19 | <body>
20 |   <!-- This file lives in public/500.html -->
21 |   <div class="dialog">
22 |     <h1>We're sorry, but something went wrong.</h1>
23 |   </div>
24 | </body>
25 | </html>
26 | 


--------------------------------------------------------------------------------
/test/dummy/public/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/prograils/lit/dc11ab3415524d16a6dfe40b130a07248dc65f2b/test/dummy/public/favicon.ico


--------------------------------------------------------------------------------
/test/dummy/script/rails:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env ruby
2 | # This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
3 | 
4 | APP_PATH = File.expand_path('../../config/application',  __FILE__)
5 | require File.expand_path('../../config/boot',  __FILE__)
6 | require 'rails/commands'
7 | 


--------------------------------------------------------------------------------
/test/fixtures/lit/files/import.csv.array:
--------------------------------------------------------------------------------
1 | key,en,pl
2 | scopes.csvarray,val0 en,"val0 pl"
3 | scopes.csvarray,val1 en,"val1 pl"
4 | scopes.csvarray,,"val2 pl"
5 | scopes.csvarray,val3 en,
6 | 


--------------------------------------------------------------------------------
/test/fixtures/lit/files/import.csv.array_with_nil:
--------------------------------------------------------------------------------
1 | key,en,pl
2 | scopes.csvarray,,
3 | scopes.csvarray,val0 en,"val0 pl"
4 | scopes.csvarray,val1 en,"val1 pl"
5 | scopes.csvarray,,"val2 pl"
6 | scopes.csvarray,val3 en,
7 | 


--------------------------------------------------------------------------------
/test/fixtures/lit/files/import.csv.malformed:
--------------------------------------------------------------------------------
1 | "haha""haha""
2 | 


--------------------------------------------------------------------------------
/test/fixtures/lit/files/import.csv.missing-locale:
--------------------------------------------------------------------------------
1 | key,en
2 | key1,val1
3 | 


--------------------------------------------------------------------------------
/test/fixtures/lit/files/import.csv.nil:
--------------------------------------------------------------------------------
1 | key,en,pl
2 | scopes.to_be_nil,,
3 | 


--------------------------------------------------------------------------------
/test/fixtures/lit/files/import.csv.normal:
--------------------------------------------------------------------------------
1 | key,en,pl
2 | scopes.foo,foo en,"foo pl"
3 | scopes.bar,"bar en",bar pl
4 | 


--------------------------------------------------------------------------------
/test/fixtures/lit/files/import.tsv.normal:
--------------------------------------------------------------------------------
1 | key	en	pl
2 | scopes.foo	foo en	"foo pl"
3 | 


--------------------------------------------------------------------------------
/test/fixtures/lit/files/import.yml.array:
--------------------------------------------------------------------------------
1 | en:
2 |   scopes:
3 |     csvarray: ['val0 en', 'val1 en', null, 'val3 en']
4 | pl:
5 |   scopes:
6 |     csvarray: ['val0 pl', 'val1 pl', 'val2 pl', null]
7 | 


--------------------------------------------------------------------------------
/test/fixtures/lit/files/import.yml.malformed:
--------------------------------------------------------------------------------
1 | ha: ha: ha
2 | 


--------------------------------------------------------------------------------
/test/fixtures/lit/files/import.yml.missing-locale:
--------------------------------------------------------------------------------
1 | en:
2 |   key1: val1
3 | 


--------------------------------------------------------------------------------
/test/fixtures/lit/files/import.yml.nil:
--------------------------------------------------------------------------------
1 | en:
2 |   scopes:
3 |     to_be_nil:
4 | pl:
5 |   scopes:
6 |     to_be_nil:
7 | 


--------------------------------------------------------------------------------
/test/fixtures/lit/files/import.yml.normal:
--------------------------------------------------------------------------------
1 | en:
2 |   scopes:
3 |     foo: foo en
4 |     bar: bar en
5 | pl:
6 |   scopes:
7 |     foo: foo pl
8 |     bar: bar pl
9 | 


--------------------------------------------------------------------------------
/test/fixtures/lit/files/import.yml.raw:
--------------------------------------------------------------------------------
1 | en:
2 |   hello:
3 |     world: 'Test'
4 |     nothing:
5 |     not_nil: ''
6 | 
7 | 


--------------------------------------------------------------------------------
/test/fixtures/lit/incomming_localizations.yml:
--------------------------------------------------------------------------------
 1 | # Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/Fixtures.html
 2 | 
 3 | one:
 4 |   translated_value: MyText
 5 |   locale: 
 6 |   localization_key: 
 7 |   locale_str: MyString
 8 |   localization_key_str: MyString
 9 |   source: 
10 | 
11 | two:
12 |   translated_value: MyText
13 |   locale: 
14 |   localization_key: 
15 |   locale_str: MyString
16 |   localization_key_str: MyString
17 |   source: 
18 | 


--------------------------------------------------------------------------------
/test/fixtures/lit/locales.yml:
--------------------------------------------------------------------------------
 1 | # Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/Fixtures.html
 2 | 
 3 | pl:
 4 |   locale: pl
 5 |   created_at: <%= Time.current %>
 6 |   updated_at: <%= Time.current %>
 7 | 
 8 | en:
 9 |   locale: en
10 |   created_at: <%= Time.current %>
11 |   updated_at: <%= Time.current %>
12 | 


--------------------------------------------------------------------------------
/test/fixtures/lit/localization_keys.yml:
--------------------------------------------------------------------------------
 1 | hello_world:
 2 |   localization_key: 'scopes.hello_world'
 3 |   created_at: <%= Time.current %>
 4 |   updated_at: <%= Time.current %>
 5 | 
 6 | array:
 7 |   localization_key: 'scopes.array'
 8 |   created_at: <%= Time.current %>
 9 |   updated_at: <%= Time.current %>
10 | 
11 | string:
12 |   localization_key: 'scopes.string'
13 |   created_at: <%= Time.current %>
14 |   updated_at: <%= Time.current %>
15 | 
16 | hash_main:
17 |   localization_key: 'scopes.hash'
18 |   created_at: <%= Time.current %>
19 |   updated_at: <%= Time.current %>
20 | 
21 | hash_sub_one:
22 |   localization_key: 'scopes.hash.sub_one'
23 |   created_at: <%= Time.current %>
24 |   updated_at: <%= Time.current %>
25 | 
26 | hash_sub_two:
27 |   localization_key: 'scopes.hash.sub_two'
28 |   created_at: <%= Time.current %>
29 |   updated_at: <%= Time.current %>
30 | 


--------------------------------------------------------------------------------
/test/fixtures/lit/localization_versions.yml:
--------------------------------------------------------------------------------
 1 | # Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/Fixtures.html
 2 | 
 3 | one:
 4 |   translated_value: MyText
 5 |   localization: 
 6 | 
 7 | two:
 8 |   translated_value: MyText
 9 |   localization: 
10 | 


--------------------------------------------------------------------------------
/test/fixtures/lit/localizations.yml:
--------------------------------------------------------------------------------
 1 | # Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/Fixtures.html
 2 | 
 3 | string:
 4 |   locale: en
 5 |   localization_key: string
 6 |   translated_value: value
 7 |   default_value: value
 8 |   created_at: <%= Time.current %>
 9 |   updated_at: <%= Time.current %>
10 | 
11 | array:
12 |   locale: en
13 |   localization_key: array
14 |   translated_value:
15 |     - one
16 |     - two
17 |     - three
18 |   default_value:
19 |     - one
20 |     - two
21 |     - three
22 |   created_at: <%= Time.current %>
23 |   updated_at: <%= Time.current %>
24 | 
25 | hash_main:
26 |   locale: en
27 |   localization_key: hash_main
28 |   translated_value: the_root
29 |   default_value: the_root
30 |   created_at: <%= Time.current %>
31 |   updated_at: <%= Time.current %>
32 |   
33 | hash_sub_one:
34 |   locale: en
35 |   localization_key: hash_sub_one
36 |   translated_value: left_leaf
37 |   default_value: left_leaf
38 |   created_at: <%= Time.current %>
39 |   updated_at: <%= Time.current %>
40 |   
41 | hash_sub_two:
42 |   locale: en
43 |   localization_key: hash_sub_two
44 |   translated_value: right_leaf
45 |   default_value: right_leaf
46 |   created_at: <%= Time.current %>
47 |   updated_at: <%= Time.current %>
48 | 


--------------------------------------------------------------------------------
/test/fixtures/lit/sources.yml:
--------------------------------------------------------------------------------
 1 | # Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/Fixtures.html
 2 | 
 3 | test:
 4 |   identifier: test
 5 |   url: http://testhost.com/lit
 6 |   api_key: test
 7 |   last_updated_at: '2013-09-23 18:21:41'
 8 |   updated_at: <%= Time.current %>
 9 |   created_at: <%= Time.current %>
10 | 


--------------------------------------------------------------------------------
/test/functional/lit/api/v1/locales_controller_test.rb:
--------------------------------------------------------------------------------
 1 | require 'test_helper'
 2 | 
 3 | module Lit
 4 |   class Api::V1::LocalesControllerTest < ActionController::TestCase
 5 |     def setup
 6 |       Lit.api_enabled = true
 7 |       Lit.api_key = 'test'
 8 |       @routes = Lit::Engine.routes
 9 |       request.env['HTTP_AUTHORIZATION'] = ActionController::HttpAuthentication::Token.encode_credentials('test')
10 |     end
11 | 
12 |     test 'should get index' do
13 |       get :index, format: :json
14 |       assert_response :success
15 |       response.body =~ /en/
16 |       response.body =~ /pl/
17 |     end
18 | 
19 |     test 'should not get index if api is disabled' do
20 |       Lit.api_enabled = false
21 |       Lit::Engine.routes.clear!
22 |       Dummy::Application.reload_routes!
23 |       @routes = Lit::Engine.routes
24 |       if defined?(ActionController::UrlGenerationError)
25 |         assert_raises(ActionController::UrlGenerationError) do
26 |           get :index, format: :json
27 |         end
28 |       else
29 |         assert_raises(ActionController::RoutingError) do
30 |           get :index, format: :json
31 |         end
32 |       end
33 |     end
34 | 
35 |     test 'should not be able to access if authorization token is invalid' do
36 |       request.env['HTTP_AUTHORIZATION'] = ActionController::HttpAuthentication::Token.encode_credentials('invalid')
37 |       get :index, format: :json
38 |       assert_response 401
39 |     end
40 | 
41 |     test 'should not be able to access if authorization token is missing' do
42 |       request.env.delete('HTTP_AUTHORIZATION')
43 |       get :index, format: :json
44 |       assert_response 401
45 |     end
46 |   end
47 | end
48 | 


--------------------------------------------------------------------------------
/test/functional/lit/api/v1/localization_keys_controller_test.rb:
--------------------------------------------------------------------------------
 1 | require 'test_helper'
 2 | 
 3 | module Lit
 4 |   class Api::V1::LocalizationKeysControllerTest < ActionController::TestCase
 5 |     def setup
 6 |       Lit::Localization.delete_all
 7 |       Lit::LocalizationKey.delete_all
 8 |       Lit::LocalizationVersion.delete_all
 9 |       Lit.loader = nil
10 |       Lit.api_enabled = true
11 |       Lit.api_key = 'test'
12 |       Lit::Engine.routes.clear!
13 |       Dummy::Application.reload_routes!
14 |       @routes = Lit::Engine.routes
15 |       request.env['HTTP_AUTHORIZATION'] = ActionController::HttpAuthentication::Token.encode_credentials('test')
16 |       Lit.ignore_yaml_on_startup = false
17 |       Lit.init
18 |     end
19 | 
20 |     def teardown
21 |       Lit.ignore_yaml_on_startup = nil
22 |     end
23 | 
24 |     test 'should get index' do
25 |       get :index, format: :json
26 |       assert_response :success
27 |     end
28 | 
29 |     test 'should only changed records' do
30 |       I18n.l(Time.now)
31 |       Lit::LocalizationKey.update_all ['updated_at=?', 2.hours.ago]
32 |       Lit::Localization.update_all ['updated_at=?', 2.hours.ago]
33 |       l = Lit::LocalizationKey.last
34 |       l.touch
35 |       l.localizations.each do |loc|
36 |         loc.update_column :is_changed, true
37 |       end
38 |       get :index, params: { format: :json, after: I18n.l(2.seconds.ago) }
39 |       assert_response :success
40 |       assert_equal 1, assigns(:localization_keys).count
41 |       assert response.body =~ /#{l.localization_key}/
42 |     end
43 |   end
44 | end
45 | 


--------------------------------------------------------------------------------
/test/functional/lit/api/v1/localizations_controller_test.rb:
--------------------------------------------------------------------------------
 1 | require 'test_helper'
 2 | 
 3 | module Lit
 4 |   class Api::V1::LocalizationsControllerTest < ActionController::TestCase
 5 |     def setup
 6 |       Lit::Localization.delete_all
 7 |       Lit::LocalizationKey.delete_all
 8 |       Lit::LocalizationVersion.delete_all
 9 |       Lit.loader = nil
10 |       Lit.api_enabled = true
11 |       Lit.api_key = 'test'
12 |       Lit::Engine.routes.clear!
13 |       Dummy::Application.reload_routes!
14 |       @routes = Lit::Engine.routes
15 |       request.env['HTTP_AUTHORIZATION'] = ActionController::HttpAuthentication::Token.encode_credentials('test')
16 |       Lit.ignore_yaml_on_startup = false
17 |       Lit.init
18 |     end
19 | 
20 |     def teardown
21 |       Lit.ignore_yaml_on_startup = nil
22 |     end
23 | 
24 |     test 'should get index' do
25 |       get :index, format: :json
26 |       assert_response :success
27 |     end
28 | 
29 |     test 'should only changed records' do
30 |       I18n.l(Time.now)
31 |       Lit::Localization.update_all ['updated_at=?', 2.hours.ago]
32 |       l = Lit::Localization.last
33 |       l.translated_value = 'test'
34 |       l.is_changed = true
35 |       l.save
36 |       get :index, params: { format: :json, after: 2.seconds.ago.to_s(:db) }
37 |       assert_response :success
38 |       assert_equal 1, assigns(:localizations).count
39 |       assert response.body =~ /#{l.value}/
40 |     end
41 | 
42 |     test 'should return last update date' do
43 |       I18n.l(Time.now)
44 |       Lit::Localization.update_all ['updated_at=?', 2.hours.ago]
45 |       l = Lit::Localization.last
46 |       l.translated_value = 'test'
47 |       l.save
48 |       get :last_change, format: :json
49 |       assert_response :success
50 |       assert_equal l, assigns(:localization)
51 |       assert response.body =~ /#{l.updated_at.to_s(:db)}/
52 | 
53 |     end
54 |   end
55 | end
56 | 


--------------------------------------------------------------------------------
/test/functional/lit/dashboard_controller_test.rb:
--------------------------------------------------------------------------------
 1 | require 'test_helper'
 2 | 
 3 | module Lit
 4 |   class DashboardControllerTest < ActionController::TestCase
 5 |     setup do
 6 |       @routes = Lit::Engine.routes
 7 |     end
 8 | 
 9 |     test 'should require auth / should redirect' do
10 |       Lit.authentication_function = :authenticate_admin!
11 |       get :index
12 |       assert_response 302
13 |     end
14 | 
15 |     test 'should show index if none auth function is defined' do
16 |       Lit.authentication_function = nil
17 |       get :index
18 |       assert_response :success
19 |     end
20 |   end
21 | end
22 | 


--------------------------------------------------------------------------------
/test/functional/lit/incomming_localizations_controller_test.rb:
--------------------------------------------------------------------------------
 1 | require 'test_helper'
 2 | 
 3 | module Lit
 4 |   class IncommingLocalizationsControllerTest < ActionController::TestCase
 5 |     fixtures 'lit/sources'
 6 |     set_fixture_class lit_sources: Lit::Source
 7 |     def setup
 8 |       Lit.authentication_function = nil
 9 |       @routes = Lit::Engine.routes
10 |       stub_request(:get, 'http://testhost.com/lit/api/v1/last_change.json').
11 |         to_return(body: { last_change: 1.hour.ago.to_s(:db) }.to_json)
12 |       @source = lit_sources(:test)
13 |     end
14 | 
15 |     test 'should get index' do
16 |       get :index, params: { source_id: @source.id }
17 |       assert_response :success
18 |     end
19 | 
20 |     test 'should properly return to index' do
21 |       get :accept_all, params: { source_id: @source.id }
22 |       assert_response :redirect
23 |     end
24 |   end
25 | end
26 | 


--------------------------------------------------------------------------------
/test/functional/lit/locales_controller_test.rb:
--------------------------------------------------------------------------------
 1 | require 'test_helper'
 2 | 
 3 | module Lit
 4 |   class LocalesControllerTest < ActionController::TestCase
 5 |     setup do
 6 |       @routes = Lit::Engine.routes
 7 | 
 8 |       Lit.authentication_function = nil
 9 |       @locale = Locale.first_or_create(locale: 'en')
10 |     end
11 | 
12 |     test 'should get index' do
13 |       get :index
14 |       assert_response :success
15 |       assert_not_nil assigns(:locales)
16 |     end
17 | 
18 |     test 'should hide locale' do
19 |       put :hide, params: { id: @locale, locale: {}, format: :js }
20 |       assert assigns(:locale).is_hidden?
21 |     end
22 | 
23 |     test 'should destroy locale' do
24 |       assert_difference('Locale.count', -1) do
25 |         delete :destroy, params: { id: @locale }
26 |       end
27 |     end
28 |   end
29 | end
30 | 


--------------------------------------------------------------------------------
/test/functional/lit/sources_controller_test.rb:
--------------------------------------------------------------------------------
 1 | require 'test_helper'
 2 | 
 3 | module Lit
 4 |   class SourcesControllerTest < ActionController::TestCase
 5 |     fixtures 'lit/sources'
 6 | 
 7 |     setup do
 8 |       Lit.authentication_function = nil
 9 |       @routes = Lit::Engine.routes
10 |       stub_request(:get, 'http://testhost.com/lit/api/v1/last_change.json').
11 |         to_return(body: { last_change: 1.hour.ago.to_s(:db) }.to_json)
12 |       @source = lit_sources(:test)
13 |     end
14 | 
15 |     test 'should get index' do
16 |       get :index
17 |       assert_response :success
18 |       assert_not_nil assigns(:sources)
19 |     end
20 | 
21 |     test 'should get new' do
22 |       get :new
23 |       assert_response :success
24 |     end
25 | 
26 |     test 'should create source' do
27 |       assert_difference('Source.count') do
28 |         post :create, params: {
29 |                         source: { identifier: 'test2',
30 |                                   url: 'http://testhost.com/lit',
31 |                                   api_key: 'blabla' }
32 |                       }
33 |       end
34 |       assert_redirected_to source_path(assigns(:source))
35 |     end
36 | 
37 |     test 'should show source' do
38 |       get :show, params: { id: @source }
39 |       assert_response :success
40 |     end
41 | 
42 |     test 'should get edit' do
43 |       get :edit, params: { id: @source }
44 |       assert_response :success
45 |     end
46 | 
47 |     test 'should update source' do
48 |         put :update, params: { id: @source, source: { identifier: 'test2' } }
49 |       assert_redirected_to source_path(assigns(:source))
50 |       @source.reload
51 |       assert_equal 'test2', @source.identifier
52 |     end
53 | 
54 |     test 'should update last_updates_at' do
55 |       prev_last_updated_at = @source.last_updated_at
56 |       put :touch, params: { id: @source }
57 |       assert_redirected_to source_path(assigns(:source))
58 |       @source.reload
59 |       assert_redirected_to @source
60 |       assert @source.last_updated_at > prev_last_updated_at
61 |     end
62 | 
63 |     test 'should destroy source' do
64 |       assert_difference('Source.count', -1) do
65 |         delete :destroy, params: { id: @source }
66 |       end
67 |       assert_redirected_to sources_path
68 |     end
69 | 
70 |     test 'should indicate sync completion' do
71 |       @source.update_column(:sync_complete, true)
72 |       get :sync_complete, params: { format: :json, id: @source.id }
73 |       body = JSON.parse(response.body)
74 |       assert_equal true, body['sync_complete']
75 |     end
76 |   end
77 | end
78 | 


--------------------------------------------------------------------------------
/test/functional/welcome_controller_test.rb:
--------------------------------------------------------------------------------
 1 | require 'test_helper'
 2 | 
 3 | class WelcomeControllerTest < ActionController::TestCase
 4 |   def setup
 5 |     Lit::Localization.delete_all
 6 |     Lit::LocalizationKey.delete_all
 7 |     Lit::LocalizationVersion.delete_all
 8 |     Lit.loader = nil
 9 |     Lit.ignore_yaml_on_startup = false
10 |     Lit.init
11 |   end
12 | 
13 |   def teardown
14 |     Lit.ignore_yaml_on_startup = nil
15 |   end
16 | 
17 |   test 'should properly show index' do
18 |     # $redis.flushall
19 |     get :index, params: { locale: :en }
20 |     assert_response :success
21 |     assert I18n.locale == :en
22 |   end
23 | 
24 |   test 'should properly load value from yaml' do
25 |     get :index, params: { locale: :en }
26 |     assert Lit::LocalizationKey.where(localization_key: 'date.abbr_day_names').exists?
27 |     assert_equal I18n.t('date.abbr_day_names'), %w( Sun Mon Tue Wed Thu Fri Sat )
28 |   end
29 | 
30 |   test 'should properly store key with default value' do
31 |     get :index, params: { locale: :en }
32 |     localization_key = Lit::LocalizationKey.where(localization_key: 'scope.text_with_default').first
33 |     assert localization_key.present?
34 |     locale = Lit::Locale.find_by(locale: :en)
35 |     localization = localization_key.localizations.find_by(locale_id: locale.id)
36 |     assert_equal localization.translation, 'Default content'
37 |     assert_equal localization.to_s, 'Default content'
38 |     assert_equal localization.default_value, 'Default content'
39 |   end
40 | end
41 | 


--------------------------------------------------------------------------------
/test/integration/lit/backend_test.rb:
--------------------------------------------------------------------------------
 1 | # encoding: utf-8
 2 | require 'test_helper'
 3 | 
 4 | class BackendTest < ActionDispatch::IntegrationTest
 5 |   def setup
 6 |     @old_locale = I18n.locale
 7 |     I18n.locale = :pl
 8 |   end
 9 | 
10 |   def teardown
11 |     I18n.locale = @old_locale
12 |   end
13 | 
14 |   test 'when generating locale while listing localizations it should copy default_value' do
15 |     Lit.authentication_function = nil
16 |     Lit::Locale.where(locale: 'en').first_or_create
17 |     I18n.t('prograils.swag', default: 'Prograils codelovers')
18 |     lk = Lit::LocalizationKey.find_by(localization_key: 'prograils.swag')
19 |     assert lk.present?
20 |     visit('/lit/localization_keys')
21 |     lk.reload
22 |     assert lk.localizations.map(&:default_value).compact.count == Lit::Locale.all.count
23 |   end
24 | end
25 | 


--------------------------------------------------------------------------------
/test/integration/lit/locales_test.rb:
--------------------------------------------------------------------------------
 1 | # encoding: utf-8
 2 | require 'test_helper'
 3 | 
 4 | class LocalesTest < ActionDispatch::IntegrationTest
 5 |   def setup
 6 |     Lit.ignore_yaml_on_startup = false
 7 |     Lit.init
 8 |   end
 9 | 
10 |   def teardown
11 |     Lit.ignore_yaml_on_startup = nil
12 |   end
13 | 
14 |   test 'should allow hiding locale' do
15 |     Lit.authentication_function = nil
16 |     # visit('/pl/welcome')
17 |     visit('/lit/localization_keys')
18 |     # within('td.locale_row:last-child') do
19 |     # Lit.init.logger.info page.body
20 |     # assert has_content?('pl')
21 |     # end
22 |     assert(all('td.locale_row').last.text =~ /pl/)
23 |     l = Lit::Locale.where(locale: 'pl').first
24 |     l.is_hidden = true
25 |     l.save
26 |     visit('/lit/localization_keys')
27 |     assert(!(all('td.locale_row').last.text =~ /pl/))
28 | 
29 |   end
30 | end
31 | 


--------------------------------------------------------------------------------
/test/integration/lit/projects_test.rb:
--------------------------------------------------------------------------------
 1 | # encoding: utf-8
 2 | require 'test_helper'
 3 | 
 4 | class ProjectsTest < ActionDispatch::IntegrationTest
 5 |   setup do
 6 |     @old = Lit.humanize_key
 7 |   end
 8 |   teardown do
 9 |     Lit.humanize_key = @old
10 |   end
11 | 
12 |   test 'should display translated project name' do
13 |     Lit.humanize_key = true
14 |     visit('/en/projects/new')
15 |     locale = Lit::Locale.where('locale=?', 'en').first
16 |     localization_key = Lit::LocalizationKey.find_by_localization_key! 'helpers.label.project.name'
17 |     localization = localization_key.localizations.where(locale_id: locale.id).first
18 |     assert_equal 'Name', localization.to_s
19 |     assert_equal 'Name', localization.default_value
20 |   end
21 | 
22 |   test 'should have error messages' do
23 |     post '/en/projects', params: { project: { name: '' } }
24 |     locale = Lit::Locale.where('locale=?', 'en').first
25 |     localization_key = Lit::LocalizationKey.find_by_localization_key! 'activerecord.errors.models.project.attributes.name.blank'
26 |     localization = localization_key.localizations.where(locale_id: locale.id).first
27 |     assert_nil localization.to_s
28 |     assert_nil localization.default_value
29 |   end
30 | 
31 |   test 'should have error message humanized' do
32 |     Lit.humanize_key = true
33 |     if ::Rails::VERSION::MAJOR < 5
34 |       post '/en/projects', project: { name: '' }
35 |     else
36 |       post '/en/projects', params: { project: { name: '' } }
37 |     end
38 |     locale = Lit::Locale.where('locale=?', 'en').first
39 |     localization_key = Lit::LocalizationKey.find_by_localization_key! 'activerecord.errors.models.project.attributes.name.blank'
40 |     localization = localization_key.localizations.where(locale_id: locale.id).first
41 |     assert_equal 'Blank', localization.to_s
42 |     assert_equal 'Blank', localization.default_value
43 |   end
44 | end
45 | 


--------------------------------------------------------------------------------
/test/lib/raw_import_task_test.rb:
--------------------------------------------------------------------------------
 1 | require 'test_helper'
 2 | require 'rake'
 3 | 
 4 | class RawImportTaskTest < ActiveSupport::TestCase
 5 |   def setup
 6 |     path = Lit::Engine.root.join('test', 'fixtures', 'lit', 'files', 'import.yml.raw')
 7 |     @locales = Rails.root.join('config', 'locales', 'import.yml')
 8 |     FileUtils.cp path, @locales
 9 |     Rake::Task.clear
10 |     Lit::Engine.load_tasks
11 |     Rake::Task.define_task(:environment)
12 |     @old_files = ENV['FILES']
13 |     @old_locale = ENV['LOCALE']
14 |     @old_skip_nil = ENV['SKIP_NIL']
15 |     ENV['FILES'] = 'import.yml'
16 |     ENV['LOCALE'] = 'en'
17 |   end
18 | 
19 |   def teardown
20 |     ENV['FILES'] = @old_files
21 |     ENV['LOCALE'] = @old_locale
22 |     ENV['SKIP_NIL'] = @old_skip_nil
23 |     FileUtils.rm @locales
24 |   end
25 | 
26 |   test 'imports locale from selected file and skips nil values' do
27 |     ENV['SKIP_NIL'] = 'true'
28 |     assert Lit::LocalizationKey.where(localization_key: 'hello.world').empty?
29 |     assert Lit::LocalizationKey.where(localization_key: 'hello.nothing').empty?
30 |     assert Lit::LocalizationKey.where(localization_key: 'hello.not_nil').empty?
31 |     Rake::Task['lit:raw_import'].invoke
32 |     assert Lit::LocalizationKey.where(localization_key: 'hello.world').present?
33 |     assert Lit::LocalizationKey.where(localization_key: 'hello.nothing').empty?
34 |     assert Lit::LocalizationKey.where(localization_key: 'hello.not_nil').present?
35 |   end
36 | 
37 |   test 'imports locale from selected file and imports nil values' do
38 |     ENV['SKIP_NIL'] = 'false'
39 |     assert Lit::LocalizationKey.where(localization_key: 'hello.world').empty?
40 |     assert Lit::LocalizationKey.where(localization_key: 'hello.nothing').empty?
41 |     assert Lit::LocalizationKey.where(localization_key: 'hello.not_nil').empty?
42 |     Rake::Task['lit:raw_import'].invoke
43 |     assert Lit::LocalizationKey.where(localization_key: 'hello.world').present?
44 |     assert Lit::LocalizationKey.where(localization_key: 'hello.nothing').present?
45 |     assert Lit::LocalizationKey.where(localization_key: 'hello.not_nil').present?
46 |   end
47 | end
48 | 


--------------------------------------------------------------------------------
/test/lit_test.rb:
--------------------------------------------------------------------------------
1 | require 'test_helper'
2 | 
3 | class LitTest < ActiveSupport::TestCase
4 |   test 'truth' do
5 |     assert_kind_of Module, Lit
6 |   end
7 | end
8 | 


--------------------------------------------------------------------------------
/test/services/lit/synchronize_source_service_test.rb:
--------------------------------------------------------------------------------
 1 | require 'test_helper'
 2 | 
 3 | # Applicable only in an ActiveJob-enabled environment (Rails 4.2+ or 4.0/4.1
 4 | # with additional gem)
 5 | if defined?(ActiveJob)
 6 |   module Lit
 7 |     class SynchronizeSourceServiceTest < ActiveSupport::TestCase
 8 |       fixtures :all
 9 | 
10 |       def setup
11 |         after = 3.hours.ago
12 |         after_str = after.strftime('%F %T')
13 |         after_param = Rack::Utils.escape(after_str)
14 |         @source = Source.first
15 |         @source.update_column(:last_updated_at, after)
16 |         localizations_addr = "http://testhost.com/lit/api/v1/localizations.json?after=#{after_param}"
17 |         last_change_addr = 'http://testhost.com/lit/api/v1/last_change.json'
18 |         stub_request(:get, localizations_addr).to_return(
19 |           body:
20 |             Localization
21 |               .all
22 |               .as_json(
23 |                 root: false,
24 |                 only: %i[id localization_key_id locale_id],
25 |                 methods: %i[value localization_key_str locale_str localization_key_is_deleted],
26 |               )
27 |               .to_json,
28 |         )
29 |         stub_request(:get, last_change_addr).to_return(body: { last_change: after_str }.to_json)
30 |       end
31 | 
32 |       test 'synchronization works for different values' do
33 |         assert_equal 0, @source.incomming_localizations.count
34 |         Localization.all.each do |lc|
35 |           lc.translated_value << 'test'
36 |           lc.is_changed = true
37 |           lc.save
38 |         end
39 |         SynchronizeSourceService.new(@source).execute
40 |         assert_equal 5, @source.incomming_localizations.count
41 |       end
42 | 
43 |       test 'synchronization ignores same values' do
44 |         assert_equal 0, @source.incomming_localizations.count
45 |         SynchronizeSourceService.new(@source).execute
46 |         assert_equal 0, @source.incomming_localizations.count
47 |       end
48 |     end
49 |   end
50 | end
51 | 


--------------------------------------------------------------------------------
/test/support/clear_redis.rb:
--------------------------------------------------------------------------------
1 | require 'redis'
2 | def clear_redis
3 |   if defined?($redis) && !$redis.nil?
4 |     keys = $redis.keys(Lit.storage_options[:prefix] + '*')
5 |     $redis.del keys unless keys.empty?
6 |   end
7 | end
8 | 


--------------------------------------------------------------------------------
/test/support/en.yml:
--------------------------------------------------------------------------------
1 | en:
2 |   foo: bar
3 |   nil_thing:
4 | 


--------------------------------------------------------------------------------
/test/support/en_changed.yml:
--------------------------------------------------------------------------------
1 | en:
2 |   foo: barbar
3 |   nil_thing: not nil anymore
4 | 


--------------------------------------------------------------------------------
/test/support/redis_prefix.rb:
--------------------------------------------------------------------------------
1 | Lit.storage_options = { prefix: '_test_' }
2 | 


--------------------------------------------------------------------------------
/test/test_helpers/warden.rb:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/prograils/lit/dc11ab3415524d16a6dfe40b130a07248dc65f2b/test/test_helpers/warden.rb


--------------------------------------------------------------------------------
/test/unit/helpers/lit/dashboard_helper_test.rb:
--------------------------------------------------------------------------------
1 | require 'test_helper'
2 | 
3 | module Lit
4 |   class DashboardHelperTest < ActionView::TestCase
5 |   end
6 | end
7 | 


--------------------------------------------------------------------------------
/test/unit/helpers/lit/sources_helper_test.rb:
--------------------------------------------------------------------------------
 1 | require 'test_helper'
 2 | 
 3 | class SourcesHelperTest < ActionView::TestCase
 4 |   include Lit::SourcesHelper
 5 |   
 6 |   def setup
 7 |     @source = Lit::Source.new
 8 |   end
 9 | 
10 |   test 'returns "loaded" when source sync is complete' do
11 |     @source.sync_complete = true
12 |     assert_equal source_loading_class(@source), 'loaded'
13 |   end
14 | 
15 |   test 'returns "loading" when source sync is not complete' do
16 |     @source.sync_complete = false
17 |     assert_equal source_loading_class(@source), 'loading'
18 |   end
19 | end
20 | 


--------------------------------------------------------------------------------
/test/unit/i18n_backend_test.rb:
--------------------------------------------------------------------------------
 1 | require 'test_helper'
 2 | 
 3 | class I18nBackendTest < ActiveSupport::TestCase
 4 |   fixtures 'lit/locales'
 5 |   class Backend < Lit::I18nBackend
 6 |   end
 7 | 
 8 |   def setup
 9 |     @old_backend = I18n.backend
10 |     @old_locale = I18n.locale
11 |     @old_humanize_key = Lit.humanize_key
12 |     @old_available_locales = ::Rails.configuration.i18n.available_locales
13 |   end
14 | 
15 |   def teardown
16 |     ::Rails.configuration.i18n.available_locales = @old_available_locales
17 |     I18n.backend = @old_backend
18 |     I18n.backend = @old_backend
19 |     I18n.locale = @old_locale
20 |     Lit.humanize_key = @old_humanize_key
21 |   end
22 | 
23 |   test 'properly returns available locales' do
24 |     I18n.backend = Backend.new(Lit.loader.cache)
25 |     assert_equal 2, I18n.backend.available_locales.count
26 |     ::Rails.configuration.i18n.available_locales = [:en, :pl]
27 |     I18n.backend = Backend.new(Lit.loader.cache)
28 |     assert_equal 2, I18n.backend.available_locales.count
29 |     ::Rails.configuration.i18n.available_locales = [:en]
30 |     I18n.backend = Backend.new(Lit.loader.cache)
31 |     assert_equal 1, I18n.backend.available_locales.count
32 |   end
33 | 
34 |   test 'auto-humanizes key when Lit.humanize_key=true' do
35 |     # since Rails 6.1 pure i18n calls should not be humanized
36 |     skip if I18n.backend.send(:on_rails_6_1_or_higher?)
37 |     Lit.humanize_key = true
38 |     I18n.locale = :en
39 |     test_key = 'this_will_get_humanized'
40 |     humanized_key = 'This will get humanized'
41 |     assert_equal I18n.t(test_key), humanized_key
42 |     lk = Lit::LocalizationKey.find_by localization_key: test_key
43 |     locale = Lit::Locale.find_by locale: 'en'
44 |     l = lk.localizations.where(locale: locale).first
45 |     assert_equal l.default_value, humanized_key
46 |   end
47 | 
48 |   test 'wont humanize key, if key is ignored' do
49 |     Lit.humanize_key = true
50 |     I18n.locale = :en
51 |     test_key = 'date.this_will_get_humanized'
52 |     assert_equal I18n.t(test_key), 'translation missing: en.date.this_will_get_humanized'
53 |     lk = Lit::LocalizationKey.find_by localization_key: test_key
54 |     locale = Lit::Locale.find_by locale: 'en'
55 |     l = lk.localizations.where(locale: locale).first
56 |     assert_nil l.default_value
57 |   end
58 | 
59 |   test 'will not call additional queries when nil values in a fallback key chain have been cached' do
60 |     Lit.humanize_key = false
61 |     I18n.locale = :en
62 | 
63 |     test_key = :'test.key'
64 |     fallback_key = :'test.fallback'
65 | 
66 |     # first, when these keys don't exist in the DB yet, they should be created:
67 |     loc_key_count = -> { Lit::LocalizationKey.where(localization_key: [test_key, fallback_key]).count }
68 |     assert_equal 0, loc_key_count.call
69 |     assert_equal 'foobar', I18n.t(test_key, default: [fallback_key, 'foobar'])
70 |     # We do not create localization key record for fallback keys if value is found
71 |     assert_equal 1, loc_key_count.call
72 | 
73 |     # on subsequent translation calls, they should not be fetched from DB
74 |     assert_no_database_queries do
75 |       assert_equal 'foobar', I18n.t(test_key, default: [fallback_key, 'foobar'])
76 |     end
77 |   end
78 | end
79 | 


--------------------------------------------------------------------------------
/test/unit/lit/cloud_translation/providers/examples.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | def cloud_provider_examples(described_klass)
 4 |   let(:text) { 'The quick brown fox jumps over the lazy dog.' }
 5 |   let(:from) { 'en' }
 6 |   let(:to) { 'pl' }
 7 | 
 8 |   describe 'when only :to language is given' do
 9 |     subject do
10 |       described_klass.translate(text: text, to: to)
11 |     end
12 | 
13 |     describe 'when single string is given' do
14 |       it 'translates single string to target language' do
15 |         _(subject).must_match(/\blis\b/)
16 |       end
17 | 
18 |       describe 'when string contains interpolation' do
19 |         let(:text) { 'here is your %{meal}, enjoy' }
20 | 
21 |         it 'does not translate stuff enclosed in %{}' do
22 |           _(subject).must_match(/%{meal}/)
23 |         end
24 |       end
25 | 
26 |     end
27 | 
28 |     describe 'when array of strings is given' do
29 |       let(:text) { %w[awesome stuff] }
30 | 
31 |       it 'translates array of strings to target language' do
32 |         _(subject.length).must_equal 2
33 |       end
34 |     end
35 | 
36 |     describe 'when array containing nil values is given' do
37 |       let(:text) { [nil, 'awesome', nil, 'stuff'] }
38 | 
39 |       it 'translates array to target language, converting nil to ""' do
40 |         _(subject.first).must_equal ''
41 |         _(subject.second).must_be :present?
42 |         _(subject.third).must_equal ''
43 |         _(subject.fourth).must_be :present?
44 |         _(subject.length).must_equal 4
45 |       end
46 |     end
47 |   end
48 | 
49 |   describe 'when :from and :to languages are given' do
50 |     subject do
51 |       described_klass.translate(text: text, from: from, to: to)
52 |     end
53 | 
54 |     describe 'when single string is given' do
55 |       it 'translates single string to target language' do
56 |         _(subject).must_match(/\blis\b/)
57 |       end
58 |     end
59 | 
60 |     describe 'when array of strings is given' do
61 |       let(:text) { %w[awesome stuff] }
62 | 
63 |       it 'translates array of strings to target language' do
64 |         _(subject.length).must_equal 2
65 |       end
66 |     end
67 |   end
68 | end
69 | 


--------------------------------------------------------------------------------
/test/unit/lit/cloud_translation/providers/yandex_test.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | require 'test_helper'
 4 | require 'lit/cloud_translation/providers/yandex'
 5 | require 'minitest/mock'
 6 | 
 7 | require_relative 'examples'
 8 | 
 9 | describe Lit::CloudTranslation::Providers::Yandex,
10 |          vcr: {
11 |            match_requests_on: [:method,
12 |                                VCR.request_matchers.uri_without_param(:key)],
13 |            record: :none # set :all and provide YANDEX_TRANSLATE_API_KEY to write tests
14 |          } do
15 |   cloud_provider_examples(Lit::CloudTranslation::Providers::Yandex)
16 | 
17 |   describe 'when non-OK response comes in from yandex' do
18 |     before do
19 |       Net::HTTP.stubs(:get_response).with(anything).returns(
20 |         OpenStruct.new(body: '{ "code": 401, "message": "Something odd happened" }')
21 |       )
22 |     end
23 | 
24 |     it 'raises Lit::CloudTranslation::TranslationError' do
25 |       assert_raises Lit::CloudTranslation::TranslationError do
26 |         Lit::CloudTranslation::Providers::Yandex.translate(text: text, to: to)
27 |       end
28 |     end
29 |   end
30 | end
31 | 


--------------------------------------------------------------------------------
/test/unit/lit/incomming_localization_test.rb:
--------------------------------------------------------------------------------
 1 | require 'test_helper'
 2 | 
 3 | module Lit
 4 |   class IncommingLocalizationTest < ActiveSupport::TestCase
 5 |     def setup
 6 |       DatabaseCleaner.clean_with :truncation
 7 |       stub_request(:get, 'http://testhost.com/lit/api/v1/last_change.json').to_return(
 8 |         body: { last_change: 1.hour.ago.to_s(:db) }.to_json,
 9 |       )
10 |       @source = Lit::Source.create url: 'http://testhost.com/lit', api_key: 'test', identifier: 'test'
11 |     end
12 | 
13 |     test 'on accept deletes itself and creates all missing records' do
14 |       assert_equal 0, Locale.count
15 |       assert_equal 0, Localization.count
16 |       assert_equal 0, LocalizationKey.count
17 |       il =
18 |         IncommingLocalization.create locale_str: 'de',
19 |                                      localization_key_str: 'scope.test',
20 |                                      translated_value: 'scope.test',
21 |                                      source: @source
22 |       assert_equal 0, Locale.count
23 |       assert_equal 0, Localization.count
24 |       assert_equal 0, LocalizationKey.count
25 |       il.accept
26 |       assert_equal 1, Locale.count
27 |       assert_equal 1, Localization.count
28 |       assert_equal 1, LocalizationKey.count
29 |       assert_equal true, Localization.first.is_changed?
30 |     end
31 | 
32 |     test '#duplicated? returns true when localization key is deleted' do
33 |       locale = Locale.create locale: 'en'
34 |       l_k = LocalizationKey.create localization_key: 'test'
35 |       localization = Localization.create locale: locale, localization_key: l_k, default_value: 'test test'
36 |       il =
37 |         IncommingLocalization.create locale_str: locale.locale,
38 |                                      localization_key_str: l_k.localization_key,
39 |                                      translated_value: localization.translated_value,
40 |                                      localization: localization,
41 |                                      source: @source
42 |       assert il.duplicated?('test test')
43 |     end
44 | 
45 |     test '#duplicated? returns false when incomming localization key is deleted' do
46 |       locale = Locale.create locale: 'en'
47 |       l_k = LocalizationKey.create localization_key: 'test'
48 |       localization = Localization.create locale: locale, localization_key: l_k, translated_value: 'test test'
49 |       il =
50 |         IncommingLocalization.create locale_str: locale.locale,
51 |                                      localization_key_str: l_k.localization_key,
52 |                                      translated_value: localization.translated_value,
53 |                                      localization: localization,
54 |                                      source: @source,
55 |                                      localization_key_is_deleted: true
56 |       assert_not il.duplicated?('test test')
57 |     end
58 |   end
59 | end
60 | 


--------------------------------------------------------------------------------
/test/unit/lit/locale_test.rb:
--------------------------------------------------------------------------------
 1 | require 'test_helper'
 2 | 
 3 | module Lit
 4 |   class LocaleTest < ActiveSupport::TestCase
 5 |     fixtures 'lit/locales'
 6 | 
 7 |     test 'uniqueness checking' do
 8 |       l = lit_locales(:pl)
 9 |       locale = Lit::Locale.new(locale: l.locale)
10 |       assert (!locale.valid?)
11 |     end
12 |   end
13 | end
14 | 


--------------------------------------------------------------------------------
/test/unit/lit/localization_key_test.rb:
--------------------------------------------------------------------------------
 1 | require 'test_helper'
 2 | 
 3 | module Lit
 4 |   class LocalizationKeyTest < ActiveSupport::TestCase
 5 |     fixtures 'lit/localization_keys'
 6 | 
 7 |     setup do
 8 |       @lk = Lit::LocalizationKey.create(localization_key: 'testing')
 9 |       @locale_en = Lit::Locale.create(locale: :en)
10 |       @locale_pl = Lit::Locale.create(locale: :pl)
11 |       @loc1 = @lk.localizations.create translated_value: 'test',
12 |                                        locale: @locale_en
13 |       @loc2 = @lk.localizations.create translated_value: 'test',
14 |                                        locale: @locale_pl
15 |     end
16 | 
17 |     test 'uniqueness checking' do
18 |       lk = Lit::LocalizationKey.new(localization_key: @lk.localization_key)
19 |       assert_not lk.valid?
20 |     end
21 | 
22 |     test 'when all localizations are changed, localization key should mark as completed' do
23 |       assert_not @lk.is_completed
24 |       @loc1.update is_changed: true
25 |       @loc2.update is_changed: true
26 |       assert @lk.reload.is_completed
27 |     end
28 | 
29 |     test '#change_all_completed should mark everything as changed/completed' do
30 |       assert_not @lk.is_completed
31 |       assert_not @loc1.is_changed
32 |       assert_not @loc2.is_changed
33 |       @lk.change_all_completed
34 |       assert @lk.reload.is_completed
35 |       assert @loc1.reload.is_changed
36 |       assert @loc2.reload.is_changed
37 |     end
38 | 
39 |     test '#soft_destroy should mark translation key as deleted and translations as completed' do
40 |       assert_not @lk.is_completed
41 |       assert_not @loc1.is_changed
42 |       assert_not @loc2.is_changed
43 |       @lk.soft_destroy
44 |       assert @lk.reload.is_deleted
45 |       assert @lk.localizations.all?(&:is_changed)
46 |     end
47 | 
48 |     test '#soft_destroy should delete translation key from memoized objects' do
49 |       lk_obj_cache = Lit.init.cache.instance_variable_get(:@localization_key_object_cache)
50 |       Lit.init.cache.refresh_key("en.#{@lk.localization_key}")
51 |       assert lk_obj_cache[@lk.localization_key] == @lk
52 |       @lk.soft_destroy
53 |       refute lk_obj_cache.key?(@lk.localization_key)
54 |     end
55 | 
56 |     test '#restore should restore translation key' do
57 |       @lk.change_all_completed
58 |       @lk.update is_deleted: true, is_visited_again: true
59 |       assert @lk.is_deleted
60 |       assert @lk.is_completed
61 |       assert @lk.is_visited_again
62 |       @lk.restore
63 |       assert_not @lk.is_deleted
64 |       assert_not @lk.is_completed
65 |       assert_not @lk.is_visited_again
66 |     end
67 |   end
68 | end
69 | 


--------------------------------------------------------------------------------
/test/unit/lit/localization_test.rb:
--------------------------------------------------------------------------------
 1 | require 'test_helper'
 2 | 
 3 | module Lit
 4 |   class LocalizationTest < ActiveSupport::TestCase
 5 |     def setup
 6 |       Lit::Localization.delete_all
 7 |       Lit::LocalizationKey.delete_all
 8 |       Lit::LocalizationVersion.delete_all
 9 |       Lit.loader = nil
10 |       Lit.ignore_yaml_on_startup = false
11 |       Lit.init
12 |       I18n.locale = :en
13 |     end
14 | 
15 |     def teardown
16 |       Lit.ignore_yaml_on_startup = nil
17 |     end
18 | 
19 |     test 'does not create version upon creation' do
20 |       assert_no_difference 'Lit::LocalizationVersion.count' do
21 |         Lit.init.cache.reset
22 |         assert_equal 'English translation', I18n.t('scope.text_with_translation_in_english')
23 |       end
24 |     end
25 | 
26 |     test 'does create new version upon update via model' do
27 |       assert_difference 'Lit::LocalizationVersion.count' do
28 |         Lit.init.cache.reset
29 |         assert_equal 'English translation', I18n.t('scope.text_with_translation_in_english')
30 |         lang = Lit::Locale.find_by_locale('en')
31 |         lk = Lit::LocalizationKey.find_by_localization_key('scope.text_with_translation_in_english')
32 |         l = Lit::Localization.where('localization_key_id=?', lk).where('locale_id=?', lang).first
33 |         assert_not_nil l
34 |         l.update_attribute :is_changed, false
35 |         l.reload
36 |         l.translated_value = 'test'
37 |         l.save!
38 |         l.update_attribute :is_changed, true
39 |         l.reload
40 |         assert_equal true, l.is_changed?
41 |       end
42 |       Lit.init.cache.reset
43 |       assert_equal 'test', I18n.t('scope.text_with_translation_in_english')
44 |     end
45 | 
46 |     test 'does not set is_changed to true upon update via model' do
47 |       assert_equal 'English translation', I18n.t('scope.text_with_translation_in_english')
48 |       l = Lit::Localization.first
49 |       assert_equal false, l.is_changed?
50 |       l.update(translated_value: 'Test')
51 |       assert_equal false, l.is_changed?
52 |     end
53 |   end
54 | 
55 |   test 'after update cache should be modified' do
56 |     locale = Lit::Locale.find_by_locale('en')
57 |     lk = Lit::LocalizationKey.first
58 |     loc = lk.localizations.create locale: locale, is_changed: false
59 |     assert_not Lit.init.cache[loc.full_key]
60 |     loc.update translated_value: 'test'
61 |     assert_equal Lit.init.cache[loc.full_key], 'test'
62 |   end
63 | end
64 | 


--------------------------------------------------------------------------------
/test/unit/lit/localization_version_test.rb:
--------------------------------------------------------------------------------
 1 | require 'test_helper'
 2 | 
 3 | module Lit
 4 |   class LocalizationVersionTest < ActiveSupport::TestCase
 5 |     # test "the truth" do
 6 |     #   assert true
 7 |     # end
 8 |   end
 9 | end
10 | 


--------------------------------------------------------------------------------
/test/unit/lit/services/localization_keys_to_hash_service_test.rb:
--------------------------------------------------------------------------------
 1 | require 'test_helper'
 2 | 
 3 | module Lit
 4 |   module Services
 5 |     class LocalizationKeysToHashServiceTest < ActiveSupport::TestCase
 6 |       test 'accepts flat hash of keys/translations and forms a tree' do
 7 |         flat_hash = { 'en.js.layouts.back' => 'Back', 'en.js.layouts.home' => 'Home', 'en.js.common.new' => 'New' }
 8 |         result = LocalizationKeysToHashService.call(flat_hash)
 9 |         assert_equal result.keys.length, 1
10 |         inner = result['en']['js']
11 |         assert inner.key?('layouts')
12 |         assert inner.key?('common')
13 |         assert_equal inner['layouts']['home'], 'Home'
14 |         assert_equal inner['common']['new'], 'New'
15 |       end
16 |     end
17 |   end
18 | end
19 | 


--------------------------------------------------------------------------------
/test/unit/lit/source_test.rb:
--------------------------------------------------------------------------------
 1 | require 'test_helper'
 2 | 
 3 | module Lit
 4 |   class SourceTest < ActiveSupport::TestCase
 5 |     fixtures 'lit/sources'
 6 |     def setup
 7 |       stub_request(:get, 'http://testhost.com/lit/api/v1/last_change.json').
 8 |           to_return(body: { last_change: 1.hour.ago.to_s(:db) }.to_json)
 9 |       stub_request(:get, 'http://testhost.nope/lit/api/v1/last_change.json').
10 |           to_return(body: 'Nothing to be found around here', status: 404)
11 |     end
12 |     test 'validates url validation' do
13 |       s = Lit::Source.new
14 |       s.url = 'http://testhost.com/lit'
15 |       s.api_key = 'test'
16 |       s.identifier = 'test'
17 |       assert s.valid?
18 |       assert s.errors.empty?
19 |       s.url = 'http://testhost.nope/lit'
20 |       assert !s.valid?
21 |       assert !s.errors.empty?
22 |     end
23 | 
24 |     test 'touch_last_update_at! updates timestamp' do
25 |       s = lit_sources(:test)
26 |       assert s.last_updated_at < 5.seconds.ago
27 |       previous_updated_at = s.last_updated_at
28 |       s.touch_last_updated_at!
29 |       s.reload
30 |       assert s.last_updated_at > previous_updated_at
31 |     end
32 | 
33 |     test 'should set last_updated_at upon source creation' do
34 |       Lit.set_last_updated_at_upon_creation = true
35 |       s = Lit::Source.new
36 |       s.url = 'http://testhost.com/lit'
37 |       s.api_key = 'test'
38 |       s.identifier = 'test'
39 |       s.save!
40 |       s.reload
41 |       assert s.last_updated_at.present?
42 |     end
43 | 
44 |     test 'should not set last_updated_at upon source creation if asked' do
45 |       Lit.set_last_updated_at_upon_creation = false
46 |       s = Lit::Source.new
47 |       s.url = 'http://testhost.com/lit'
48 |       s.api_key = 'test'
49 |       s.identifier = 'test'
50 |       s.save!
51 |       s.reload
52 |       assert s.last_updated_at.nil?
53 |     end
54 |   end
55 | end
56 | 


--------------------------------------------------------------------------------
/test/unit/pure_i18n_compatibility_test.rb:
--------------------------------------------------------------------------------
 1 | require 'test_helper'
 2 | 
 3 | class PureI18nCompatibilityTest < ActiveSupport::TestCase
 4 |   class Backend < Lit::I18nBackend
 5 |     include I18n::Backend::Pluralization
 6 |   end
 7 | 
 8 |   def setup
 9 |     Lit::Localization.delete_all
10 |     Lit::LocalizationKey.delete_all
11 |     Lit::LocalizationVersion.delete_all
12 | 
13 |     @old_load_path = I18n.load_path
14 |     @old_humanize_key = Lit.humanize_key
15 |     @old_backend = I18n.backend
16 | 
17 |     I18n.load_path = []
18 |     Lit.humanize_key = false
19 |     I18n.backend = Backend.new(Lit.loader.cache)
20 |     super
21 |   end
22 | 
23 |   def teardown
24 |     Lit.humanize_key = @old_humanize_key
25 |     I18n.backend = @old_backend
26 |     I18n.load_path = @old_load_path
27 |     super
28 |   end
29 | 
30 |   include I18n::Tests::Basics
31 |   include I18n::Tests::Defaults
32 |   include I18n::Tests::Interpolation
33 |   include I18n::Tests::Link
34 |   include I18n::Tests::Lookup
35 |   include I18n::Tests::Pluralization
36 |   include I18n::Tests::Procs
37 |   include I18n::Tests::Localization::Date
38 |   include I18n::Tests::Localization::DateTime
39 |   include I18n::Tests::Localization::Time
40 |   include I18n::Tests::Localization::Procs
41 | 
42 |   test 'make sure we use the Lit::I18n backend' do
43 |     assert_equal Backend, I18n.backend.class
44 |   end
45 | end
46 | 


--------------------------------------------------------------------------------