ab_admin 0.8.3 → 0.10.0

data/db/migrate/20130101000007_base_translations.rb

@@ -1,15 +1,46 @@
-class BaseTranslations < ActiveRecord::Migration
-  def self.up
-    StaticPage.create_translation_table! title: :string, content: :text
-    Header.create_translation_table! title: :string, h1: :string, keywords: :string, description: :text, seo_block: :text
-    Structure.create_translation_table! title: :string, redirect_url: :string
-    Asset.create_translation_table! name: :string, alt: :string
-  end
+class BaseTranslations < ActiveRecord::Migration[5.2]
+  def change
+    create_table :static_page_translations do |t|
+      t.references :static_page, null: false
+      t.string :locale, limit: 5, null: false
+      t.string :title
+      t.text :content
+
+      t.timestamps
+    end
+    add_index :static_page_translations, [:static_page_id, :locale], unique: true, name: 'static_pages_ts_static_page_id_locale'
+
+    create_table :header_translations do |t|
+      t.references :header, null: false
+      t.string :locale, limit: 5, null: false
+      t.string :title
+      t.string :h1
+      t.string :keywords
+      t.text :description
+      t.text :seo_block
+
+      t.timestamps
+    end
+    add_index :header_translations, [:header_id, :locale], unique: true, name: 'headers_ts_header_id_locale'
+
+    create_table :structure_translations do |t|
+      t.references :structure, null: false
+      t.string :locale, limit: 5, null: false
+      t.string :title
+      t.string :redirect_url
+
+      t.timestamps
+    end
+    add_index :structure_translations, [:structure_id, :locale], unique: true, name: 'structures_ts_structure_id_locale'
+
+    create_table :asset_translations do |t|
+      t.references :asset, null: false
+      t.string :locale, limit: 5, null: false
+      t.string :name
+      t.string :alt
 
-  def self.down
-    StaticPage.drop_translation_table!
-    Header.drop_translation_table!
-    Structure.drop_translation_table!
-    Asset.drop_translation_table!
+      t.timestamps
+    end
+    add_index :asset_translations, [:asset_id, :locale], unique: true, name: 'assets_ts_asset_id_locale'
   end
 end

data/db/migrate/20130101000008_create_admin_comments.rb

@@ -1,18 +1,13 @@
-class CreateAdminComments < ActiveRecord::Migration
+class CreateAdminComments < ActiveRecord::Migration[5.2]
   def change
     create_table :admin_comments do |t|
       t.references :user
       t.string :user_name
-      t.integer :resource_id, null: false
-      t.string :resource_type, limit: 50, null: false
+      t.references :resource, polymorphic: true
       t.references :resource_user
       t.text :body
 
       t.timestamps
     end
-
-    add_index :admin_comments, :user_id
-    add_index :admin_comments, :resource_user_id
-    add_index :admin_comments, [:resource_type, :resource_id]
   end
 end

data/db/migrate/20130101000009_create_tracks.rb

@@ -1,20 +1,16 @@
-class CreateTracks < ActiveRecord::Migration
+class CreateTracks < ActiveRecord::Migration[5.2]
   def change
     create_table :tracks do |t|
       t.string :name
       t.string :key
-      t.belongs_to :trackable, polymorphic: true
-      t.belongs_to :user
-      t.belongs_to :owner
+      t.references :trackable, polymorphic: true
+      t.references :user
+      t.references :owner
       t.column :trackable_changes, :mediumtext
       t.text :parameters
 
       t.timestamps
     end
-
-    add_index :tracks, [:trackable_type, :trackable_id]
-    add_index :tracks, :owner_id
-    add_index :tracks, :user_id
     add_index :tracks, :key
   end
 end

data/lib/ab_admin/abstract_resource.rb

@@ -6,14 +6,15 @@ module AbAdmin
       ACTIONS = [:index, :show, :new, :edit, :create, :update, :destroy, :preview, :batch, :rebuild, :custom_action, :history]
     end
 
-    attr_accessor :model, :table, :search, :export, :form, :chart, :modal_form, :show, :preview_path, :actions, :custom_settings,
-                  :batch_action_list, :action_items, :disabled_action_items, :resource_action_items, :tree_node_renderer,
+    attr_accessor :model, :table, :search, :export, :form, :chart, :stats, :map, :modal_form, :show,
+                  :preview_path, :actions, :custom_settings,
+                  :batch_actions, :action_items, :disabled_action_items, :resource_action_items, :tree_node_renderer,
                   :parent_resources, :custom_actions, :permitted_params, :scopes
 
     def initialize
       @actions = ACTIONS
       @custom_settings = {}
-      @batch_action_list = [AbAdmin::Config::BatchAction.new(:destroy, confirm: I18n.t('admin.delete_confirmation'))]
+      @batch_actions= [AbAdmin::Config::BatchAction.new(:destroy, confirm: I18n.t('admin.delete_confirmation'))]
       @action_items = []
       @disabled_action_items = []
       @default_action_items_for = {}
@@ -87,9 +88,9 @@ module AbAdmin
 
       def batch_action(name, options={}, &block)
         if options
-          instance.batch_action_list << AbAdmin::Config::BatchAction.new(name.to_sym, options, &block)
+          instance.batch_actions << AbAdmin::Config::BatchAction.new(name.to_sym, options, &block)
         else
-          instance.batch_action_list.reject!{|a| a.name == name.to_sym }
+          instance.batch_actions.reject!{|a| a.name == name.to_sym }
         end
       end
 

data/lib/ab_admin/carrierwave/base_uploader.rb

@@ -1,4 +1,3 @@
-require 'mime/types'
 require 'mini_magick'
 require 'carrierwave/processing/mini_magick'
 
@@ -8,8 +7,7 @@ module AbAdmin
       include ::CarrierWave::MiniMagick
       include AbAdmin::Utils::EvalHelpers
 
-      class_attribute :transliterate, :human_filenames
-      self.transliterate = true
+      class_attribute :human_filenames
       self.human_filenames = true
 
       attr_accessor :internal_identifier
@@ -26,41 +24,48 @@ module AbAdmin
 
       process :set_model_info
 
-      def strict_filename(for_file=filename)
-        "#{version_name || secure_token}#{File.extname(for_file).downcase}"
+      def filename
+        "#{[human_part, secure_token].compact.join('_')}#{extension}"
       end
 
-      def save_original_name(file)
-        model.original_name ||= file.original_filename if file.respond_to?(:original_filename)
+      def full_filename(*)
+        return filename unless version_name
+        base = "#{version_filename_part}#{version_extension}"
+        return base unless human_filenames
+        [human_part, base].compact.join('_')
       end
 
-      def base_filename_part
-        return if version_name == :default
-        return secure_token unless version_name
-        version_name.to_s.start_with?('retina_') ? "#{version_name.to_s.sub(/^retina_/, '')}@2x" : version_name.to_s
+      def human_part
+        normalize_filename(model.send("#{mounted_as}_file_name").to_s.strip.remove(/\.\w+$/)).remove(secure_token).chomp('_').presence
       end
 
-      def full_filename(for_file=filename)
-        human_filenames ? human_full_filename(for_file) : strict_filename(for_file)
+      def extension
+        File.extname(model.original_name).downcase
       end
 
-      def human_full_filename(for_file=filename)
-        ext = File.extname(for_file)
-        system_part = base_filename_part
-        human_filename_part = for_file.chomp(ext)
-        return "#{system_part || version_name}#{ext}" if human_filename_part == secure_token
-        system_part ? "#{human_filename_part}_#{system_part}#{ext}" : "#{human_filename_part}#{ext}"
+      def version_extension
+        webp? ? '.webp' : extension
       end
 
-      def full_original_filename
-        "#{base_filename_part}#{File.extname(store_filename)}"
+      def version_filename_part
+        return secure_token unless version_name
+        strict_version_name = version_name.to_s.remove('retina_').remove('_webp')
+        strict_version_name = nil if strict_version_name.to_sym == :default
+        "#{strict_version_name}#{'@2x' if retina?}"
       end
 
-      # use secure token in the filename for non processed image
       def secure_token
         model.data_secure_token ||= AbAdmin.friendly_token(20).downcase
       end
 
+      def retina?
+        version_name.to_s.start_with?('retina_')
+      end
+
+      def webp?
+        version_name.to_s.end_with?('_webp')
+      end
+
       def store_model_filename(record)
         old_file_name = filename
         new_file_name = model_filename(old_file_name, record)
@@ -68,69 +73,81 @@ module AbAdmin
         rename_via_move(new_file_name)
       end
 
-      alias_method :store_filename, :filename
-
-      def filename
-        internal_identifier || model.send("#{mounted_as}_file_name") || (store_filename && "#{secure_token}#{File.extname(store_filename).downcase}")
-      end
-
-      def write_internal_identifier(internal_identifier)
-        self.internal_identifier = internal_identifier
-        versions.values.each{|v| v.internal_identifier = internal_identifier }
+      def save_original_name(file)
+        model.original_name ||= file.original_filename if file.respond_to?(:original_filename)
       end
 
-      # transliterate original filename
-      # allow to build custom filename
       def model_filename(base_filename, record)
         custom_file_name = model.build_filename(base_filename, record)
         return unless custom_file_name
-        normalize_filename(custom_file_name) + File.extname(base_filename).downcase
+        normalize_filename(custom_file_name)
       end
+      private :model_filename
 
       def normalize_filename(raw_filename)
-        parameterize_args = ActiveSupport::VERSION::MAJOR > 4 ? {separator: '_'} : '_'
-        I18n.transliterate(raw_filename).parameterize(parameterize_args).gsub(/[\-_]+/, '_').downcase
-      end
-
-      # rename files via move
-      def rename_via_move(new_file_name)
-        if human_filenames
-          dir = File.dirname(path)
-
-          moves = []
-          versions.values.unshift(self).each do |v|
-            from_path = File.join(dir, v.full_filename)
-            to_path = File.join(dir, v.full_filename(new_file_name))
-            next if from_path == to_path || !File.exists?(from_path)
-            moves << [from_path, to_path]
-          end
-          moves.each { |move| FileUtils.mv(*move) }
+        I18n.transliterate(raw_filename.unicode_normalize).parameterize(separator: '_').gsub(/[\-_]+/, '_').downcase
+      end
+
+      def rename_via_move(new_filename)
+        dir = File.dirname(path)
+        old_names = versions.values.unshift(self).map(&:full_filename)
+        model.send("#{mounted_as}_file_name=", "#{[new_filename.presence, secure_token].compact.join('_')}#{extension}")
+        new_names = versions.values.unshift(self).map(&:full_filename)
+        old_names.zip(new_names).each do |old_name, new_name|
+          old_path, new_path = File.join(dir, old_name), File.join(dir, new_name)
+          next if old_path == new_path || !File.exist?(old_path)
+          FileUtils.mv(old_path, new_path)
         end
-
-        write_internal_identifier new_file_name
-        model.send("write_#{mounted_as}_identifier")
-        retrieve_from_store!(new_file_name) if human_filenames
-
-        new_file_name
+        retrieve_from_store!(model.send("#{mounted_as}_file_name"))
       end
 
-      private :write_internal_identifier, :store_filename, :model_filename
-
-      def rmagick_included?
-        self.class.included_modules.map(&:to_s).include?('CarrierWave::RMagick')
-      end
-
-      # prevent large number of subdirectories
       def store_dir
         str_id = model.id.to_s.rjust(4, '0')
         [AbAdmin.uploads_dir, model.class.to_s.underscore, str_id[0..2], str_id[3..-1]].join('/')
       end
 
+      def convert_to_webp(options = {})
+        webp_path = "#{File.dirname(path)}/#{full_filename}"
+        WebP.encode(path, webp_path, options_for_webp(options))
+        @file = ::CarrierWave::SanitizedFile.new(tempfile: webp_path, filename: webp_path, content_type: 'image/webp')
+      end
+
+      def options_for_webp(options)
+        w, h = width, height
+        options = options.dup
+        ratio = w.to_f / h
+        if options[:resize_to_fill]
+          res_w, res_h = options[:resize_to_fill]
+          res_ratio = res_w.to_f / res_h
+          options.update(resize_w: res_w, resize_h: res_h) unless w == res_w && h == res_h
+          if ratio > res_ratio
+            crop_res_w = h * res_ratio
+            crop_res_h = h
+            options.update(crop_x: ((w - crop_res_w) / 2).to_i, crop_y: 0, crop_w: crop_res_w.to_i, crop_h: crop_res_h.to_i)
+          elsif ratio < res_ratio
+            crop_res_w = w
+            crop_res_h = w / res_ratio
+            options.update(crop_x: 0, crop_y: ((h - crop_res_h) / 2).to_i, crop_w: crop_res_w.to_i, crop_h: crop_res_h.to_i)
+          end
+        elsif options[:resize_to_fit]
+          res_w, res_h = options[:resize_to_fit]
+          res_ratio = res_w.to_f / res_h
+          if ratio == res_ratio
+            options.update(resize_w: res_w, resize_h: res_h) unless w == res_w && h == res_h
+          elsif ratio > res_ratio
+            options.update(resize_w: res_h)
+          elsif ratio < res_ratio
+            options.update(resize_h: res_w)
+          end
+        end
+        options.except(:resize_to_fill, :resize_to_fit)
+      end
+
       # Strips out all embedded information from the image
       # process :strip
       #
       def strip
-        manipulate! do |img|
+        minimagick! do |img|
           img.strip
           img = yield(img) if block_given?
           img
@@ -144,7 +161,7 @@ module AbAdmin
         percentage = normalize_param(percentage)
 
         unless percentage.blank?
-          manipulate! do |img|
+          minimagick! do |img|
             img.quality percentage.to_s
             img = yield(img) if block_given?
             img
@@ -160,7 +177,7 @@ module AbAdmin
 
         unless degrees.blank?
           manipulate! do |img|
-            rmagick_included? ? img.rotate!(degrees.to_i) : img.rotate(degrees.to_s)
+            self.class.included_modules.map(&:to_s).include?('CarrierWave::RMagick') ? img.rotate!(degrees.to_i) : img.rotate(degrees.to_s)
             img = yield(img) if block_given?
             img
           end
@@ -176,7 +193,7 @@ module AbAdmin
         geometry = normalize_param(geometry[0]) if geometry.size == 1
 
         if geometry && geometry.size == 4
-          manipulate! do |img|
+          minimagick! do |img|
             img.crop '%ix%i+%i+%i' % geometry
             img = yield(img) if block_given?
             img
@@ -185,7 +202,7 @@ module AbAdmin
       end
 
       def watermark(watermark_path, gravity='SouthEast')
-        manipulate! do |img|
+        minimagick! do |img|
           resolved_path = watermark_path.is_a?(Symbol) ? send(watermark_path) : watermark_path
           watermark_image = ::MiniMagick::Image.open(resolved_path)
           img.composite(watermark_image) { |c| c.gravity gravity }
@@ -202,12 +219,7 @@ module AbAdmin
       end
 
       def dimensions
-        [magick[:width], magick[:height]]
-      end
-
-      def magick
-        #@magick ||= ::MiniMagick::Image.new(current_path)
-        ::MiniMagick::Image.new(current_path)
+        [width, height]
       end
 
       protected

data/lib/ab_admin/carrierwave/glue.rb

@@ -11,11 +11,6 @@ module AbAdmin
           mount_uploader(:data, uploader, options, &block)
         end
 
-        def sunrise_uploader(*args)
-          ActiveSupport::Deprecation.warn('`sunrise_uploader` is deprecated, use `ab_admin_uploader` instead')
-          ab_admin_uploader(*args)
-        end
-        
         def validates_filesize_of(*attr_names)
           validates_with FileSizeValidator, _merge_attributes(attr_names)
         end

data/lib/ab_admin/concerns/admin_addition.rb

@@ -4,19 +4,23 @@ module AbAdmin
       extend ActiveSupport::Concern
 
       included do
+        attr_accessor :last_updated_timestamp
+        validate :do_not_overwrite, if: :last_updated_timestamp
         scope(:admin, proc { all }) unless respond_to?(:admin)
         scope(:base, -> { all }) unless respond_to?(:base)
-        scope :by_ids, lambda { |ids| where("#{quoted_table_name}.id IN (?)", AbAdmin.val_to_array(ids).push(0)) } unless respond_to?(:by_ids)
 
         class_attribute :batch_actions, instance_writer: false
         self.batch_actions = [:destroy]
       end
 
-      module ClassMethods
-        def for_input_token(r, attr=nil)
-          text = attr ? r[attr] : (r['name_ru'] || r['name'])
-          {id: r.id, text: text}
+      def updated_timestamp(associations: true)
+        res = [updated_at]
+        res += translations.map(&:updated_at) if self.class.translates?
+        if associations
+          associations = self.class.nested_attributes_options.keys unless associations.is_a?(Array)
+          res += associations.flat_map{|assoc| Array(send(assoc)).map(&:updated_timestamp) }
         end
+        res.compact.max
       end
 
       def for_input_token
@@ -27,28 +31,6 @@ module AbAdmin
         "#{self.class.model_name.human(count: 1)} ##{self.id} #{AbAdmin.safe_display_name(self)}"
       end
 
-      def translated_any(attr)
-        send(attr).presence || translations.detect { |r| r.send(attr).present? }.try!(attr)
-      end
-
-      def new_changes
-        excluded_attrs = [:updated_at]
-        excluded_attrs += translated_attribute_names if self.class.translates?
-        all_changes = changes.except(*excluded_attrs).map { |k, v| [k, v[1]] }.to_h
-        if self.class.translates?
-          globalize.dirty.each do |attr, changes|
-            changes.each do |change|
-              all_changes["#{attr}_#{change[0]}"] = send("#{attr}_#{change[0]}")
-            end
-          end
-        end
-        all_changes
-      end
-
-      def admin_comments_count_non_zero
-        self[:admin_comments_count].to_i.zero? ? nil : self[:admin_comments_count]
-      end
-
       def token_data(method, options={})
         assoc = self.class.reflect_on_association(method)
         scope = send(method)
@@ -93,6 +75,12 @@ module AbAdmin
         scope.where(sql, val: send(order_col)).ransack(query[:q]).result(distinct: true).first
       end
 
+      private
+
+      def do_not_overwrite
+        return if new_record? || last_updated_timestamp.blank?
+        errors.add(:base, :changed) if updated_timestamp.to_i > last_updated_timestamp.to_i
+      end
     end
   end
 end

data/lib/ab_admin/concerns/translations_macro.rb

@@ -0,0 +1,97 @@
+module AbAdmin
+  module Concerns
+    module TranslationsMacro
+      def translates(*attr_names)
+        options = attr_names.extract_options!
+        setup_translations(options) unless translates?
+        add_translated_attributes(attr_names.map(&:to_sym) - translated_attribute_names)
+      end
+
+      def setup_translations(options)
+        include InstanceMethods
+        extend ClassMethods
+
+        class_attribute :translated_attribute_names, :translation_options
+        self.translated_attribute_names = []
+        self.translation_options = options
+
+        has_many :translations, class_name: translation_class.name, foreign_key: class_name.foreign_key, dependent: :destroy, autosave: true, inverse_of: :translated_model
+      end
+
+      def add_translated_attributes(attr_names)
+        attr_names.each do |attr_name|
+          define_translation_accessors(attr_name)
+          self.translated_attribute_names << attr_name
+        end
+      end
+
+      def define_translation_accessors(attr_name)
+        define_method("#{attr_name}_translation") { translation_for_locale(I18n.locale).try!(:send, attr_name) }
+        define_method("#{attr_name}_translation=") {|v| translation_for_locale(I18n.locale).try!(:send, "#{attr_name}=", v) }
+        alias_method attr_name, "#{attr_name}_translation"
+        alias_method "#{attr_name}=", "#{attr_name}_translation="
+        define_method("#{attr_name}_default"){ translation_for_locale(I18n.default_locale).try!(:send, attr_name) }
+        AbAdmin.translated_locales.each do |l|
+          define_method("#{attr_name}_#{l}") {translation_for_locale(l).try!(:send, attr_name)}
+          define_method("#{attr_name}_#{l}=") {|v| translation_for_locale(l).try!(:send, "#{attr_name}=", v)}
+        end
+      end
+
+      def class_name
+        name.split('::').last
+      end
+
+      def translates?
+        included_modules.include?(InstanceMethods)
+      end
+
+      module InstanceMethods
+        def translation_for_locale(l)
+          return unless AbAdmin.translated_locales.include?(l)
+          translations.detect{|r| r.locale == l.to_s} || translations.new(locale: l.to_s)
+        end
+
+        def translated_attributes
+          translated_attribute_names.map{|attr| [attr, send(attr)] }.to_h.stringify_keys
+        end
+
+        def attributes
+          super.merge!(translated_attributes)
+        end
+      end
+
+      module ClassMethods
+        def translation_class
+          @translation_class ||= begin
+            klass = self.const_defined?(:Translation, false) ? self.const_get(:Translation, false) : self.const_set(:Translation, Class.new(BaseTranslation))
+            klass.belongs_to :translated_model, class_name: self.name, foreign_key: class_name.foreign_key, inverse_of: :translations, touch: translation_options.fetch(:touch, false)
+            klass
+          end
+        end
+
+        def translations_table_name
+          translation_class.table_name
+        end
+
+        def translated?(name)
+          translated_attribute_names.include?(name.to_sym)
+        end
+      end
+    end
+
+    class BaseTranslation < ::ActiveRecord::Base
+      self.abstract_class = true
+
+      validates :locale, presence: true
+      after_initialize :init
+
+      def init
+        self.locale ||= I18n.locale.to_s
+      end
+
+      def self.table_exists?
+        table_name.present? && super
+      end
+    end
+  end
+end

data/lib/ab_admin/concerns/utilities.rb

@@ -70,7 +70,7 @@ module AbAdmin
             add_cond << assoc.klass.instance_exec(&assoc.scope).to_sql[/WHERE(.*?)(?:(?:ORDER|LIMIT).*)?$/, 1] if assoc.scope
             if assoc.klass.default_scopes.present?
               assoc.klass.default_scopes.each do |scope|
-                add_cond << scope.call.to_sql[/WHERE(.*?)(?:(?:ORDER|LIMIT).*)?$/, 1]
+                add_cond << scope.scope.call.to_sql[/WHERE(.*?)(?:(?:ORDER|LIMIT).*)?$/, 1]
               end
             end
             count_klass = assoc_count.klass
@@ -85,7 +85,7 @@ module AbAdmin
 
         def all_translated_attribute_names
           if translates?
-            ::Globalize.available_locales.map do |loc|
+            AbAdmin.translated_locales.map do |loc|
               translated_attribute_names.map { |attr| "#{attr}_#{loc}" }
             end.flatten
           else

data/lib/ab_admin/config/base.rb

@@ -23,12 +23,20 @@ module AbAdmin
             next if column_name == :id || options[:skip].try(:include?, column_name)
             builder.field(column_name)
           end
+          model.translated_attribute_names.each do |column_name|
+            builder.field(column_name, sortable: false)
+          end if model.translates?
         end
       end
     end
 
     class Table < BaseBuilder
       self.partial_name = 'table'
+
+      def row_html_class
+        return :row_html_class if options[:row_html_class].is_a?(TrueClass)
+        options[:row_html_class]
+      end
     end
 
     class Search < BaseBuilder
@@ -39,6 +47,14 @@ module AbAdmin
       self.partial_name = 'chart'
     end
 
+    class Stats < BaseBuilder
+      self.partial_name = 'stats'
+    end
+
+    class Map < BaseBuilder
+      self.partial_name = 'map'
+    end
+
     class Export < BaseBuilder
       def render_options
         {column_names: fields.map(&:name), column_data: fields.map(&:data),
@@ -111,7 +127,7 @@ module AbAdmin
     end
 
     class BatchAction
-      attr_reader :name, :options, :data, :title, :form
+      attr_reader :name, :options, :data, :form
 
       def initialize(name, options={}, &block)
         @name = name
@@ -119,10 +135,13 @@ module AbAdmin
         if options.has_key?(:form)
           @form = options[:form].is_a?(String) ? options[:form] : "##{name}_batch_form"
         end
-        @title = options[:title] || I18n.t("admin.actions.batch_#{name}.link", default: name.to_s.humanize)
         @data = block_given? ? block : name.to_sym
       end
 
+      def title
+        options[:title] || I18n.t("admin.actions.#{name}.title", default: name.to_s.humanize)
+      end
+
       def confirm
         options[:confirm]
       end
@@ -169,8 +188,12 @@ module AbAdmin
         @data = block
       end
 
-      def apply(relation, params)
-        data.is_a?(Proc) ? data.call(relation, params) : relation.public_send(name)
+      def param_name
+        options[:as] || name
+      end
+
+      def apply(context, relation)
+        data.is_a?(Proc) ? data.call(context, relation) : relation.public_send(name)
       end
     end
   end