weeler 0.0.4 → 1.0.0

data/app/views/weeler/translations/new.html.haml

@@ -0,0 +1,13 @@
+.header.container
+  .row
+    .col-lg-12.col-md-12
+      .page-header
+        %h1 New translation
+.edit_user.container
+  .row
+    .col-lg-12.col-md-12
+      = form_for @translation, {url: weeler_translations_path, html: {class: "form-horizontal", role: "form"}} do |f|
+        = render partial: "form", locals: {translation: @translation, f: f}
+        %p.text-center
+          %button.btn.btn-primary{type: "submit"} Save
+          %a.btn.btn-link{href: weeler_translations_path} Cancel

data/lib/generators/weeler/install_generator.rb

@@ -29,14 +29,18 @@ module Weeler
         end
       end
 
-      #def install_models
-      #  copy_files 'models', 'app/models'
-      #end
-
       def install_views
         copy_files 'views', 'app/views'
       end
 
+      def install_javascripts_assets
+        copy_files 'assets/javascripts', 'lib/assets/javascripts'
+      end
+
+      def install_stylesheets_assets
+        copy_files 'assets/stylesheets', 'lib/assets/stylesheets'
+      end
+
       def install_controllers
         copy_files 'controllers', 'app/controllers'
       end
@@ -45,37 +49,37 @@ module Weeler
       def add_weeler_routes
         weeler_routes  = "mount_weeler_at \"weeler\" do \n"
         weeler_routes << "    # weeler_resources :example, include_in_weeler_menu: true \n"
+        weeler_routes << "    # Also you orderable and imageable concerns \n"
         weeler_routes << "  end"
         route weeler_routes
       end
 
+    private
 
-      private
-
-        def copy_files subdir, dest_dir
-          raise ArgumEnterror unless subdir.is_a? String
-          raise ArgumEnterror unless dest_dir.is_a? String
-          raise ArgumetnError if subdir.blank?
-          raise ArgumetnError if dest_dir.blank?
+      def copy_files subdir, dest_dir
+        raise ArgumEnterror unless subdir.is_a? String
+        raise ArgumEnterror unless dest_dir.is_a? String
+        raise ArgumetnError if subdir.blank?
+        raise ArgumetnError if dest_dir.blank?
 
-          get_file_list(subdir).each do |image|
-            copy_file [subdir, image].join('/'), [dest_dir, image].join('/')
-          end
+        get_file_list(subdir).each do |image|
+          copy_file [subdir, image].join('/'), [dest_dir, image].join('/')
         end
+      end
 
-        def get_file_list subdir
-          raise ArgumentError unless subdir.is_a? String
-          raise ArgumetnError if subdir.blank?
-          dir = get_current_dir
-          search_path = [dir, 'templates', subdir].join('/') + '/'
-          file_list = Dir.glob(search_path + '**/*').map { |filename| File.directory?(filename) ? nil : filename.sub(search_path, '') }
-          file_list.delete nil
-          return file_list
-        end
+      def get_file_list subdir
+        raise ArgumentError unless subdir.is_a? String
+        raise ArgumetnError if subdir.blank?
+        dir = get_current_dir
+        search_path = [dir, 'templates', subdir].join('/') + '/'
+        file_list = Dir.glob(search_path + '**/*').map { |filename| File.directory?(filename) ? nil : filename.sub(search_path, '') }
+        file_list.delete nil
+        return file_list
+      end
 
-        def get_current_dir
-          File.dirname(__FILE__)
-        end
+      def get_current_dir
+        File.dirname(__FILE__)
+      end
 
     end
   end

data/lib/generators/weeler/templates/assets/javascripts/weeler/app/index.js

@@ -0,0 +1,2 @@
+// Here you can implement your JS code
+// For example //= require redactor-rails

data/lib/generators/weeler/templates/assets/stylesheets/weeler/app/index.css

@@ -0,0 +1,4 @@
+/*
+  Here you can implement your css code
+  // For example *= require redactor-rails
+*/

data/lib/generators/weeler/templates/controllers/weeler/application_controller.rb

@@ -0,0 +1,6 @@
+module Weeler
+  class ApplicationController < ::ApplicationController
+    # Here you can define controller methods for using in weeler.
+    # Also you can set before_filter 's and define those methods.
+  end
+end

data/lib/generators/weeler/templates/initializers/weeler.rb

@@ -1,7 +1,35 @@
 Weeler.setup do |config|
 
+  # Use Weeler I18n transaltion engine (ActiveRecord store).
+  #
   # config.use_weeler_i18n = true
-  # config.create_missing_translations
-  # config.required_user_method = nil 
+  # config.create_missing_translations = true # Create translation in database if it missing
+
+  # Require user method weeler use in before filter. (e.g. require_user)
+  #
+  # config.required_user_method = nil
+
+  # You can define logout path (e.g. "/logout")
+  #
+  # config.logout_path = nil
+
+  # Menu items in Content section. There you must create resources in app.
+  #
+  # config.content_menu_items = []
+
+  # If you don't want to create model in your app and use only single page CMS, then you should use this property.
+  # e.g. {about: ['about_us.title', 'about_us.about_text_html', 'about_us.our_company', 'about_us.our_company_text_html']}
+  #
+  #
+  # config.static_sections = [] # Menu items in Content section under Static. Resourses uses I18n translaitons
+
+  # Menu items in Administration section. There you must create resources in app.
+  #
+  # config.administration_menu_items = []
+
+  # You can exclude translation groups from weeler administration
+  # By default theres already excluded [:activerecord, :attributes, :helpers, :views, :i18n, :weeler]
+  #
+  # config.excluded_i18n_groups += ["number", "date", "scopes", "named_routes", "named_routes_path", "path_names", "errors", "routes"]
 
 end

data/lib/generators/weeler/templates/migrations/create_weeler_seos.rb

@@ -0,0 +1,14 @@
+class CreateWeelerSeos < ActiveRecord::Migration
+  def change
+    create_table :weeler_seos do |t|
+      t.string :title
+      t.text :description
+      t.text :keywords
+      t.string :section
+      t.references :seoable, index: true, polymorphic: true
+
+      t.timestamps
+    end
+    add_index :weeler_seos, :section
+  end
+end

data/lib/generators/weeler/templates/migrations/create_weeler_settings.rb

@@ -0,0 +1,17 @@
+class CreateWeelerSettings < ActiveRecord::Migration
+  def self.up
+    create_table :settings do |t|
+      t.string :var, :null => false
+      t.text   :value, :null => true
+      t.integer :thing_id, :null => true
+      t.string :thing_type, :limit => 30, :null => true
+      t.timestamps
+    end
+
+    add_index :settings, [ :thing_type, :thing_id, :var ], :unique => true
+  end
+
+  def self.down
+    drop_table :settings
+  end
+end

data/lib/generators/weeler/templates/migrations/translate_weeler_seos.rb

@@ -0,0 +1,15 @@
+class TranslateWeelerSeos < ActiveRecord::Migration
+  def self.up
+    Weeler::Seo.create_translation_table!({
+      title: :string,
+      description: :text,
+      keywords: :text
+    }, {
+      :migrate_data => true
+    })
+  end
+
+  def self.down
+    Weeler::Seo.drop_translation_table! :migrate_data => true
+  end
+end

data/lib/i18n/backend/weeler.rb

@@ -1,14 +1,30 @@
 require 'i18n/backend/base'
 require 'i18n/backend/weeler/translation'
+require 'i18n/backend/weeler/dedupe'
+require 'i18n/backend/weeler/html_checker'
 require 'i18n/backend/weeler/exporter'
 require 'i18n/backend/weeler/importer'
 
 module I18n
   module Backend
+    # I18n backend by weeler for storing translations in database and caching.
+    #
+    # It implements storing all translation in <tt>Translation</tt> active record moduel table.
+    # When application is running, it stores translation in cache for better performance.
+    #
+    # Also this backend provides extra moduls:
+    # * HTML checher, for storing html translations.
+    # * exporter - for export all translations in xlsx
+    # * importer - for importing all translations
+    # * Dedupe - you should use if you find duplicated keys
+    #
     class Weeler
+      attr_accessor :i18n_cache
+
       PLURAL_KEYS = ["zero", "one", "other"]
 
-      autoload :StoreProcs,  'i18n/backend/weeler/store_procs'
+      autoload :HtmlChecker, 'i18n/backend/weeler/html_checker'
+      autoload :Translation, 'i18n/backend/weeler/dedupe'
       autoload :Translation, 'i18n/backend/weeler/translation'
       autoload :Exporter,    'i18n/backend/weeler/exporter'
       autoload :Importer,    'i18n/backend/weeler/importer'
@@ -16,59 +32,123 @@ module I18n
       module Implementation
         include Base, Flatten
 
-        def available_locales
-          begin
-            Translation.available_locales
-          rescue ::ActiveRecord::StatementInvalid
-            []
-          end
-        end
-
         def store_translations(locale, data, options = {})
           escape = options.fetch(:escape, true)
           flatten_translations(locale, data, escape, false).each do |key, value|
             Translation.locale(locale).lookup(expand_keys(key)).delete_all
-            Translation.create(:locale => locale.to_s, :key => key.to_s, :value => value)
+            Translation.create(locale: locale.to_s, key: key.to_s, value: value)
+          end
+        end
+
+        def reload_cache
+          i18n_cache.clear
+
+          Translation.all.each do |translation|
+            i18n_cache.write [translation.locale, translation.key], translation if translation.value.present?
           end
+
+          i18n_cache.write('UPDATED_AT', Settings.i18n_updated_at) if ActiveRecord::Base.connection.table_exists?('settings')
         end
 
       protected
 
         def lookup(locale, key, scope = [], options = {})
           key = normalize_flat_keys(locale, key, scope, options[:separator])
+          return lookup_in_cache(locale, key, scope, options)
+        end
+
+      private
+
+        def lookup_in_cache locale, key, scope = [], options = {}
+          # reload cache if cache timestamp differs from last translations update
+          reload_cache if ((!ActiveRecord::Base.connection.table_exists?('settings')) || i18n_cache.read('UPDATED_AT') != Settings.i18n_updated_at)
+
+          return nil if i18n_cache.read([:missing, [locale, key]])
+
+          keys = expand_keys key
+
+          keys.reverse.each do |check_key|
+
+            result = i18n_cache.read([locale, check_key])
+
+            return result.value unless result.blank?
+          end
+
+          # mark translation as missing
+          i18n_cache.write([:missing, [locale, key]], true)
+
+          if ::Weeler.create_missing_translations
+            return store_empty_translation locale, key, options
+          else
+            return nil
+          end
+        end
+
+        def lookup_in_database locale, key, scope = [], options = {}
           result = Translation.locale(locale).lookup(key).load
 
           if result.empty?
             if ::Weeler.create_missing_translations
-              interpolations = options.keys - I18n::RESERVED_KEYS
-              keys = options[:count] ? PLURAL_KEYS.map { |k| [key, k].join(FLATTEN_SEPARATOR) } : [key]
-              keys.each { |key| store_translation(locale, key, interpolations) }
+              return store_empty_translation locale, key, options
+            else
+              return nil
             end
-            nil
           elsif result.first.key == key
-            result.first.value
+            translation = result.first
+            if translation.value.blank?
+              fallback_value = fallback_backend_translation locale, key
+              translation.update_attributes value: fallback_value if fallback_value.present?
+            end
+            return translation.value
           else
             chop_range = (key.size + FLATTEN_SEPARATOR.size)..-1
             result = result.inject({}) do |hash, r|
               hash[r.key.slice(chop_range)] = r.value
               hash
             end
-            result.deep_symbolize_keys
+            return result.deep_symbolize_keys
           end
         end
 
         # For a key :'foo.bar.baz' return ['foo', 'foo.bar', 'foo.bar.baz']
-        def expand_keys(key)
-          key.to_s.split(FLATTEN_SEPARATOR).inject([]) do |keys, key|
+        def expand_keys(not_expanded_key)
+          not_expanded_key.to_s.split(FLATTEN_SEPARATOR).inject([]) do |keys, key|
             keys << [keys.last, key].compact.join(FLATTEN_SEPARATOR)
           end
         end
 
         # Store single empty translation
-        def store_translation(locale, key, interpolations)
-          translation = Weeler::Translation.new :locale => locale.to_s, :key => key
-          translation.interpolations = interpolations
-          translation.save
+        def store_empty_translation locale, singular_key, options
+          return_value = nil
+          interpolations = options.keys - I18n::RESERVED_KEYS
+
+          keys = options[:count] ? PLURAL_KEYS.map { |k| [singular_key, k].join(FLATTEN_SEPARATOR) } : [singular_key]
+
+
+          keys.each do |key|
+            translation = Weeler::Translation.find_or_initialize_by locale: locale.to_s, key: key
+            translation.interpolations = interpolations
+            fallback_value = fallback_backend_translation locale, key
+            if fallback_value.present?
+              translation.value = fallback_value
+              translation.save
+              reload_cache
+            else
+              translation.save
+            end
+            return_value = translation.value
+          end
+          return_value
+        end
+
+
+        def fallback_backend_translation locale, key
+          if I18n.backend.backends.size > 1
+            alternative_backend = I18n.backend.backends[1]
+            alternative_backend.send(:lookup, locale, key)
+          else
+            nil
+          end
         end
 
       end

data/lib/i18n/backend/weeler/dedupe.rb

@@ -0,0 +1,31 @@
+# This module is intended to be mixed into the Weeler backend to allow
+# remove all dublicates from translation table
+#
+#   I18n.backend = I18n::Backend::Weeler.new
+#   I18n::Backend::Weeler::Translation.send(:include, I18n::Backend::Weeler::Dedupe)
+
+module I18n
+  module Backend
+    class Weeler
+      module Dedupe
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def dedupe
+            # find all models and group them on keys which should be common
+            grouped = all.group_by{|model| [model.locale,model.key] }
+            grouped.values.each do |duplicates|
+              # the first one we want to keep right?
+              first_one = duplicates.shift # or pop for last one
+              # if there are any more left, they are duplicates
+              # so delete all of them
+              duplicates.each{|double| double.destroy} # duplicates can now be destroyed
+            end
+          end
+        end
+
+        Translation.send(:include, Dedupe)
+      end
+    end
+  end
+end

data/lib/i18n/backend/weeler/exporter.rb

@@ -1,7 +1,19 @@
+# Weeler I18n backend export helper module.
+#
+# Export all translations in excel (xlsx)
+#
+#   def export
+#     respond_to do |format|
+#       format.xlsx do
+#         outstrio = StringIO.new
+#         outstrio.write(I18n::Backend::Weeler::Translation.all.as_xlsx_package.to_stream.read)
+#         send_data(outstrio.string, filename: "translations" + '.xlsx')
+#       end
+#     end
+#   end
+
 begin
   require 'axlsx'
-  require 'i18n/backend/weeler/exporter/active_record'
-  require 'i18n/backend/weeler/exporter/active_record_relation'
 rescue LoadError => e
   puts "can't use Exporter because: #{e.message}"
 end
@@ -9,10 +21,60 @@ end
 module I18n
   module Backend
     class Weeler
+      module Exporter
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          # Prepare xlsx package from current scope
+          # Stores all translations in translations worksheet.
+          def as_xlsx_package
+            package = Axlsx::Package.new
+            package.use_shared_strings = true
+
+            sheet = package.workbook.add_worksheet(name: "translations")
+
+            locales = I18n.available_locales
+            sheet.add_row(Translation.title_row(locales))
 
-      Translation.send(:include, Exporter::ActiveRecord)
-      ActiveRecord::Relation::ActiveRecord_Relation_I18n_Backend_Weeler_Translation.send(:include, Exporter::ActiveRecordRelation)
+            types = []
+            (locales.size + 1).times { types << :string }
 
+            included_keys = []
+
+            self.current_scope.each do |translation|
+              unless included_keys.include? translation.key
+                sheet.add_row(Translation.translation_row_by_key_and_locales(translation.key, locales), types: types)
+                included_keys << translation.key
+              end
+            end
+            return package
+          end
+
+          def title_row locales
+            row = [ 'Key' ]
+            locales.each do |locale|
+              row.push(locale.capitalize)
+            end
+            row
+          end
+
+          def translation_row_by_key_and_locales key, locales
+            row = [ key ]
+            locales.each do |locale|
+              result = Translation.locale(locale).lookup(key).load
+              if result.first.present?
+                row.push(result.first.value)
+              else
+                row.push("")
+              end
+            end
+            row
+          end
+        end
+
+        Translation.send(:include, self)
+      end
     end
   end
-end
+end