drewda_rails_admin 0.0.1

data/lib/rails_admin/adapters/mongoid.rb

@@ -0,0 +1,333 @@
+require 'mongoid'
+require 'rails_admin/config/sections/list'
+require 'rails_admin/adapters/mongoid/abstract_object'
+
+module RailsAdmin
+  module Adapters
+    module Mongoid
+      STRING_TYPE_COLUMN_NAMES = [:name, :title, :subject]
+
+      def new(params = {})
+        AbstractObject.new(model.new)
+      end
+
+      def get(id)
+        if object = model.where(:_id=>BSON::ObjectId(id)).first
+          AbstractObject.new object
+        else
+          nil
+        end
+      end
+
+      def scoped
+        model.scoped
+      end
+
+      def first(options = {},scope=nil)
+        all(options, scope).first
+      end
+
+      def all(options = {},scope=nil)
+        scope ||= self.scoped
+        scope = scope.includes(options[:include]) if options[:include]
+        scope = scope.limit(options[:limit]) if options[:limit]
+        scope = scope.any_in(:_id => options[:bulk_ids]) if options[:bulk_ids]
+        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 = if options[:sort] && options[:sort_reverse]
+          scope.desc(options[:sort])
+        elsif options[:sort]
+          scope.asc(options[:sort])
+        else
+          scope
+        end
+      end
+      
+      def count(options = {},scope=nil)
+        all(options.merge({:limit => false, :page => false}), scope).count
+      end
+
+      def destroy(objects)
+        Array.wrap(objects).each &:destroy
+      end
+
+      def primary_key
+        :_id
+      end
+
+      def associations
+        model.associations.values.map do |association|
+          {
+            :name => association.name.to_sym,
+            :pretty_name => association.name.to_s.tr('_', ' ').capitalize,
+            :type => association_type_lookup(association.macro),
+            :model_proc => Proc.new { association_model_proc_lookup(association) },
+            :primary_key_proc => Proc.new { association_primary_key_lookup(association) },
+            :foreign_key => association_foreign_key_lookup(association),
+            :foreign_type => association_foreign_type_lookup(association),
+            :as => association_as_lookup(association),
+            :polymorphic => association_polymorphic_lookup(association),
+            :inverse_of => association_inverse_of_lookup(association),
+            :read_only => nil,
+            :nested_form => nil
+          }
+        end
+      end
+
+      def properties
+        @properties if @properties
+        @properties = model.fields.map do |name,field|
+          ar_type =
+            if name == '_type'
+              { :type => :mongoid_type, :length => 1024 }
+            elsif field.type.to_s == 'String'
+              if (length = length_validation_lookup(name)) && length < 256
+                { :type => :string, :length => length }
+              elsif STRING_TYPE_COLUMN_NAMES.include?(name.to_sym)
+                { :type => :string, :length => 255 }
+              else
+                { :type => :text, :length => nil }
+              end
+            else
+              {
+                "Array"          => { :type => :serialized, :length => nil },
+                "BigDecimal"     => { :type => :string, :length => 1024 },
+                "Boolean"        => { :type => :boolean, :length => nil },
+                "BSON::ObjectId" => { :type => :bson_object_id, :length => nil },
+                "Date"           => { :type => :date, :length => nil },
+                "DateTime"       => { :type => :datetime, :length => nil },
+                "Float"          => { :type => :float, :length => nil },
+                "Hash"           => { :type => :serialized, :length => nil },
+                "Integer"        => { :type => :integer, :length => nil },
+                "Time"           => { :type => :datetime, :length => nil },
+                "Object"         => { :type => :bson_object_id, :length => nil },
+              }[field.type.to_s] or raise "Need to map field #{field.type.to_s} for field name #{name} in #{model.inspect}"
+            end
+
+          {
+            :name => field.name.to_sym,
+            :pretty_name => field.name.to_s.gsub('_', ' ').strip.capitalize,
+            :nullable? => true,
+            :serial? => false,
+          }.merge(ar_type)
+        end
+      end
+
+      def table_name
+        model.collection.name
+      end
+
+      def serialized_attributes
+        # Mongoid Array and Hash type columns are mapped to RA serialized type
+        # through type detection in self#properties.
+        []
+      end
+
+      private
+
+      def query_conditions(query, fields = config.list.fields.select(&:queryable?))
+        statements = []
+
+        fields.each do |field|
+          conditions_per_collection = {}
+          field.searchable_columns.flatten.each do |column_infos|
+            collection_name, column_name = column_infos[:column].split('.')
+            statement = build_statement(column_name, column_infos[:type], query, field.search_operator)
+            if statement
+              conditions_per_collection[collection_name] ||= []
+              conditions_per_collection[collection_name] << statement
+            end
+          end
+          statements.concat make_condition_for_current_collection(field, conditions_per_collection)
+        end
+
+        if statements.any?
+          { '$or' => statements }
+        else
+          {}
+        end
+      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 = []
+
+        filters.each_pair do |field_name, filters_dump|
+          filters_dump.each do |filter_index, filter_dump|
+            conditions_per_collection = {}
+            field = fields.find{|f| f.name.to_s == field_name}
+            next unless field
+            field.searchable_columns.each do |column_infos|
+              collection_name, column_name = column_infos[:column].split('.')
+              statement = build_statement(column_name, column_infos[:type], filter_dump[:v], (filter_dump[:o] || 'default'))
+              if statement
+                conditions_per_collection[collection_name] ||= []
+                conditions_per_collection[collection_name] << statement
+              end
+            end
+            if conditions_per_collection.any?
+              field_statements = make_condition_for_current_collection(field, conditions_per_collection)
+              if field_statements.length > 1
+                statements << { '$or' => field_statements }
+              else
+                statements << field_statements.first
+              end
+            end
+          end
+        end
+
+        if statements.any?
+          { '$and' => statements }
+        else
+          {}
+        end
+      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'
+
+        # filtering data with unary operator, not type dependent
+        if operator == '_blank' || value == '_blank'
+          return { column => {'$in' => [nil, '']} }
+        elsif operator == '_present' || value == '_present'
+          return { column => {'$nin' => [nil, '']} }
+        elsif operator == '_null' || value == '_null'
+          return { column => nil }
+        elsif operator == '_not_null' || value == '_not_null'
+          return { column => {'$ne' => nil} }
+        elsif operator == '_empty' || value == '_empty'
+          return { column => '' }
+        elsif operator == '_not_empty' || value == '_not_empty'
+          return { column => {'$ne' => ''} }
+        end
+        # now we go type specific
+        case type
+        when :boolean
+          return { column => false } if ['false', 'f', '0'].include?(value)
+          return { column => true } if ['true', 't', '1'].include?(value)
+        when :integer, :belongs_to_association
+          return if value.blank?
+          { column => value.to_i } if value.to_i.to_s == value
+        when :string, :text
+          return if value.blank?
+          value = case operator
+          when 'default', 'like'
+            Regexp.compile(Regexp.escape(value))
+          when 'starts_with'
+            Regexp.compile("^#{Regexp.escape(value)}")
+          when 'ends_with'
+            Regexp.compile("#{Regexp.escape(value)}$")
+          when 'is', '='
+            value.to_s
+          else
+            return
+          end
+          { column => value }
+        when :datetime, :timestamp, :date
+          start_date, end_date = get_filtering_duration(operator, value)
+
+          if start_date && end_date
+            { column => { '$gte' => start_date, '$lte' => end_date } }
+          elsif start_date
+            { column => { '$gte' => start_date } }
+          elsif end_date
+            { column => { '$lte' => end_date } }
+          end
+        when :enum
+          return if value.blank?
+          { column => { "$in" => Array.wrap(value) } }
+        end
+      end
+
+      def association_model_proc_lookup(association)
+        if association.polymorphic? && association.macro == :referenced_in
+          RailsAdmin::AbstractModel.polymorphic_parents(:mongoid, association.name) || []
+        else
+          association.klass
+        end
+      end
+
+      def association_foreign_type_lookup(association)
+        if association.polymorphic? && association.macro == :referenced_in
+          association.inverse_type.try(:to_sym) || :"#{association.name}_type"
+        end
+      end
+
+      def association_as_lookup(association)
+        association.as.try :to_sym
+      end
+
+      def association_polymorphic_lookup(association)
+        !!association.polymorphic? && association.macro == :referenced_in
+      end
+
+      def association_primary_key_lookup(association)
+        :_id # todo
+      end
+
+      def association_inverse_of_lookup(association)
+        association.inverse_of.try :to_sym
+      end
+
+      def association_foreign_key_lookup(association)
+        association.foreign_key.to_sym rescue nil
+      end
+      
+      def association_type_lookup(macro)
+        case macro.to_sym
+        when :referenced_in, :embedded_in
+          :belongs_to
+        when :references_one, :embeds_one
+          :has_one
+        when :references_many, :embeds_many
+          :has_many
+        when :references_and_referenced_in_many
+          :has_and_belongs_to_many
+        else
+          raise "Unknown association type: #{macro.inspect}"
+        end
+      end
+
+      def length_validation_lookup(name)
+        shortest = model.validators.select do |validator|
+          validator.attributes.include?(name.to_sym) &&
+            validator.class == ActiveModel::Validations::LengthValidator
+        end.min{|a, b| a.options[:maximum] <=> b.options[:maximum] }
+        if shortest
+          shortest.options[:maximum]
+        else
+          false
+        end
+      end
+
+      def make_condition_for_current_collection(target_field, conditions_per_collection)
+        result =[]
+        conditions_per_collection.each do |collection_name, conditions|
+          if collection_name == table_name
+            # conditions referring current model column are passed directly
+            result.concat conditions
+          else
+            # otherwise, collect ids of documents that satisfy search condition
+            result.concat perform_search_on_associated_collection(target_field.name, conditions)
+          end
+        end
+        result
+      end
+
+      def perform_search_on_associated_collection(field_name, conditions)
+        target_association = associations.find{|a| a[:name] == field_name }
+        return [] unless target_association
+        model = target_association[:model_proc].call
+        case target_association[:type]
+        when :belongs_to, :has_and_belongs_to_many
+          [{ target_association[:foreign_key].to_s => { '$in' => model.where('$or' => conditions).all.map{|r| r.send(target_association[:primary_key_proc].call)} }}]
+        when :has_many
+          [{ target_association[:primary_key_proc].call.to_s => { '$in' => model.where('$or' => conditions).all.map{|r| r.send(target_association[:foreign_key])} }}]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'rails_admin/adapters/active_record/abstract_object'
+module RailsAdmin
+  module Adapters
+    module Mongoid
+      class AbstractObject < RailsAdmin::Adapters::ActiveRecord::AbstractObject
+        def initialize(object)
+          super
+          object.associations.each do |name, association|
+            if association.macro == :references_many
+              instance_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{name.to_s.singularize}_ids
+                  #{name}.map{|item| item.id }
+                end
+
+                def #{name.to_s.singularize}_ids=(items)
+                  self.#{name} = items.
+                    map{|item_id| self.#{name}.klass.find(item_id) rescue nil }.
+                    compact
+                end
+RUBY
+            end
+          end
+        end
+
+        def destroy
+          object.destroy
+          object
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/adapters/mongoid/extension.rb

@@ -0,0 +1,27 @@
+module RailsAdmin
+  module Adapters
+    module Mongoid
+      module Extension
+        extend ActiveSupport::Concern
+
+        included do
+          def self.rails_admin(&block)
+            RailsAdmin::Config.model(self, &block)
+          end
+        end
+
+        def rails_admin_default_object_label_method
+          self.new_record? ? "new #{self.class.to_s}" : "#{self.class.to_s} ##{self.id}"
+        end
+
+        def safe_send(value)
+          if self.attributes.find{ |k,v| k.to_s == value.to_s }
+            self.read_attribute(value)
+          else
+            self.send(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/config.rb

@@ -0,0 +1,322 @@
+require 'rails_admin/config/model'
+require 'rails_admin/config/sections/list'
+require 'active_support/core_ext/class/attribute_accessors'
+
+module RailsAdmin
+  module Config
+    # RailsAdmin is setup to try and authenticate with warden
+    # If warden is found, then it will try to authenticate
+    #
+    # This is valid for custom warden setups, and also devise
+    # If you're using the admin setup for devise, you should set RailsAdmin to use the admin
+    #
+    # @see RailsAdmin::Config.authenticate_with
+    # @see RailsAdmin::Config.authorize_with
+    DEFAULT_AUTHENTICATION = Proc.new do
+      request.env['warden'].try(:authenticate!)
+    end
+
+    DEFAULT_ATTR_ACCESSIBLE_ROLE = Proc.new { :default }
+
+    DEFAULT_AUTHORIZE = Proc.new {}
+
+    DEFAULT_AUDIT = Proc.new {}
+
+    DEFAULT_CURRENT_USER = Proc.new do
+      request.env["warden"].try(:user) || respond_to?(:current_user) && current_user
+    end
+
+
+    class << self
+      # Application title, can be an array of two elements
+      attr_accessor :main_app_name
+
+      # Configuration option to specify which models you want to exclude.
+      attr_accessor :excluded_models
+
+      # Configuration option to specify a whitelist of models you want to RailsAdmin to work with.
+      # The excluded_models list applies against the whitelist as well and further reduces the models
+      # RailsAdmin will use.
+      # If included_models is left empty ([]), then RailsAdmin will automatically use all the models
+      # in your application (less any excluded_models you may have specified).
+      attr_accessor :included_models
+
+      # Fields to be hidden in show, create and update views
+      attr_accessor :default_hidden_fields
+
+      # Default items per page value used if a model level option has not
+      # been configured
+      attr_accessor :default_items_per_page
+
+      attr_reader :default_search_operator
+
+      # Configuration option to specify which method names will be searched for
+      # to be used as a label for object records. This defaults to [:name, :title]
+      attr_accessor :label_methods
+
+      # hide blank fields in show view if true
+      attr_accessor :compact_show_view
+
+      # Set the max width of columns in list view before a new set is created
+      attr_accessor :total_columns_width
+
+      # Stores model configuration objects in a hash identified by model's class
+      # name.
+      #
+      # @see RailsAdmin::Config.model
+      attr_reader :registry
+
+      # Setup authentication to be run as a before filter
+      # This is run inside the controller instance so you can setup any authentication you need to
+      #
+      # By default, the authentication will run via warden if available
+      # and will run the default.
+      #
+      # If you use devise, this will authenticate the same as _authenticate_user!_
+      #
+      # @example Devise admin
+      #   RailsAdmin.config do |config|
+      #     config.authenticate_with do
+      #       authenticate_admin!
+      #     end
+      #   end
+      #
+      # @example Custom Warden
+      #   RailsAdmin.config do |config|
+      #     config.authenticate_with do
+      #       warden.authenticate! :scope => :paranoid
+      #     end
+      #   end
+      #
+      # @see RailsAdmin::Config::DEFAULT_AUTHENTICATION
+      def authenticate_with(&blk)
+        @authenticate = blk if blk
+        @authenticate || DEFAULT_AUTHENTICATION
+      end
+
+
+      def attr_accessible_role(&blk)
+        @attr_accessible_role = blk if blk
+        @attr_accessible_role || DEFAULT_ATTR_ACCESSIBLE_ROLE
+      end
+
+      # Setup auditing/history/versioning provider that observe objects lifecycle
+      def audit_with(*args, &block)
+        extension = args.shift
+        if(extension)
+          @audit = Proc.new {
+            @auditing_adapter = RailsAdmin::AUDITING_ADAPTERS[extension].new(*([self] + args).compact)
+          }
+        else
+          @audit = block if block
+        end
+        @audit || DEFAULT_AUDIT
+      end
+
+      # Setup authorization to be run as a before filter
+      # This is run inside the controller instance so you can setup any authorization you need to.
+      #
+      # By default, there is no authorization.
+      #
+      # @example Custom
+      #   RailsAdmin.config do |config|
+      #     config.authorize_with do
+      #       redirect_to root_path unless warden.user.is_admin?
+      #     end
+      #   end
+      #
+      # To use an authorization adapter, pass the name of the adapter. For example,
+      # to use with CanCan[https://github.com/ryanb/cancan], pass it like this.
+      #
+      # @example CanCan
+      #   RailsAdmin.config do |config|
+      #     config.authorize_with :cancan
+      #   end
+      #
+      # See the wiki[https://github.com/sferik/rails_admin/wiki] for more on authorization.
+      #
+      # @see RailsAdmin::Config::DEFAULT_AUTHORIZE
+      def authorize_with(*args, &block)
+        extension = args.shift
+        if(extension)
+          @authorize = Proc.new {
+            @authorization_adapter = RailsAdmin::AUTHORIZATION_ADAPTERS[extension].new(*([self] + args).compact)
+          }
+        else
+          @authorize = block if block
+        end
+        @authorize || DEFAULT_AUTHORIZE
+      end
+
+      # Setup configuration using an extension-provided ConfigurationAdapter
+      #
+      # @example Custom configuration for role-based setup.
+      #   RailsAdmin.config do |config|
+      #     config.configure_with(:custom) do |config|
+      #       config.models = ['User', 'Comment']
+      #       config.roles  = {
+      #         'Admin' => :all,
+      #         'User'  => ['User']
+      #       }
+      #     end
+      #   end
+      def configure_with(extension)
+        configuration = RailsAdmin::CONFIGURATION_ADAPTERS[extension].new
+        yield(configuration) if block_given?
+      end
+
+      # Setup a different method to determine the current user or admin logged in.
+      # This is run inside the controller instance and made available as a helper.
+      #
+      # By default, _request.env["warden"].user_ or _current_user_ will be used.
+      #
+      # @example Custom
+      #   RailsAdmin.config do |config|
+      #     config.current_user_method do
+      #       current_admin
+      #     end
+      #   end
+      #
+      # @see RailsAdmin::Config::DEFAULT_CURRENT_USER
+      def current_user_method(&block)
+        @current_user = block if block
+        @current_user || DEFAULT_CURRENT_USER
+      end
+
+      def default_search_operator=(operator)
+        if %w{ default like starts_with ends_with is = }.include? operator
+          @default_search_operator = operator
+        else
+          raise ArgumentError, "Search operator '#{operator}' not supported"
+        end
+      end
+
+      # pool of all found model names from the whole application
+      def models_pool
+        possible =
+          included_models.map(&:to_s).presence || (
+          @@system_models ||= # memoization for tests
+            ([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|
+                    # app/models/module/class.rb => module/class.rb => module/class => Module::Class
+                    lchomp(filename, "#{app.root.join(load_dir)}/").chomp('.rb').camelize
+                  end
+                end
+              end
+            end.flatten
+          )
+
+        excluded = (excluded_models.map(&:to_s) + ['RailsAdmin::History'])
+
+        (possible - excluded).uniq.sort
+      end
+
+      # Loads a model configuration instance from the registry or registers
+      # a new one if one is yet to be added.
+      #
+      # First argument can be an instance of requested model, its class object,
+      # its class name as a string or symbol or a RailsAdmin::AbstractModel
+      # instance.
+      #
+      # If a block is given it is evaluated in the context of configuration instance.
+      #
+      # Returns given model's configuration
+      #
+      # @see RailsAdmin::Config.registry
+      def model(entity, &block)
+        key = begin
+          if entity.kind_of?(RailsAdmin::AbstractModel)
+            entity.model.try(:name).try :to_sym
+          elsif entity.kind_of?(Class)
+            entity.name.to_sym
+          elsif entity.kind_of?(String) || entity.kind_of?(Symbol)
+            entity.to_sym
+          else
+            entity.class.name.to_sym
+          end
+        end
+        config = @registry[key] ||= RailsAdmin::Config::Model.new(entity)
+        config.instance_eval(&block) if block
+        config
+      end
+
+      def default_hidden_fields=(fields)
+        if fields.is_a?(Array)
+          @default_hidden_fields = {}
+          @default_hidden_fields[:edit] = fields
+          @default_hidden_fields[:show] = fields
+        else
+          @default_hidden_fields = fields
+        end
+      end
+
+      # Returns action configuration object
+      def actions(&block)
+        RailsAdmin::Config::Actions.instance_eval(&block) if block
+      end
+
+      # Returns all model configurations
+      #
+      # If a block is given it is evaluated in the context of configuration
+      # instances.
+      #
+      # @see RailsAdmin::Config.registry
+      def models(&block)
+        RailsAdmin::AbstractModel.all.map{|m| model(m, &block)}
+      end
+
+      # Reset all configurations to defaults.
+      #
+      # @see RailsAdmin::Config.registry
+      def reset
+        @compact_show_view = true
+        @authenticate = nil
+        @authorize = nil
+        @audit = nil
+        @current_user = nil
+        @default_hidden_fields = {}
+        @default_hidden_fields[:edit] = [:id, :created_at, :created_on, :deleted_at, :updated_at, :updated_on, :deleted_on]
+        @default_hidden_fields[:show] = [:id, :created_at, :created_on, :deleted_at, :updated_at, :updated_on, :deleted_on]
+        @default_items_per_page = 20
+        @default_search_operator = 'default'
+        @attr_accessible_role = nil
+        @excluded_models = []
+        @included_models = []
+        @total_columns_width = 697
+        @label_methods = [:name, :title]
+        @main_app_name = Proc.new { [Rails.application.engine_name.titleize.chomp(' Application'), 'Admin'] }
+        @registry = {}
+        RailsAdmin::Config::Actions.reset
+      end
+
+      # Reset a provided model's configuration.
+      #
+      # @see RailsAdmin::Config.registry
+      def reset_model(model)
+        key = model.kind_of?(Class) ? model.name.to_sym : model.to_sym
+        @registry.delete(key)
+      end
+
+      # Get all models that are configured as visible sorted by their weight and label.
+      #
+      # @see RailsAdmin::Config::Hideable
+
+      def visible_models(bindings)
+        models.map{|m| m.with(bindings) }.select{|m| m.visible? && bindings[:controller].authorized?(:index, m.abstract_model)}.sort do |a, b|
+          (weight_order = a.weight <=> b.weight) == 0 ? a.label.downcase <=> b.label.downcase : weight_order
+        end
+      end
+
+      private
+
+      def lchomp(base, arg)
+        base.to_s.reverse.chomp(arg.to_s.reverse).reverse
+      end
+    end
+
+    # Set default values for configuration options on load
+    self.reset
+  end
+end