obitum-rails_admin 0.0.1 → 0.0.2

data/lib/rails_admin/abstract_model.rb

@@ -1,73 +1,56 @@
-require 'active_support/core_ext/string/inflections'
-require 'rails_admin/generic_support'
-
 module RailsAdmin
   class AbstractModel
-    cattr_accessor :all_models, :all_abstract_models
-    @@all_models = nil
-    @@all_abstract_models = nil
-    # Returns all models for a given Rails app
+    cattr_accessor :all
+    attr_reader :adapter, :model_name
 
-    # self.all_abstract_models
-    def self.all
-      @@all_abstract_models ||= all_models.map{ |model| new(model) }
-    end
+    class << self
+      def reset
+        @@all = nil
+      end
 
-    def self.all_models
-      @@all_models ||= (
-        possible_models = RailsAdmin::Config.included_models.map(&:to_s).presence || ([Rails.application] + Rails::Application::Railties.engines).map do |app|
-          (app.paths['app/models'] + app.config.autoload_paths).map do |load_path|
-            Dir.glob(app.root.join(load_path)).map do |load_dir|
-              Dir.glob(load_dir + "/**/*.rb").map do |filename|
-                lchomp(filename, "#{app.root.join(load_dir)}/").chomp('.rb').camelize  # app/models/module/class.rb => module/class.rb => module/class => Module::Class
-              end
-            end
-          end
-        end.flatten
-        excluded_models = (RailsAdmin::Config.excluded_models.map(&:to_s) + ['RailsAdmin::History'])
-        (possible_models - excluded_models).uniq.sort{|x, y| x.to_s <=> y.to_s}.map{|model| lookup(model) }.compact
-      )
-    end
+      def all(adapter = nil)
+        @@all ||= Config.models_pool.map{ |m| new(m) }.compact
+        adapter ? @@all.select{|m| m.adapter == adapter} : @@all
+      end
 
-    # Given a string +model_name+, finds the corresponding model class
-    def self.lookup(model_name)
-      model = model_name.constantize rescue nil
-      if model && model.is_a?(Class) && superclasses(model).include?(ActiveRecord::Base) && !model.abstract_class?
-        model
-      else
+      alias_method :old_new, :new
+      def new(m)
+        m = m.is_a?(Class) ? m : m.constantize
+        (am = old_new(m)).model && am.adapter ? am : nil
+      rescue LoadError, NameError
         nil
       end
-    rescue LoadError
-      Rails.logger.error "Error while loading '#{model_name}': #{$!}"
-      nil
     end
 
-    def initialize(model)
-      model = self.class.lookup(model.to_s.camelize) unless model.is_a?(Class)
-      @model_name = model.name
-      self.extend(GenericSupport)
-      ### TODO more ORMs support
-      require 'rails_admin/adapters/active_record'
-      self.extend(RailsAdmin::Adapters::ActiveRecord)
+    def initialize(m)
+      @model_name = m.to_s
+      # ActiveRecord
+      if m.ancestors.map(&:to_s).include?('ActiveRecord::Base') && !m.abstract_class?
+        @adapter = :active_record
+        require 'rails_admin/adapters/active_record'
+        extend Adapters::ActiveRecord
+      end
     end
 
+    # do not store a reference to the model, does not play well with ActiveReload/Rails3.2
     def model
-      @model_name.constantize
+      @model_name.try :constantize
     end
 
-    private
+    def config
+      Config.model self
+    end
 
-    def self.superclasses(klass)
-      superclasses = []
-      while klass
-        superclasses << klass.superclass if klass && klass.superclass
-        klass = klass.superclass
-      end
-      superclasses
+    def to_param
+      model.to_s.split("::").map(&:underscore).join("~")
+    end
+
+    def param_key
+      model.to_s.split("::").map(&:underscore).join("_")
     end
 
-    def self.lchomp(base, arg) # yeah.. delete was probably safe, but never know.
-      base.to_s.reverse.chomp(arg.to_s.reverse).reverse
+    def pretty_name
+      model.model_name.human
     end
   end
 end

data/lib/rails_admin/adapters/active_record/abstract_object.rb

@@ -0,0 +1,32 @@
+module RailsAdmin
+  module Adapters
+    module ActiveRecord
+      class AbstractObject
+        # undef almost all of this class's methods so it will pass almost
+        # everything through to its delegate using method_missing (below).
+        instance_methods.each { |m| undef_method m unless m.to_s =~ /(^__|^send$|^object_id$)/ }
+        #                                                  ^^^^^
+        # the unnecessary "to_s" above is a workaround for meta_where, see
+        # https://github.com/sferik/rails_admin/issues/374
+
+        attr_accessor :object
+
+        def initialize(object)
+          self.object = object
+        end
+
+        def set_attributes(attributes, role = nil)
+          object.assign_attributes(attributes, :as => role)
+        end
+
+        def save(options = { :validate => true })
+          object.save(options)
+        end
+
+        def method_missing(name, *args, &block)
+          self.object.send(name, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/adapters/active_record.rb

@@ -1,34 +1,26 @@
 require 'active_record'
-require 'rails_admin/config/sections/list'
-require 'rails_admin/abstract_object'
+require 'rails_admin/adapters/active_record/abstract_object'
 
 module RailsAdmin
   module Adapters
     module ActiveRecord
-      DISABLED_COLUMN_TYPES = [:tsvector, :blob, :binary]
-      @@polymorphic_parents = nil
+      DISABLED_COLUMN_TYPES = [:tsvector, :blob, :binary, :spatial]
+      LIKE_OPERATOR =  ::ActiveRecord::Base.configurations[Rails.env]['adapter'] == "postgresql" ? 'ILIKE' : 'LIKE'
 
-      def self.polymorphic_parents(name)
-        @@polymorphic_parents ||= {}.tap do |hash|
-          RailsAdmin::AbstractModel.all_models.each do |klass|
-            klass.reflect_on_all_associations.select{|r| r.options[:as] }.each do |reflection|
-              (hash[reflection.options[:as].to_sym] ||= []) << klass
-            end
-          end
-        end
-        @@polymorphic_parents[name.to_sym]
+      def new(params = {})
+        AbstractObject.new(model.new(params))
       end
 
       def get(id)
         if object = model.where(model.primary_key => id).first
-          RailsAdmin::AbstractObject.new object
+          AbstractObject.new object
         else
           nil
         end
       end
 
-      def count(options = {}, scope = nil)
-        all(options.merge({:limit => false, :page => false}), scope).count
+      def scoped
+        model.scoped
       end
 
       def first(options = {}, scope = nil)
@@ -40,56 +32,19 @@ module RailsAdmin
         scope = scope.includes(options[:include]) if options[:include]
         scope = scope.limit(options[:limit]) if options[:limit]
         scope = scope.where(model.primary_key => options[:bulk_ids]) if options[:bulk_ids]
-        scope = scope.where(options[:conditions]) if options[:conditions]
+        scope = scope.where(query_conditions(options[:query])) if options[:query]
+        scope = scope.where(filter_conditions(options[:filters])) if options[:filters]
         scope = scope.page(options[:page]).per(options[:per]) if options[:page] && options[:per]
         scope = scope.reorder("#{options[:sort]} #{options[:sort_reverse] ? 'asc' : 'desc'}") if options[:sort]
         scope
       end
 
-      def scoped
-        model.scoped
-      end
-
-      def create(params = {})
-        model.create(params)
-      end
-
-      def new(params = {})
-        RailsAdmin::AbstractObject.new(model.new(params))
+      def count(options = {}, scope = nil)
+        all(options.merge({:limit => false, :page => false}), scope).count
       end
 
       def destroy(objects)
-        [objects].flatten.map &:destroy
-      end
-
-      def destroy_all!
-        model.all.each do |object|
-          object.destroy
-        end
-      end
-
-      def has_and_belongs_to_many_associations
-        associations.select do |association|
-          association[:type] == :has_and_belongs_to_many
-        end
-      end
-
-      def has_many_associations
-        associations.select do |association|
-          association[:type] == :has_many
-        end
-      end
-
-      def has_one_associations
-        associations.select do |association|
-          association[:type] == :has_one
-        end
-      end
-
-      def belongs_to_associations
-        associations.select do |association|
-          association[:type] == :belongs_to
-        end
+        Array.wrap(objects).each &:destroy
       end
 
       def associations
@@ -98,9 +53,9 @@ module RailsAdmin
             :name => association.name.to_sym,
             :pretty_name => association.name.to_s.tr('_', ' ').capitalize,
             :type => association.macro,
-            :parent_model => association_parent_model_lookup(association),
+            :parent_model_proc => Proc.new { association_parent_model_lookup(association) },
             :parent_key => association_parent_key_lookup(association),
-            :child_model => association_child_model_lookup(association),
+            :child_model_proc => Proc.new { association_child_model_lookup(association) },
             :child_key => association_child_key_lookup(association),
             :foreign_type => association_foreign_type_lookup(association),
             :as => association_as_lookup(association),
@@ -112,12 +67,6 @@ module RailsAdmin
         end
       end
 
-      def polymorphic_associations
-        (has_many_associations + has_one_associations).select do |association|
-          association[:options][:as]
-        end
-      end
-
       def properties
         columns = model.columns.reject {|c| c.type.blank? || DISABLED_COLUMN_TYPES.include?(c.type.to_sym) }
         columns.map do |property|
@@ -132,68 +81,47 @@ module RailsAdmin
         end
       end
 
-      def model_store_exists?
-        model.table_exists?
-      end
+      private
 
-      def get_conditions_hash(model_config, query, filters)
-        @like_operator =  "ILIKE" if ::ActiveRecord::Base.configurations[Rails.env]['adapter'] == "postgresql"
-        @like_operator ||= "LIKE"
-
-        query_statements = []
-        filters_statements = []
+      def query_conditions(query, fields = config.list.fields.select(&:queryable?))
+        statements = []
         values = []
-        conditions = [""]
-
-        if query.present?
-          queryable_fields = model_config.list.fields.select(&:queryable?)
-          queryable_fields.each do |field|
-            searchable_columns = field.searchable_columns.flatten
-            searchable_columns.each do |field_infos|
-              statement, value1, value2 = build_statement(field_infos[:column], field_infos[:type], query, field.search_operator)
-              if statement
-                query_statements << statement
-                values << value1 unless value1.nil?
-                values << value2 unless value2.nil?
-              end
-            end
+
+        fields.each do |field|
+          field.searchable_columns.flatten.each do |column_infos|
+            statement, value1, value2 = build_statement(column_infos[:column], column_infos[:type], query, field.search_operator)
+            statements << statement if statement
+            values << value1 unless value1.nil?
+            values << value2 unless value2.nil?
           end
         end
 
-        unless query_statements.empty?
-          conditions[0] += " AND " unless conditions == [""]
-          conditions[0] += "(#{query_statements.join(" OR ")})"
-        end
+        [statements.join(' OR '), *values]
+      end
+
+      # filters example => {"string_field"=>{"0055"=>{"o"=>"like", "v"=>"test_value"}}, ...}
+      # "0055" is the filter index, no use here. o is the operator, v the value
+      def filter_conditions(filters, fields = config.list.fields.select(&:filterable?))
+        statements = []
+        values = []
 
-        if filters.present?
-          @filterable_fields = model_config.list.fields.select(&:filterable?).inject({}){ |memo, field| memo[field.name.to_sym] = field.searchable_columns; memo }
-          filters.each_pair do |field_name, filters_dump|
-            filters_dump.each do |filter_index, filter_dump|
-              field_statements = []
-              @filterable_fields[field_name.to_sym].each do |field_infos|
-                statement, value1, value2 = build_statement(field_infos[:column], field_infos[:type], filter_dump[:v], (filter_dump[:o] || 'default'))
-                if statement
-                  field_statements << statement
-                  values << value1 unless value1.nil?
-                  values << value2 unless value2.nil?
-                end
-              end
-              filters_statements << "(#{field_statements.join(' OR ')})" unless field_statements.empty?
+        filters.each_pair do |field_name, filters_dump|
+          filters_dump.each do |filter_index, filter_dump|
+            field_statements = []
+            fields.find{|f| f.name.to_s == field_name}.searchable_columns.each do |column_infos|
+              statement, value1, value2 = build_statement(column_infos[:column], column_infos[:type], filter_dump[:v], (filter_dump[:o] || 'default'))
+              field_statements << statement if statement.present?
+              values << value1 unless value1.nil?
+              values << value2 unless value2.nil?
             end
+            statements << "(#{field_statements.join(' OR ')})" unless field_statements.empty?
           end
         end
 
-        unless filters_statements.empty?
-         conditions[0] += " AND " unless conditions == [""]
-         conditions[0] += "#{filters_statements.join(" AND ")}" # filters should all be true
-        end
-
-        conditions += values
-        conditions != [""] ? { :conditions => conditions } : {}
+        [statements.join(' AND '), *values]
       end
 
       def build_statement(column, type, value, operator)
-
         # this operator/value has been discarded (but kept in the dom to override the one stored in the various links of the page)
         return if operator == '_discard' || value == '_discard'
 
@@ -232,7 +160,7 @@ module RailsAdmin
           when 'is', '='
             "#{value}"
           end
-          ["(#{column} #{@like_operator} ?)", value]
+          ["(#{column} #{LIKE_OPERATOR} ?)", value]
         when :datetime, :timestamp, :date
           return unless operator != 'default'
           values = case operator
@@ -257,23 +185,21 @@ module RailsAdmin
           ["(#{column} BETWEEN ? AND ?)", *values]
         when :enum
           return if value.blank?
-          ["(#{column} IN (?))", [value].flatten]
+          ["(#{column} IN (?))", Array.wrap(value)]
         end
       end
 
-      def association_options(association)
-        if association.options[:polymorphic]
-          {
-            :polymorphic => true,
-            :foreign_type => association.options[:foreign_type] || "#{association.name}_type"
-          }
-        elsif association.options[:as]
-          {
-            :as => association.options[:as]
-          }
-        else
-          {}
+      @@polymorphic_parents = nil
+
+      def self.polymorphic_parents(name)
+        @@polymorphic_parents ||= {}.tap do |hash|
+          RailsAdmin::AbstractModel.all(:active_record).each do |am|
+            am.model.reflect_on_all_associations.select{|r| r.options[:as] }.each do |reflection|
+              (hash[reflection.options[:as].to_sym] ||= []) << am.model
+            end
+          end
         end
+        @@polymorphic_parents[name.to_sym]
       end
 
       def association_parent_model_lookup(association)
@@ -333,14 +259,7 @@ module RailsAdmin
       end
 
       def association_child_key_lookup(association)
-        case association.macro
-        when :belongs_to
-          association.options[:foreign_key].try(:to_sym) || "#{association.name}_id".to_sym
-        when :has_one, :has_many, :has_and_belongs_to_many
-          association.foreign_key.to_sym
-        else
-          raise "Unknown association type: #{association.macro.inspect}"
-        end
+        association.foreign_key.to_sym
       end
     end
   end

data/lib/rails_admin/config/actions/base.rb

@@ -1,101 +1,113 @@
-require 'rails_admin/config/base'
+require 'rails_admin/config/proxyable'
+require 'rails_admin/config/configurable'
 require 'rails_admin/config/hideable'
 
 module RailsAdmin
   module Config
     module Actions
-      class Base < RailsAdmin::Config::Base
+      class Base
+        include RailsAdmin::Config::Proxyable
+        include RailsAdmin::Config::Configurable
         include RailsAdmin::Config::Hideable
-        
+
+        # http://twitter.github.com/bootstrap/base-css.html#icons
+        register_instance_option :link_icon do
+          'icon-question-sign'
+        end
+
         # Should the action be visible
         register_instance_option :visible? do
-          true
+          authorized? && (bindings[:abstract_model] ? bindings[:abstract_model].config.with(bindings).try(:visible?) : true)
         end
-        
+
+        register_instance_option :authorized? do
+          bindings[:controller] ? bindings[:controller].authorized?(self.authorization_key, bindings[:abstract_model], bindings[:object]) : true
+        end
+
         # Is the action acting on the root level (Example: /admin/contact)
         register_instance_option :root? do
           false
         end
-        
-        # Is the action on a model scope (Example: /admin/teams/export)
+
+        # Is the action on a model scope (Example: /admin/team/export)
         register_instance_option :collection? do
           false
         end
-        
-        # Is the action on an object scope (Example: /admin/teams/1/edit)
+
+        # Is the action on an object scope (Example: /admin/team/1/edit)
         register_instance_option :member? do
           false
         end
-        
+
         # This block is evaluated in the context of the controller when action is called
         # You can access:
-        # - @abstract_model & @model_config if your on a model or object scope
+        # - @objects if you're on a model scope
+        # - @abstract_model & @model_config if you're on a model or object scope
         # - @object if you're on an object scope
         register_instance_option :controller do
           Proc.new do
             render :action => @action.template_name
           end
         end
-        
+
         # Model scoped actions only. You will need to handle params[:bulk_ids] in controller
         register_instance_option :bulkable? do
           false
         end
-        
+
         # View partial name (called in default :controller block)
         register_instance_option :template_name do
           key.to_sym
         end
-        
+
         # For Cancan and the like
         register_instance_option :authorization_key do
           key.to_sym
         end
-        
+
         # List of methods allowed. Note that you are responsible for correctly handling them in :controller block
         register_instance_option :http_methods do
           [:get]
         end
-        
+
         # Url fragment
         register_instance_option :route_fragment do
           custom_key.to_s
         end
-        
+
         # Controller action name
         register_instance_option :action_name do
           custom_key.to_sym
         end
-        
+
         # I18n key
         register_instance_option :i18n_key do
           key
         end
-        
+
         # User should override only custom_key (action name and route fragment change, allows for duplicate actions)
         register_instance_option :custom_key do
           key
         end
-        
+
         # Breadcrumb parent
         register_instance_option :breadcrumb_parent do
-          case 
+          case
           when root?
-            :dashboard
+            [:dashboard]
           when collection?
-            :index
+            [:index, bindings[:abstract_model]]
           when member?
-            :show
+            [:show, bindings[:abstract_model], bindings[:object]]
           end
         end
-        
-        
+
         # Off API.
-        
+
         def key
           self.class.key
         end
-        
+
         def self.key
           self.name.to_s.demodulize.underscore.to_sym
         end

data/lib/rails_admin/config/actions/bulk_delete.rb

@@ -3,50 +3,49 @@ module RailsAdmin
     module Actions
       class BulkDelete < RailsAdmin::Config::Actions::Base
         RailsAdmin::Config::Actions.register(self)
-        
+
         register_instance_option :collection do
           true
         end
-                
+
         register_instance_option :http_methods do
           [:post, :delete]
         end
-        
+
         register_instance_option :controller do
           Proc.new do
 
             if request.post? # BULK DELETE
-              
+
               @objects = list_entries(@model_config, :destroy)
-              not_found and return if @objects.empty?
 
               render @action.template_name
 
             elsif request.delete? # BULK DESTROY
-              
+
               @objects = list_entries(@model_config, :destroy)
               processed_objects = @abstract_model.destroy(@objects)
 
               destroyed = processed_objects.select(&:destroyed?)
               not_destroyed = processed_objects - destroyed
-              
+
               destroyed.each do |object|
                 @auditing_adapter && @auditing_adapter.delete_object("Destroyed #{@model_config.with(:object => object).object_label}", object, @abstract_model, _current_user)
-              end                   
+              end
 
               flash[:success] = t("admin.flash.successful", :name => pluralize(destroyed.count, @model_config.label), :action => t("admin.actions.delete.done")) unless destroyed.empty?
               flash[:error] = t("admin.flash.error", :name => pluralize(not_destroyed.count, @model_config.label), :action => t("admin.actions.delete.done")) unless not_destroyed.empty?
 
               redirect_to back_or_index
-              
+
             end
           end
         end
-        
+
         register_instance_option :authorization_key do
           :destroy
         end
-        
+
         register_instance_option :bulkable? do
           true
         end

data/lib/rails_admin/config/actions/dashboard.rb

@@ -3,19 +3,19 @@ module RailsAdmin
     module Actions
       class Dashboard < RailsAdmin::Config::Actions::Base
         RailsAdmin::Config::Actions.register(self)
-        
+
         register_instance_option :root? do
           true
         end
-        
+
         register_instance_option :breadcrumb_parent do
           nil
         end
-        
+
         register_instance_option :controller do
           Proc.new do
             @history = @auditing_adapter && @auditing_adapter.latest || []
-            @abstract_models = RailsAdmin::Config.visible_models.map(&:abstract_model)
+            @abstract_models = RailsAdmin::Config.visible_models(:controller => self).map(&:abstract_model)
 
             @most_recent_changes = {}
             @count = {}
@@ -30,10 +30,14 @@ module RailsAdmin
             render @action.template_name, :status => (flash[:error].present? ? :not_found : 200)
           end
         end
-        
+
         register_instance_option :route_fragment do
           ''
         end
+
+        register_instance_option :link_icon do
+          'icon-home'
+        end
       end
     end
   end