drewda_rails_admin 0.0.1

data/lib/generators/rails_admin/uninstall_generator.rb

@@ -0,0 +1,22 @@
+require 'rails/generators'
+require File.expand_path('../utils', __FILE__)
+
+module RailsAdmin
+  class UninstallGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+    include Generators::Utils::InstanceMethods
+    extend Generators::Utils::ClassMethods
+    source_root File.expand_path('../templates', __FILE__)
+
+    desc "RailsAdmin uninstall"
+
+    def uninstall
+      display "Why you leaving so soon? :("
+      migration_template 'drop.rb', 'db/migrate/drop_rails_admin_histories_table.rb'
+      remove_file 'config/initializers/rails_admin.rb'
+      remove_file 'config/initializers/rails_admin.rb.example'
+      gsub_file "config/routes.rb", /mount RailsAdmin::Engine => \'\/.+\', :as => \'rails_admin\'/, ''
+      display "Done! Devise has been left untouched."
+    end
+  end
+end

data/lib/generators/rails_admin/utils.rb

@@ -0,0 +1,30 @@
+module RailsAdmin
+  module Generators
+    module Utils
+      module InstanceMethods
+        def display(output, color = :green)
+          say("           -  #{output}", color)
+        end
+
+        def ask_for(wording, default_value = nil, override_if_present_value = nil)
+          override_if_present_value.present? ?
+            display("Using [#{override_if_present_value}] for question '#{wording}'") && override_if_present_value :
+            ask("           ?  #{wording} Press <enter> for [#{default_value}] >", :yellow).presence || default_value
+        end
+      end
+
+      module ClassMethods
+        def next_migration_number(dirname)
+          if ActiveRecord::Base.timestamped_migrations
+            migration_number = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+            migration_number += 1
+            migration_number.to_s
+          else
+            "%.3d" % (current_migration_number(dirname) + 1)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/rails_admin.rb

@@ -0,0 +1,34 @@
+require 'rails_admin/engine'
+require 'rails_admin/abstract_model'
+require 'rails_admin/config'
+require 'rails_admin/extension'
+require 'rails_admin/extensions/cancan'
+require 'rails_admin/extensions/paper_trail'
+require 'rails_admin/extensions/history'
+require 'rails_admin/support/csv_converter'
+require 'rails_admin/support/core_extensions'
+
+module RailsAdmin
+  # Setup RailsAdmin
+  #
+  # Given the first argument is a model class, a model class name
+  # or an abstract model object proxies to model configuration method.
+  #
+  # If only a block is passed it is stored to initializer stack to be evaluated
+  # on first request in production mode and on each request in development. If
+  # initialization has already occured (in other words RailsAdmin.setup has
+  # been called) the block will be added to stack and evaluated at once.
+  #
+  # Otherwise returns RailsAdmin::Config class.
+  #
+  # @see RailsAdmin::Config
+  def self.config(entity = nil, &block)
+    if entity
+      RailsAdmin::Config.model(entity, &block)
+    elsif block_given? && ENV['SKIP_RAILS_ADMIN_INITIALIZER'] != "true"
+      block.call(RailsAdmin::Config)
+    else
+      RailsAdmin::Config
+    end
+  end
+end

data/lib/rails_admin/abstract_model.rb

@@ -0,0 +1,110 @@
+module RailsAdmin
+  class AbstractModel
+    cattr_accessor :all
+    attr_reader :adapter, :model_name
+
+    class << self
+      def reset
+        @@all = nil
+      end
+
+      def all(adapter = nil)
+        @@all ||= Config.models_pool.map{ |m| new(m) }.compact
+        adapter ? @@all.select{|m| m.adapter == adapter} : @@all
+      end
+
+      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
+
+      @@polymorphic_parents = {}
+
+      def polymorphic_parents(adapter, name)
+        @@polymorphic_parents[adapter.to_sym] ||= {}.tap do |hash|
+          all(adapter).each do |am|
+            am.associations.select{|r| r[:as] }.each do |association|
+              (hash[association[:as].to_sym] ||= []) << am.model
+            end
+          end
+        end
+        @@polymorphic_parents[adapter.to_sym][name.to_sym]
+      end
+
+      # For testing
+      def reset_polymorphic_parents
+        @@polymorphic_parents = {}
+      end
+    end
+
+    def initialize(m)
+      @model_name = m.to_s
+      if m.ancestors.map(&:to_s).include?('ActiveRecord::Base') && !m.abstract_class?
+        # ActiveRecord
+        @adapter = :active_record
+        require 'rails_admin/adapters/active_record'
+        extend Adapters::ActiveRecord
+      elsif m.ancestors.map(&:to_s).include?('Mongoid::Document')
+        # Mongoid
+        @adapter = :mongoid
+        require 'rails_admin/adapters/mongoid'
+        extend Adapters::Mongoid
+      end
+    end
+
+    # do not store a reference to the model, does not play well with ActiveReload/Rails3.2
+    def model
+      @model_name.try :constantize
+    end
+
+    def config
+      Config.model self
+    end
+
+    def to_param
+      model.to_s.split("::").map(&:underscore).join("~")
+    end
+
+    def param_key
+      model.to_s.split("::").map(&:underscore).join("_")
+    end
+
+    def pretty_name
+      model.model_name.human
+    end
+
+    private
+
+    def get_filtering_duration(operator, value)
+      date_format = I18n.t("admin.misc.filter_date_format", :default => I18n.t("admin.misc.filter_date_format", :locale => :en)).gsub('dd', '%d').gsub('mm', '%m').gsub('yy', '%Y')
+      case operator
+      when 'between'
+        start_date = value[1].present? ? (beginning_of_date(Date.strptime(value[1], date_format)) rescue false) : false
+        end_date   = value[2].present? ? (Date.strptime(value[2], date_format).end_of_day rescue false) : false
+      when 'today'
+        start_date = beginning_of_date(Date.today)
+        end_date   = Date.today.end_of_day
+      when 'yesterday'
+        start_date = beginning_of_date(Date.yesterday)
+        end_date   = Date.yesterday.end_of_day
+      when 'this_week'
+        start_date = beginning_of_date(Date.today.beginning_of_week)
+        end_date   = Date.today.end_of_week.end_of_day
+      when 'last_week'
+        start_date = beginning_of_date(1.week.ago.to_date.beginning_of_week)
+        end_date   = 1.week.ago.to_date.end_of_week.end_of_day
+      else # default
+        start_date = (beginning_of_date(Date.strptime(Array.wrap(value).first, date_format)) rescue false)
+        end_date   = (Date.strptime(Array.wrap(value).first, date_format).end_of_day rescue false)
+      end
+      [start_date, end_date]
+    end
+
+    def beginning_of_date(date)
+      date.beginning_of_day
+    end
+  end
+end

data/lib/rails_admin/adapters/active_record.rb

@@ -0,0 +1,247 @@
+require 'active_record'
+require 'rails_admin/adapters/active_record/abstract_object'
+
+module RailsAdmin
+  module Adapters
+    module ActiveRecord
+      DISABLED_COLUMN_TYPES = [:tsvector, :blob, :binary, :spatial]
+      AR_ADAPTER = ::ActiveRecord::Base.configurations[Rails.env]['adapter']
+      LIKE_OPERATOR = AR_ADAPTER == "postgresql" ? 'ILIKE' : 'LIKE'
+
+      def new(params = {})
+        AbstractObject.new(model.new(params))
+      end
+
+      def get(id)
+        if object = model.where(model.primary_key => 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.where(model.primary_key => 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 = scope.reorder("#{options[:sort]} #{options[:sort_reverse] ? 'asc' : 'desc'}") if options[:sort]
+        scope
+      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
+        model.primary_key
+      end
+
+      def associations
+        model.reflect_on_all_associations.map do |association|
+          {
+            :name => association.name.to_sym,
+            :pretty_name => association.name.to_s.tr('_', ' ').capitalize,
+            :type => association.macro,
+            :model_proc => Proc.new { association_model_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 => association_read_only_lookup(association),
+            :nested_form => association_nested_attributes_options_lookup(association)
+          }
+        end
+      end
+
+      def properties
+        columns = model.columns.reject {|c| c.type.blank? || DISABLED_COLUMN_TYPES.include?(c.type.to_sym) }
+        columns.map do |property|
+          {
+            :name => property.name.to_sym,
+            :pretty_name => property.name.to_s.tr('_', ' ').capitalize,
+            :type => property.type,
+            :length => property.limit,
+            :nullable? => property.null,
+            :serial? => property.primary,
+          }
+        end
+      end
+
+      def table_name
+        model.table_name
+      end
+
+      def serialized_attributes
+        model.serialized_attributes.keys
+      end
+
+      private
+
+      def query_conditions(query, fields = config.list.fields.select(&:queryable?))
+        statements = []
+        values = []
+
+        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
+
+        [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 = []
+
+        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
+
+        [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'
+
+        # filtering data with unary operator, not type dependent
+        if operator == '_blank' || value == '_blank'
+          return ["(#{column} IS NULL OR #{column} = '')"]
+        elsif operator == '_present' || value == '_present'
+          return ["(#{column} IS NOT NULL AND #{column} != '')"]
+        elsif operator == '_null' || value == '_null'
+          return ["(#{column} IS NULL)"]
+        elsif operator == '_not_null' || value == '_not_null'
+          return ["(#{column} IS NOT NULL)"]
+        elsif operator == '_empty' || value == '_empty'
+          return ["(#{column} = '')"]
+        elsif operator == '_not_empty' || value == '_not_empty'
+          return ["(#{column} != '')"]
+        end
+
+        # now we go type specific
+        case type
+        when :boolean
+          return ["(#{column} IS NULL OR #{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'
+            "%#{value}%"
+          when 'starts_with'
+            "#{value}%"
+          when 'ends_with'
+            "%#{value}"
+          when 'is', '='
+            "#{value}"
+          else
+            return
+          end
+          ["(#{column} #{LIKE_OPERATOR} ?)", value]
+        when :datetime, :timestamp, :date
+          start_date, end_date = get_filtering_duration(operator, value)
+          
+          if start_date && end_date
+            ["(#{column} BETWEEN ? AND ?)", start_date, end_date]
+          elsif start_date
+            ["(#{column} >= ?)", start_date]
+          elsif end_date
+            ["(#{column} <= ?)", end_date]
+          end
+        when :enum
+          return if value.blank?
+          ["(#{column} IN (?))", Array.wrap(value)]
+        end
+      end
+
+      if AR_ADAPTER == "postgresql"
+        def beginning_of_date(date)
+          date.beginning_of_day
+        end
+      else
+        def beginning_of_date(date)
+          date.yesterday.end_of_day
+        end
+      end
+
+      def association_model_lookup(association)
+        if association.options[:polymorphic]
+          RailsAdmin::AbstractModel.polymorphic_parents(:active_record, association.name) || []
+        else
+          association.klass
+        end
+      end
+
+      def association_foreign_type_lookup(association)
+        if association.options[:polymorphic]
+          association.options[:foreign_type].try(:to_sym) || :"#{association.name}_type"
+        end
+      end
+
+      def association_nested_attributes_options_lookup(association)
+        model.nested_attributes_options.try { |o| o[association.name.to_sym] }
+      end
+
+      def association_as_lookup(association)
+        association.options[:as].try :to_sym
+      end
+
+      def association_polymorphic_lookup(association)
+        !!association.options[:polymorphic]
+      end
+
+      def association_primary_key_lookup(association)
+        association.options[:primary_key] || association.klass.primary_key
+      end
+
+      def association_inverse_of_lookup(association)
+        association.options[:inverse_of].try :to_sym
+      end
+
+      def association_read_only_lookup(association)
+        association.options[:readonly]
+      end
+
+      def association_foreign_key_lookup(association)
+        association.foreign_key.to_sym
+      end
+    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