upstream-rails_admin 1.0.2

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

@@ -0,0 +1,18 @@
+class DropRailsAdminHistoriesTable < ActiveRecord::Migration
+   def self.up
+    drop_table :rails_admin_histories
+  end
+
+  def self.down
+    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
+end

data/lib/generators/rails_admin/templates/initializer.erb

@@ -0,0 +1,101 @@
+# RailsAdmin config file. Generated on <%= DateTime.now.to_s(:long) %>
+# See github.com/sferik/rails_admin for more informations
+
+RailsAdmin.config do |config|
+
+  # If your default_local is different from :en, uncomment the following 2 lines and set your default locale here:
+  # require 'i18n'
+  # I18n.default_locale = :de
+
+  config.current_user_method { current_<%= @model_name.underscore %> } # auto-generated
+
+  # If you want to track changes on your models:
+  # config.audit_with :history, <%= @model_name.classify %>
+
+  # Or with a PaperTrail: (you need to install it first)
+  # config.audit_with :paper_trail, <%= @model_name.classify %>
+
+  # Set the admin name here (optional second array element will appear in a beautiful RailsAdmin red ©)
+  config.main_app_name = ['<%= Rails.application.engine_name.titleize.chomp(' Application') %>', 'Admin']
+  # or for a dynamic name:
+  # config.main_app_name = Proc.new { |controller| [Rails.application.engine_name.titleize, controller.params['action'].titleize] }
+
+
+  #  ==> Global show view settings
+  # Display empty fields in show views
+  # config.compact_show_view = false
+
+  #  ==> Global list view settings
+  # Number of default rows per-page:
+  # config.default_items_per_page = 20
+
+  #  ==> Included models
+  # Add all excluded models here:
+  # config.excluded_models = [<%= RailsAdmin::AbstractModel.all.map{|am| am.model.to_s }.join(', ') %>]
+
+  # Add models here if you want to go 'whitelist mode':
+  # config.included_models = [<%= RailsAdmin::AbstractModel.all.map{|am| am.model.to_s }.join(', ') %>]
+
+  # Application wide tried label methods for models' instances
+  # config.label_methods << :description # Default is [:name, :title]
+
+  #  ==> Global models configuration
+  # config.models do
+  #   # Configuration here will affect all included models in all scopes, handle with care!
+  #
+  #   list do
+  #     # Configuration here will affect all included models in list sections (same for show, export, edit, update, create)
+  #
+  #     fields_of_type :date do
+  #       # Configuration here will affect all date fields, in the list section, for all included models. See README for a comprehensive type list.
+  #     end
+  #   end
+  # end
+  #
+  #  ==> Model specific configuration
+  # Keep in mind that *all* configuration blocks are optional.
+  # RailsAdmin will try his best to provide the best defaults for each section, for each field.
+  # Try to override as few things as possible, in the most generic way. Try to avoid setting labels for models and attributes, use ActiveRecord I18n API instead.
+  # Less code is better code!
+  # config.model MyModel do
+  #   # Cross-section field configuration
+  #   object_label_method :name     # Name of the method called for pretty printing an *instance* of ModelName
+  #   label 'My model'              # Name of ModelName (smartly defaults to ActiveRecord's I18n API)
+  #   label_plural 'My models'      # Same, plural
+  #   weight -1                     # Navigation priority. Bigger is higher.
+  #   parent OtherModel             # Set parent model for navigation. MyModel will be nested below. OtherModel will be on first position of the dropdown
+  #   navigation_label              # Sets dropdown entry's name in navigation. Only for parents!
+  #   # Section specific configuration:
+  #   list do
+  #     filters [:id, :name]  # Array of field names which filters should be shown by default in the table header
+  #     items_per_page 100    # Override default_items_per_page
+  #     sort_by :id           # Sort column (default is primary key)
+  #     sort_reverse true     # Sort direction (default is true for primary key, last created first)
+  #     # Here goes the fields configuration for the list view
+  #   end
+  # end
+
+  # Your model's configuration, to help you get started:
+
+  # All fields marked as 'hidden' won't be shown anywhere in the rails_admin unless you mark them as visible. (visible(true))
+
+<% RailsAdmin::AbstractModel.all.map do |abstract_model| -%>
+  # config.model <%= abstract_model.model.model_name %> do
+  #   # Found associations:
+<%= abstract_model.config.export.fields.select{|f| f.association?}.map do |field|
+%{  #     configure #{field.name.inspect}, #{field.type.inspect}#{"         # Hidden" unless field.visible?} }
+end.join("\n") -%>
+  #   # Found columns:
+<%= abstract_model.config.export.fields.select{|f| !f.association?}.map do |field|
+%{  #     configure #{field.name.inspect}, #{field.type.inspect}#{"         # Hidden" unless field.visible?} }
+end.join("\n") -%>
+  #   # Sections:
+  #   list do; end
+  #   export do; end
+  #   show do; end
+  #   edit do; end
+  #   create do; end
+  #   update do; end
+  # end
+<%- end -%>
+end

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,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,108 @@
+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
+
+    def where(conditions)
+      model.where(conditions)
+    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? ? (Date.strptime(value[1], date_format) rescue false) : false
+        end_date   = value[2].present? ? (Date.strptime(value[2], date_format) rescue false) : false
+      when 'today'
+        start_date = end_date = Date.today
+      when 'yesterday'
+        start_date = end_date = Date.yesterday
+      when 'this_week'
+        start_date = Date.today.beginning_of_week
+        end_date   = Date.today.end_of_week
+      when 'last_week'
+        start_date = 1.week.ago.to_date.beginning_of_week
+        end_date   = 1.week.ago.to_date.end_of_week
+      else # default
+        start_date = (Date.strptime(Array.wrap(value).first, date_format) rescue false)
+        end_date   = (Date.strptime(Array.wrap(value).first, date_format) rescue false)
+      end
+      [start_date, end_date]
+    end
+  end
+end

data/lib/rails_admin/adapters/active_record.rb

@@ -0,0 +1,255 @@
+require 'active_record'
+require 'rails_admin/adapters/active_record/abstract_object'
+
+module RailsAdmin
+  module Adapters
+    module ActiveRecord
+      DISABLED_COLUMN_TYPES = [:tsvector, :blob, :binary, :spatial, :hstore]
+      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
+
+      def encoding
+        Rails.configuration.database_configuration[Rails.env]['encoding']
+      end
+
+      def embedded?
+        false
+      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 :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 :datetime, :timestamp
+          start_date, end_date = get_filtering_duration(operator, value)
+
+          if start_date && end_date
+            ["(#{column} BETWEEN ? AND ?)", start_date.to_time.beginning_of_day, end_date.to_time.end_of_day]
+          elsif start_date
+            ["(#{column} >= ?)", start_date.to_time.beginning_of_day]
+          elsif end_date
+            ["(#{column} <= ?)", end_date.to_time.end_of_day]
+          end
+        when :enum
+          return if value.blank?
+          ["(#{column} IN (?))", Array.wrap(value)]
+        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