weeler 0.0.4 → 1.0.0

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

@@ -0,0 +1,41 @@
+# This module is intended to be mixed into the Weeler backend to allow
+# checks if translation is html
+#
+#   I18n.backend = I18n::Backend::Weeler.new
+#   I18n::Backend::Weeler::Translation.send(:include, I18n::Backend::Weeler::HtmlChecker)
+#
+# The HtmlChecker module requires html-scanner
+# was extracted from the original backend.
+
+begin
+  require 'action_view/vendor/html-scanner'
+rescue LoadError => e
+  puts "can't use Html because: #{e.message}"
+end
+
+module I18n
+  module Backend
+    class Weeler
+      module HtmlChecker
+
+        def html?
+          if html_safe_translation_key?(self.key) ||
+            (self.value.present? && HTML::FullSanitizer.new.sanitize(self.value.to_s).length != self.value.to_s.length)
+            return true
+          else
+            return false
+          end
+        end
+
+      private
+
+        def html_safe_translation_key?(key)
+          key.to_s =~ /(\b|_|\.)html$/
+        end
+
+        Translation.send(:include, HtmlChecker)
+      end
+    end
+  end
+end
+

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

@@ -1,3 +1,13 @@
+# Weeler I18n backend import helper module.
+#
+# Loads file translations into datebase.
+# Supports: csv, xls, xlsx or ods
+#
+#   if params[:file].present?
+#     I18n::Backend::Weeler::Translation.import params[:file]
+#     Settings.i18n_updated_at = Time.now
+#   end
+
 begin
   require 'roo'
 rescue LoadError => e
@@ -9,27 +19,21 @@ module I18n
     class Weeler
 
       module Importer
-
         extend ActiveSupport::Concern
 
         module ClassMethods
 
-
-
-          def import path
-
-            xls = Roo::Excelx.new(path, file_warning: :ignore)
-
+          # Loads file and iterates each sheet and row.
+          def import file
+            xls = open_spreadsheet file
             xls.each_with_pagename do |name, sheet|
-              
+
               # Lookup locales
               locales = locales_from_xlsx_sheet_row(sheet.row(1))
 
               # Lookup values
               (2..sheet.last_row).each do |row_no|
-                
                 store_translations_from_xlsx_row(sheet.row(row_no), locales)
-
               end # rows
 
             end # sheets
@@ -38,6 +42,18 @@ module I18n
 
           private
 
+            # Open csv, xls, xlsx or ods file and read content
+            def open_spreadsheet(file)
+              case File.extname(file.original_filename)
+              when ".csv"  then Roo::Csv.new(file.path, file_warning: :ignore)
+              when ".xls"  then Roo::Excel.new(file.path, file_warning: :ignore)
+              when ".xlsx" then Roo::Excelx.new(file.path, file_warning: :ignore)
+              when ".ods"  then Roo::OpenOffice.new(file.path, file_warning: :ignore)
+              else raise "Unknown file type: #{file.original_filename}"
+              end
+            end
+
+            # Lookup locales and sequence for loading
             def locales_from_xlsx_sheet_row row
               locales = []
               row.each_with_index do |cell, i|
@@ -48,11 +64,12 @@ module I18n
               locales
             end
 
+            # Iterate each cell in row and store translation by locale
             def store_translations_from_xlsx_row row, locales
               locale = nil
               key = nil
               value = nil
-              
+
               row.each_with_index do |cell, i|
                 if i == 0
                   key = cell
@@ -63,9 +80,9 @@ module I18n
               end
             end
 
+            # Store locale if locale and key present
             def store_translation_from_xlsx_cell locale, key, cell
               value = cell.nil? ? '' : cell
-              # value = cell
 
               if locale.present? && key.present?
                 translation = Translation.find_or_initialize_by locale: locale, key: key
@@ -82,4 +99,4 @@ module I18n
       Translation.send(:include, Importer)
     end
   end
-end
+end

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

@@ -54,6 +54,11 @@ module I18n
         serialize :value
         serialize :interpolations, Array
 
+        scope :except_key, -> (key) { where("key NOT LIKE ?", "#{key}%") }
+
+        validates :key, :uniqueness => { :scope => :locale }
+        validates :key, presence: true
+
         class << self
 
           def locale(locale)
@@ -73,15 +78,15 @@ module I18n
             where("#{column_name} IN (?) OR #{column_name} LIKE ?", keys, namespace)
           end
 
-          def available_locales
-            Translation.select("DISTINCT locale").map { |t| t.locale.to_sym }
-          end
 
-          # This problably works only with PG
           def groups
-            # Translation.select("DISTINCT split_part(key, '.', 1), split_part(key, '.', 1) AS key_group").order("key_group").map { |t| t.key_group.to_sym }
-            groups_records = Translation.select("key").order("key").map{ |t| t.key.split(".")[0] }.uniq{ |t| t}
-            groups_records.uniq{ |t| t }
+            groups_records = Translation.select("key")
+
+            ::Weeler.excluded_i18n_groups.each do |key|
+              groups_records = groups_records.except_key(key)
+            end
+            groups_records = groups_records.order("key")
+            groups_records.map{ |t| t.key.split(".")[0] }.uniq{ |t| t}
           end
         end
 

data/lib/i18n/humanize_missing_translations.rb

@@ -1,4 +1,5 @@
 module I18n
+  # Show only last part from key in humanize mode
   module HumanizeMissingTranslations
     def call(exception, locale, key, options)
       if exception.is_a?(I18n::MissingTranslation)

data/lib/i18n/weeler.rb

@@ -1,6 +1,12 @@
 require 'i18n'
+
 require 'i18n/humanize_missing_translations'
+I18n.exception_handler.extend I18n::HumanizeMissingTranslations
+
 require 'i18n/backend/weeler'
+weeler_i18n_backend = I18n::Backend::Weeler.new
+weeler_i18n_backend.i18n_cache = Weeler.i18n_cache
+I18n.backend = I18n::Backend::Chain.new(weeler_i18n_backend, I18n::Backend::Simple.new)
 
-I18n.exception_handler.extend I18n::HumanizeMissingTranslations
-I18n.backend = I18n::Backend::Chain.new(I18n::Backend::Weeler.new, I18n::Backend::Simple.new)
+logger = Logger.new(STDOUT)
+logger.info "Weeler i18n backend loaded"

data/lib/tasks/weeler.rake

@@ -0,0 +1,8 @@
+namespace :weeler do
+  namespace :translations do
+    desc "Remove all weeler i18n translation dublicates"
+    task dedupe: :environment do
+      I18n::Backend::Weeler::Translation.dedupe
+    end
+  end
+end

data/lib/weeler.rb

@@ -1,10 +1,25 @@
 require "weeler/version"
+require "weeler/deprecator"
+
+require 'logger'
 require "rails"
-require "weeler/route_mapper"
+
 require "weeler/engine"
+
+# 3rd party
+require "haml"
 require "kaminari"
+require "globalize"
+require "jquery-ui-rails"
+require "rails-settings-cached"
 
 module Weeler
+  #
+  # => Static sections in content menu bottom
+  # => [{about: [{title: :text_field, content: :text_area}]}]
+  #
+  mattr_accessor :static_sections
+  @@static_sections = {}
 
   mattr_accessor :create_missing_translations
   @@create_missing_translations = true
@@ -12,18 +27,76 @@ module Weeler
   mattr_accessor :use_weeler_i18n
   @@use_weeler_i18n = true
 
-  mattr_accessor :menu_items
-  @@menu_items = []
-
   mattr_accessor :required_user_method
   @@required_user_method = nil
 
+  mattr_accessor :logout_path
+  @@logout_path = nil
+
+  # Rafacture this to one menu module
+  mattr_accessor :content_menu_items
+  @@content_menu_items = []
+
+  # Rafacture this to one menu module
+  mattr_accessor :static_menu_items
+  @@static_menu_items = []
+
+  # Rafacture this to one menu module
+  mattr_accessor :administration_menu_items
+  @@administration_menu_items = []
+
+  # Rafacture this to one menu module
+  mattr_accessor :configuration_menu_items
+  @@configuration_menu_items = []
+
+  # Rafacture this to one menu module
+  mattr_accessor :main_menu_items
+  @@main_menu_items = []
+
+  mattr_accessor :excluded_i18n_groups
+  @@excluded_i18n_groups = [:activerecord, :attributes, :helpers, :views, :i18n, :weeler]
+
+  mattr_accessor :i18n_cache
+  @@i18n_cache = ActiveSupport::Cache::MemoryStore.new
+
+  mattr_accessor :mount_location_namespace
+  @@mount_location_namespace = "weeler"
+
   def self.setup
-    if Weeler.use_weeler_i18n
+    yield self
+    if Weeler.use_weeler_i18n == true && ActiveRecord::Base.connection.table_exists?('weeler_translations')
       require "i18n/weeler"
+      Weeler.static_sections.each do |key, section|
+        Weeler.static_menu_items << {name: key.to_s.capitalize, weeler_path: "static_sections/#{key}"}
+      end
     end
+    build_main_menu
+  end
 
-    yield self
+  def self.build_main_menu
+    home_menu_item = {name: "Home", weeler_path: ""}
+    content_menu_item = {name: "Content", weeler_path: "content"}
+    administration_menu_item = {name: "Administration", weeler_path: "administration"}
+    configuration_menu_item = {name: "Configuration", weeler_path: "configuration"}
+
+    Weeler.main_menu_items.delete(home_menu_item)
+    Weeler.main_menu_items.delete(content_menu_item)
+    Weeler.main_menu_items.delete(administration_menu_item)
+    Weeler.main_menu_items.delete(configuration_menu_item)
+
+
+    Weeler.main_menu_items.insert(0, {name: "Home", weeler_path: ""}) unless Weeler.main_menu_items.include?(home_menu_item)
+
+    if (Weeler.content_menu_items.size > 0 || Weeler.static_menu_items.size > 0) && !Weeler.main_menu_items.include?(content_menu_item)
+      Weeler.main_menu_items.insert(1, {name: "Content", weeler_path: "content"})
+    end
+
+    Weeler.main_menu_items.insert(2, administration_menu_item) if Weeler.administration_menu_items.size > 0 && !Weeler.main_menu_items.include?(administration_menu_item)
+    Weeler.main_menu_items.push(configuration_menu_item) unless Weeler.main_menu_items.include?(configuration_menu_item)
+    Weeler.main_menu_items = Weeler.main_menu_items.compact
   end
-end
 
+  def self.translations
+    I18n::Backend::Weeler::Translation if Weeler.use_weeler_i18n == true
+  end
+end

data/lib/weeler/action_controller/acts/restful.rb

@@ -0,0 +1,185 @@
+module Weeler
+  module ActionController
+    module Acts
+      module Restful
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          # Weeler action controller method.
+          # It creates all restful actions for action controller. Create a controller for your
+          # model (e.g. Post) what you want to administrate in weeler. Add method <tt>acts_as_restful Post</tt>
+          # and permit params for your resource - option <tt>permit_params</tt>. Also you can paginate - add
+          # option <tt>paginate</tt>
+          # e.g.
+          #
+          #   class Weeler::PostController < Weeler::ContentController
+          #     acts_as_restful Post, permit_params: [:title, :body], paginate: 50
+          #   end
+          #
+          # It will handle <tt>:index</tt>, <tt>:new</tt>, <tt>:edit</tt>, <tt>:update</tt>,
+          # <tt>:destroy</tt>, <tt>:order</tt>, <tt>:activation</tt> and <tt>:remove_image</tt> actions
+          #
+          # For permiting custom by role or permiting all params (permit!),
+          # you must add block <tt>permit_params: -> (params) { params.require(:post).permit! }</tt>
+          #
+          # You should implement form file with your own active record attributes.
+          # To do that, create <tt>_form.html.haml</tt> in <tt>views/weeler/_YOUR_RESOURCE_/_form.html.haml</tt>
+          # where <tt>_YOUR_RESOURCE_</tt> is name of your resource.
+          #
+          # Also you can override all standart restful action view and implement, if you need,
+          # <tt>_filter.html.haml</tt>
+          #
+          def acts_as_restful(active_record_model, options = {})
+            before_filter(:load_record, only: [:show, :edit, :update, :destroy, :remove_image])
+
+            include InstanceMethodsOnActivation
+            helper_method :item_humanized_name
+
+            cattr_accessor :model do
+              active_record_model
+            end
+
+            cattr_accessor :permited_params do
+              options[:permit_params] if options.include? :permit_params
+            end
+
+            cattr_accessor :paginate do
+              options[:paginate] if options.include? :paginate
+            end
+
+            cattr_accessor :order_by do
+              options[:order_by] if options.include? :order_by
+            end
+          end
+        end
+
+        # These methods only activate if 'acts_as_restful' is called
+        #
+        module InstanceMethodsOnActivation
+
+          def index
+            @paginate = paginate
+            @items = load_collection
+            @items = @items.page(params[:page]).per(@paginate) if @paginate.present? && @paginate > 0
+          end
+
+          def new
+            @item = model.new
+            load_translations
+          end
+
+          def show
+            render :edit
+          end
+
+          def edit
+            load_translations
+          end
+
+          def order
+            sort
+          end
+
+          def create
+            @item = model.new(items_params)
+            if @item.save
+              redirect_to({ action: :edit, id: @item.id }, {:notice => "Successfully created item"})
+            else
+              render :action => 'new'
+            end
+          end
+
+          def update
+            if @item.update_attributes(items_params)
+              redirect_to({ action: :edit, id: @item.id }, {:notice => "Successfully updated item"})
+            else
+              render :action => 'edit'
+            end
+          end
+
+          def destroy
+            @item.destroy
+            redirect_to({ action: :index}, {:notice => "Successfully destroyed item"})
+          end
+
+          def remove_image
+            if @item.image.present?
+              @item.image.destroy
+              @item.image_file_name = nil
+              @item.save
+            end
+            redirect_to({ action: :edit, id: @item.id}, {:notice => "Image successfully removed"})
+          end
+
+        protected
+
+          def items_params
+            if permited_params.is_a? Proc
+              permited_params.call(params)
+            elsif permited_params.blank?
+              warning_suggestion = params[parameterized_name.to_sym].is_a?(Hash) ? params[parameterized_name.to_sym].keys.map{ |k| k.to_sym } : "permit_params:"
+              warn "[UNPERMITED PARAMS] To permiting #{params[parameterized_name.to_sym].inspect} params, add 'permit_params: #{warning_suggestion}' option to 'acts_as_restful'"
+            else
+              params.require(parameterized_name.to_sym).permit(permited_params)
+            end
+          end
+
+          def collection; end
+
+          def parameterized_name
+            "#{model.to_s.underscore.downcase}"
+          end
+
+          def item_humanized_name
+            "#{parameterized_name.humanize}"
+          end
+
+          def load_translations
+            if @item.respond_to? :translations
+              I18n.available_locales.each { |locale| @item.translations.find_or_initialize_by(locale: locale) }
+            end
+          end
+
+        private
+
+          def model
+            model
+          end
+
+          def load_collection
+            return @load_collection if @load_collection.present?
+            if model
+              if collection
+                @load_collection = collection
+              else
+                @load_collection = model.all
+                if order_by.present?
+                  @load_collection.order(order_by)
+                elsif model.new.has_attribute?(:sequence)
+                  @load_collection.order(:sequence)
+                else
+                  @load_collection.order(created_at: :desc)
+                end
+              end
+            end
+          end
+
+          def load_record
+            @item = model.find(params[:id])
+          end
+
+          def sort
+            items_sequence = URI.decode_www_form(params[:orders]).map{ |i| i[1] }
+            items_sequence.each_with_index do |sequence_item_id, index|
+              item = model.find_by id: sequence_item_id
+              item.sequence = index
+              item.save!
+            end
+            render :text => 'all ok'
+          end
+
+        end # Instance methods
+      end
+    end
+  end
+end