elucid-rails_admin 0.0.1

data/lib/generators/rails_admin/templates/migration.rb

@@ -0,0 +1,18 @@
+class CreateRailsAdminHistoriesTable < ActiveRecord::Migration
+   def self.up
+     create_table :rails_admin_histories do |t|
+       t.text :message # title, name, or object_id
+       t.string :username
+       t.integer :item
+       t.string :table
+       t.integer :month, :limit => 2
+       t.integer :year, :limit => 5
+       t.timestamps
+    end
+    add_index(:rails_admin_histories, [:item, :table, :month, :year], :name => 'index_rails_admin_histories' )
+  end
+
+  def self.down
+    drop_table :rails_admin_histories
+  end
+end

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,57 @@
+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/support/csv_converter'
+require 'rails_admin/support/core_extensions'
+
+module RailsAdmin
+  def self.authenticate_with(&block)
+    ActiveSupport::Deprecation.warn("'#{self.name}.authenticate_with { }' is deprecated, use 'RailsAdmin.config{|c| c.authenticate_with }' instead", caller)
+    self.config {|c| c.authenticate_with(&block) }
+  end
+
+  def self.authorize_with(*args, &block)
+    ActiveSupport::Deprecation.warn("'#{self.name}.authorize_with { }' is deprecated, use 'RailsAdmin.config{|c| c.authorize_with }' instead", caller)
+    self.config {|c| c.authorize_with(*args, &block) }
+  end
+
+  def self.current_user_method(&block)
+    ActiveSupport::Deprecation.warn("'#{self.name}.current_user_method { }' is deprecated, use 'RailsAdmin.config{|c| c.current_user_method }' instead", caller)
+    self.config {|c| c.current_user_method(&block) }
+  end
+
+  def self.configure_with(extension, &block)
+    ActiveSupport::Deprecation.warn("'#{self.name}.configure_with { }' is deprecated, use 'RailsAdmin.config{|c| c.configure_with }' instead", caller)
+    self.config {|c| c.configure_with(extension, &block) }
+  end
+
+  # 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
+
+  # Reset RailsAdmin configuration to defaults
+  def self.reset
+    RailsAdmin::Config.reset
+  end
+end

data/lib/rails_admin/abstract_model.rb

@@ -0,0 +1,73 @@
+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
+
+    # self.all_abstract_models
+    def self.all
+      @@all_abstract_models ||= all_models.map{ |model| new(model) }
+    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
+
+    # 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
+        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)
+    end
+
+    def model
+      @model_name.constantize
+    end
+
+    private
+
+    def self.superclasses(klass)
+      superclasses = []
+      while klass
+        superclasses << klass.superclass if klass && klass.superclass
+        klass = klass.superclass
+      end
+      superclasses
+    end
+
+    def self.lchomp(base, arg) # yeah.. delete was probably safe, but never know.
+      base.to_s.reverse.chomp(arg.to_s.reverse).reverse
+    end
+  end
+end

data/lib/rails_admin/abstract_object.rb

@@ -0,0 +1,28 @@
+ module RailsAdmin
+  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 method_missing(name, *args, &block)
+      self.object.send(name, *args, &block)
+    end
+
+    def save(options = { :validate => true })
+      object.save(options)
+    end
+  end
+end

data/lib/rails_admin/adapters/active_record.rb

@@ -0,0 +1,359 @@
+require 'active_record'
+require 'rails_admin/config/sections/list'
+require 'rails_admin/abstract_object'
+
+module RailsAdmin
+  module Adapters
+    module ActiveRecord
+      DISABLED_COLUMN_TYPES = [:tsvector]
+      @@polymorphic_parents = nil
+      def self.extended(abstract_model)
+
+        # ActiveRecord does not handle has_one relationships the way it does for has_many,
+        # and does not create any association_id and association_id= methods.
+        # Added here for backward compatibility after a refactoring, but it does belong to ActiveRecord IMO.
+        # Support is hackish at best. Atomicity is respected for creation, but not while updating.
+        # It means a failed validation at update on the parent object could still modify target belongs_to foreign ids.
+        #
+        #
+        abstract_model.model.reflect_on_all_associations.select{|assoc| assoc.macro.to_s == 'has_one'}.each do |association|
+          abstract_model.model.send(:define_method, "#{association.name}_id") do
+            self.send(association.name).try(:id)
+          end
+          abstract_model.model.send(:define_method, "#{association.name}_id=") do |id|
+            self.send(association.name.to_s + '=', associated = (id.blank? ? nil : association.klass.find_by_id(id)))
+          end
+        end
+      end
+
+      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]
+      end
+            
+      def get(id)
+        if object = model.where(model.primary_key => id).first
+          RailsAdmin::AbstractObject.new object
+        else
+          nil
+        end
+      end
+
+      def count(options = {}, scope = nil)
+        all(options.merge({:limit => false, :page => false}), scope).count
+      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(options[:conditions]) if options[:conditions]
+        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))
+      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
+      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,
+            :parent_model => association_parent_model_lookup(association),
+            :parent_key => association_parent_key_lookup(association),
+            :child_model => association_child_model_lookup(association),
+            :child_key => association_child_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)
+          }
+        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| 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 model_store_exists?
+        model.table_exists?
+      end
+      
+      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 = []
+        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
+          end
+        end
+
+        unless query_statements.empty?
+          conditions[0] += " AND " unless conditions == [""]
+          conditions[0] += "(#{query_statements.join(" OR ")})"  # any column field will do
+        end
+
+        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|
+                unless filter_dump[:disabled]
+                  statement, value1, value2 = build_statement(field_infos[:column], field_infos[:type], filter_dump[:value], (filter_dump[:operator] || 'default'))
+                  if statement
+                    field_statements << statement
+                    values << value1 unless value1.nil?
+                    values << value2 unless value2.nil?
+                  end
+                end
+              end
+              filters_statements << "(#{field_statements.join(' OR ')})" unless field_statements.empty?
+            end
+          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 } : {}
+      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}"
+          end
+          ["(#{column} #{@like_operator} ?)", value]
+        when :datetime, :timestamp, :date
+          return unless operator != 'default'
+          values = case operator
+          when 'today'
+            [Date.today.beginning_of_day, Date.today.end_of_day]
+          when 'yesterday'
+            [Date.yesterday.beginning_of_day, Date.yesterday.end_of_day]
+          when 'this_week'
+            [Date.today.beginning_of_week.beginning_of_day, Date.today.end_of_week.end_of_day]
+          when 'last_week'
+            [1.week.ago.to_date.beginning_of_week.beginning_of_day, 1.week.ago.to_date.end_of_week.end_of_day]
+          when 'less_than'
+            return if value.blank?
+            [value.to_i.days.ago, DateTime.now]
+          when 'more_than'
+            return if value.blank?
+            [2000.years.ago, value.to_i.days.ago]
+          end
+          ["(#{column} BETWEEN ? AND ?)", *values]
+        when :enum
+          return if value.blank?
+          ["(#{column} IN (?))", [value].flatten]
+        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
+          {}
+        end
+      end
+
+      def association_parent_model_lookup(association)
+        case association.macro
+        when :belongs_to
+          if association.options[:polymorphic]
+            RailsAdmin::Adapters::ActiveRecord.polymorphic_parents(association.name) || []
+          else
+            association.klass
+          end
+        when :has_one, :has_many, :has_and_belongs_to_many
+          association.active_record
+        else
+          raise "Unknown association type: #{association.macro.inspect}"
+        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_as_lookup(association)
+        association.options[:as].try :to_sym
+      end
+
+      def association_polymorphic_lookup(association)
+        association.options[:polymorphic]
+      end
+
+      def association_parent_key_lookup(association)
+        [:id]
+      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_child_model_lookup(association)
+        case association.macro
+        when :belongs_to
+          association.active_record
+        when :has_one, :has_many, :has_and_belongs_to_many
+          association.klass
+        else
+          raise "Unknown association type: #{association.macro.inspect}"
+        end
+      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
+      end
+    end
+  end
+end