ab_admin 0.1.0

data/lib/ab_admin/carrierwave/file_size_validator.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+module AbAdmin
+  module CarrierWave
+    class FileSizeValidator < ActiveModel::EachValidator
+      MESSAGES  = { :is => :wrong_size, :minimum => :size_too_small, :maximum => :size_too_big }.freeze
+      CHECKS    = { :is => :==, :minimum => :>=, :maximum => :<= }.freeze
+
+      DEFAULT_TOKENIZER = lambda { |value| value.split(//) }
+      RESERVED_OPTIONS  = [:minimum, :maximum, :within, :is, :tokenizer, :too_short, :too_long]
+
+      def initialize(options)
+        if range = (options.delete(:in) || options.delete(:within))
+          raise ArgumentError, ":in and :within must be a Range" unless range.is_a?(Range)
+          options[:minimum], options[:maximum] = range.begin, range.end
+          options[:maximum] -= 1 if range.exclude_end?
+        end
+
+        super
+      end
+
+      def check_validity!
+        keys = CHECKS.keys & options.keys
+
+        if keys.empty?
+          raise ArgumentError, 'Range unspecified. Specify the :within, :maximum, :minimum, or :is option.'
+        end
+
+        keys.each do |key|
+          value = options[key]
+
+          unless value.is_a?(Integer) && value >= 0
+            raise ArgumentError, ":#{key} must be a nonnegative Integer"
+          end
+        end
+      end
+
+      def validate_each(record, attribute, value)
+        raise(ArgumentError, "A CarrierWave::Uploader::Base object was expected") unless value.kind_of? ::CarrierWave::Uploader::Base
+        
+        value = (options[:tokenizer] || DEFAULT_TOKENIZER).call(value) if value.kind_of?(String)
+
+        CHECKS.each do |key, validity_check|
+          next unless check_value = options[key]
+
+          value ||= [] if key == :maximum
+
+          value_size = value.size
+          next if value_size.send(validity_check, check_value)
+
+          errors_options = options.except(*RESERVED_OPTIONS)
+          errors_options[:file_size] = help.number_to_human_size check_value
+
+          default_message = options[MESSAGES[key]]
+          errors_options[:message] ||= default_message if default_message
+
+          record.errors.add(attribute, MESSAGES[key], errors_options)
+        end
+      end
+      
+      def help
+        Helper.instance
+      end
+
+      class Helper
+        include Singleton
+        include ActionView::Helpers::NumberHelper
+      end
+    end
+  end
+end

data/lib/ab_admin/carrierwave/glue.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+module AbAdmin
+  module CarrierWave
+    module Glue
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def sunrise_uploader(uploader=nil, options={}, &block)
+          options = { :mount_on => :data_file_name }.merge(options)
+          
+          mount_uploader(:data, uploader, options, &block)
+          
+          validates_processing_of :data
+        end
+        
+        def validates_filesize_of(*attr_names)
+          validates_with FileSizeValidator, _merge_attributes(attr_names)
+        end
+      end
+      
+    end
+  end
+end

data/lib/ab_admin/concerns/admin_addition.rb

@@ -0,0 +1,38 @@
+# -*- encoding : utf-8 -*-
+module AbAdmin
+  module Concerns
+    module AdminAddition
+      extend ActiveSupport::Concern
+
+      included do
+        scope :admin, scoped
+        scope :base, scoped
+        scope :ids, lambda { |ids| where("#{quoted_table_name}.id IN (?)", AbAdmin.val_to_array(ids).push(0)) }
+
+        class_attribute :batch_actions, :instance_writer => false
+        self.batch_actions = [:destroy]
+      end
+
+      def next_prev_by_url(scope, url, prev=false)
+        predicates = {'>' => '<', '<' => '>', 'desc' => 'asc', 'asc' => 'desc'}
+        query = Rack::Utils.parse_nested_query(URI.parse(url).query).symbolize_keys
+        query[:q] ||= {}
+        order_str = query[:q]['s'] || 'id desc'
+        order_col, order_mode = order_str.split
+        quoted_order_col = self.class.quote_column(order_col)
+        if prev
+          query[:q]['s'] = ["#{order_col} #{predicates[order_mode]}", 'id desc']
+          predicate = order_mode == 'desc' ? '>' : '<'
+          id_predicate = '<'
+        else
+          query[:q]['s'] = ["#{order_col} #{order_mode}", 'id']
+          predicate = order_mode == 'desc' ? '<' : '>'
+          id_predicate = '>'
+        end
+        sql = "(#{quoted_order_col} #{predicate} :val OR (#{quoted_order_col} = :val AND #{self.class.quote_column('id')} #{id_predicate} #{self.id}))"
+        scope.where(sql, :val => self.send(order_col)).ransack(query[:q]).result(:distinct => true).first
+      end
+
+    end
+  end
+end

data/lib/ab_admin/concerns/deep_cloneable.rb

@@ -0,0 +1,55 @@
+# -*- encoding : utf-8 -*-
+module AbAdmin
+  module Concerns
+    module DeepCloneable
+
+      def deep_duplicate(*args)
+        deep_dup(false, *args)
+      end
+
+      def deep_dup(target, *args)
+        dupl = target || self.dup
+
+        args.reject! { |a| a.blank? }
+        return dupl if args.empty?
+
+        args.each do |arg|
+          case arg
+            when Hash
+              arg.each do |k, v|
+                dup_simple(dupl, k, v)
+              end
+            else
+              Array(arg).each do |k|
+                if k.kind_of?(Hash) || k.kind_of?(Array)
+                  self.deep_dup(dupl, k)
+                else
+                  dup_simple(dupl, k)
+                end
+              end
+          end
+        end
+
+        dupl
+      end
+
+      def dup_simple(dupl, k, v=nil)
+        if check_assoc(k).collection?
+          self.send(k).each do |rec|
+            dupl.send(k) << (v ? rec.deep_dup(false, v) : rec.dup)
+          end
+        else
+          dupl.send("#{k}=", (v ? self.send(k).deep_dup(false, v) : self.send(k).dup))
+        end
+
+        dupl
+      end
+
+      def check_assoc(assoc_method)
+        raise "Target has no association #{assoc_method}" unless assoc = self.class.reflect_on_association(assoc_method)
+        assoc
+      end
+
+    end
+  end
+end

data/lib/ab_admin/concerns/headerable.rb

@@ -0,0 +1,31 @@
+# -*- encoding : utf-8 -*-
+module AbAdmin
+  module Concerns
+    module Headerable
+      extend ActiveSupport::Concern
+
+      included do
+        has_one :header, :as => :headerable, :dependent => :delete
+
+        attr_accessible :header_attributes
+
+        accepts_nested_attributes_for :header, :reject_if => :all_blank
+
+        ::Header.all_translated_attribute_names.each do |attr|
+          define_method "header_#{attr}=" do |val|
+            default_header.send("#{attr}=", val)
+          end
+
+          define_method "header_#{attr}" do
+            default_header.send(attr)
+          end
+        end
+      end
+
+      def default_header
+        header || build_header
+      end
+
+    end
+  end
+end

data/lib/ab_admin/concerns/nested_set.rb

@@ -0,0 +1,77 @@
+# -*- encoding : utf-8 -*-
+module AbAdmin
+  module Concerns
+    module NestedSet
+      extend ActiveSupport::Concern
+
+      included do
+        acts_as_nested_set
+        after_move :update_search_index
+
+        attr_accessor :cached_children
+
+        scope :nested_set, order('lft ASC')
+        scope :reversed_nested_set, order('lft DESC')
+        scope :with_depth, proc { |level| where(:depth => level) }
+      end
+
+      module ClassMethods
+        def build_tree(records)
+          tree = {}
+          roots = []
+          records.each do |record|
+            if record.root?
+              roots << record
+              next
+            end
+            tree[record.parent_id] ||= []
+            tree[record.parent_id] << record
+          end
+          roots.each do |root|
+            root.tree_children(tree)
+          end
+          roots
+        end
+
+        def nested_opts(records, mover=nil)
+          res = []
+          records.each do |r|
+            next if mover && mover.id == r.id
+            res << ["#{'–' * r.depth} #{AbAdmin.display_name(r)}", r.id]
+          end
+          res
+        end
+      end
+
+      def nested_opts(collection=nil)
+        collection ||= self.class.all
+        self.class.nested_opts(collection, self)
+      end
+
+      def tree_children(tree)
+        return unless tree[self.id]
+        self.cached_children = tree[self.id]
+        self.cached_children.each do |r|
+          r.tree_children(tree)
+        end
+      end
+
+      def deep_parent
+        root? ? self : self.parent.try(:deep_parent)
+      end
+
+      def moveable?
+        new_record? || !root?
+      end
+
+      def descendants_count
+        (right - left - 1) / 2
+      end
+
+      def update_search_index
+        tire.update_index if respond_to?(:tire)
+        true
+      end
+    end
+  end
+end

data/lib/ab_admin/concerns/silencer.rb

@@ -0,0 +1,34 @@
+# -*- encoding : utf-8 -*-
+module AbAdmin
+  module Concerns
+    module Silencer
+
+      def no_timestamps(&block)
+        original_setting = ActiveRecord::Base.record_timestamps
+        ActiveRecord::Base.record_timestamps = false
+        begin
+          yield
+        ensure
+          ActiveRecord::Base.record_timestamps = original_setting
+        end
+      end
+
+      def no_versions(&block)
+        original_setting = PaperTrail.enabled?
+        PaperTrail.enabled = false
+        begin
+          yield
+        ensure
+          PaperTrail.enabled = original_setting
+        end
+      end
+
+      def full_silence(&block)
+        no_timestamps do
+          no_versions(&block)
+        end
+      end
+
+    end
+  end
+end

data/lib/ab_admin/concerns/utilities.rb

@@ -0,0 +1,124 @@
+# -*- encoding : utf-8 -*-
+module AbAdmin
+  module Concerns
+    module Utilities
+      extend ActiveSupport::Concern
+
+      included do
+        delegate :value_to_boolean, :to => ActiveRecord::ConnectionAdapters::Column
+      end
+
+      module ClassMethods
+        def max_time
+          Rails.cache.fetch("by_class_#{name}", :expires_in => 60) { maximum(:updated_at).to_i }
+        end
+
+        def max_time_by_scope(scope)
+          Rails.cache.fetch("by_class_#{name}_#{scope}", :expires_in => 60) { send(scope).maximum(:updated_at).to_i }
+        end
+
+        def full_truncate
+          destroy_all
+          truncate!
+          const_get(:Translation).truncate_table if translates?
+        end
+
+        def all_ids
+          select(:id).map(&:id)
+        end
+
+        def all_models
+          Dir.glob(Rails.root.to_s + '/app/models/**/*.rb').each { |file| require file }
+          ActiveRecord::Base.descendants.find_all { |model| model.table_exists? }
+          #ActiveRecord::Base.descendants.find_all { |model| model.descends_from_active_record? }
+        end
+
+        def han(attr)
+          human_attribute_name(attr)
+        end
+
+        def quote_column(col_name)
+          "#{quoted_table_name}.#{connection.quote_column_name(col_name)}"
+        end
+
+        def update_counter_columns(*args)
+          args.each do |counter_column|
+            assoc = reflect_on_association(counter_column.to_s.sub(/_count$/, '').to_sym)
+            if assoc
+              count_klass = assoc.klass
+              query = <<-SQL
+                UPDATE #{quoted_table_name} SET #{counter_column} = (SELECT COUNT(#{count_klass.quoted_table_name}.id)
+                  FROM #{count_klass.quoted_table_name}
+                  WHERE #{quoted_table_name}.id = #{count_klass.quoted_table_name}.#{assoc.foreign_key})
+              SQL
+              connection.execute(query)
+            end
+          end
+        end
+
+        def update_counter_column(col, ass)
+          assoc = reflect_on_association(ass)
+          if assoc
+            if assoc.options[:through]
+              assoc_count = reflect_on_association(assoc.options[:through])
+              if assoc.klass.quoted_table_name == quoted_table_name
+                add_from = ''
+                add_cond = '1=1'
+              else
+                add_from = "INNER JOIN #{assoc.klass.quoted_table_name} ON #{assoc_count.klass.quoted_table_name}.#{assoc.foreign_key} = #{assoc.klass.quoted_table_name}.id"
+                add_cond = assoc.sanitized_conditions || '1=1'
+              end
+            else
+              assoc_count = assoc
+              add_from = ''
+              add_cond = assoc.sanitized_conditions || '1=1'
+            end
+            count_klass = assoc_count.klass
+            query = <<-SQL
+                UPDATE #{quoted_table_name} SET #{col} = (SELECT COUNT(#{count_klass.quoted_table_name}.id)
+                  FROM #{count_klass.quoted_table_name} #{add_from}
+                  WHERE #{quoted_table_name}.id = #{count_klass.quoted_table_name}.#{assoc_count.foreign_key} AND #{add_cond})
+            SQL
+            connection.execute(query)
+          end
+        end
+
+        def all_translated_attribute_names
+          if translates?
+            ::I18n.available_locales.map do |loc|
+              translated_attribute_names.map { |attr| "#{attr}_#{loc}" }
+            end.flatten
+          else
+            []
+          end
+        end
+
+        def all_columns_names
+          if translates?
+            column_names + all_translated_attribute_names + translated_attribute_names.map(&:to_s)
+          else
+            column_names
+          end
+        end
+
+        def generate_guid(column=:guid)
+          loop do
+            token = Devise.friendly_token
+            break token unless to_adapter.find_first({column => token})
+          end
+        end
+      end
+
+      def compare_key
+        "#{self.class.model_name.singular}_#{id}"
+      end
+
+      def generate_token(column)
+        begin
+          self[column] = Devise.friendly_token
+        end while self.class.exists?(column => self[column])
+      end
+    end
+
+  end
+end