drewda_rails_admin 0.0.1

data/lib/rails_admin/extensions/history.rb

@@ -0,0 +1,5 @@
+require 'rails_admin/extensions/history/auditing_adapter'
+
+RailsAdmin.add_extension(:history, RailsAdmin::Extensions::History, {
+  :auditing => true
+})

data/lib/rails_admin/extensions/history/auditing_adapter.rb

@@ -0,0 +1,37 @@
+module RailsAdmin
+  module Extensions
+    module History
+      class AuditingAdapter
+        def initialize(controller, user_class = User)
+          @controller = controller
+          @user_class = user_class
+          require 'rails_admin/extensions/history/history'
+        end
+
+        def latest
+          ::RailsAdmin::History.latest
+        end
+
+        def delete_object(message, object, model, user)
+          ::RailsAdmin::History.create_history_item(message, object, model, user)
+        end
+
+        def update_object(model, object, associations_before, associations_after, modified_associations, old_object, user)
+          ::RailsAdmin::History.create_update_history(model, object, associations_before, associations_after, modified_associations, old_object, user)
+        end
+
+        def create_object(message, object, abstract_model, user)
+          ::RailsAdmin::History.create_history_item(message, object, abstract_model, user)
+        end
+
+        def listing_for_model(model, query, sort, sort_reverse, all, page, per_page = (RailsAdmin::Config.default_items_per_page || 20))
+          ::RailsAdmin::History.history_for_model(model, query, sort, sort_reverse, all, page, per_page)
+        end
+
+        def listing_for_object(model, object, query, sort, sort_reverse, all, page, per_page = (RailsAdmin::Config.default_items_per_page || 20))
+          ::RailsAdmin::History.history_for_object(model, object, query, sort, sort_reverse, all, page, per_page)
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/extensions/history/history.rb

@@ -0,0 +1,69 @@
+class RailsAdmin::History < ActiveRecord::Base
+
+  self.table_name = :rails_admin_histories
+
+  IGNORED_ATTRS = Set[:id, :created_at, :created_on, :deleted_at, :updated_at, :updated_on, :deleted_on]
+
+  def self.latest
+    self.limit(100)
+  end
+
+  def self.create_update_history(model, object, associations_before, associations_after, modified_associations, old_object, user)
+    messages = []
+    changed_property_list = []
+    properties = model.properties.reject{|p| IGNORED_ATTRS.include?(p[:name])}
+
+    properties.each do |p|
+      property_name = p[:name].to_param
+      changed_property_list << property_name if old_object.safe_send(property_name) != object.safe_send(property_name)
+    end
+
+    model.associations.each do |t|
+      assoc = changed_property_list.index(t[:foreign_key].to_param)
+      changed_property_list[assoc] = "associated #{t[:pretty_name]}" if assoc
+    end
+
+    associations_after.each do |key, current|
+      removed_ids = (associations_before[key] - current).map{|m| '#' + m.to_s}
+      added_ids = (current - associations_before[key]).map{|m| '#' + m.to_s}
+      messages << "Removed #{key.to_s.capitalize} #{removed_ids.join(', ')} associations" if removed_ids.any?
+      messages << "Added #{key.to_s.capitalize} #{added_ids.join(', ')} associations" if added_ids.any?
+    end
+
+    modified_associations.uniq.each { |t| changed_property_list << "associated #{t}" }
+
+    messages << "Changed #{changed_property_list.join(", ")}" unless changed_property_list.empty?
+    create_history_item(messages, object, model, user) unless messages.empty?
+  end
+
+  def self.create_history_item(message, object, abstract_model, user)
+    create(
+       :message => [message].flatten.join(', '),
+       :item => object.id,
+       :table => abstract_model.pretty_name,
+       :username => user.try(:email)
+     )
+  end
+
+  def self.history_for_model(model, query, sort, sort_reverse, all, page, per_page = (RailsAdmin::Config.default_items_per_page || 20))
+    history = where(:table => model.pretty_name)
+    history = history.where("message LIKE ? OR username LIKE ?", "%#{query}%", "%#{query}%") if query
+    if sort
+      history = history.order(sort_reverse == "true" ? "#{sort} DESC" : sort)
+    else
+      history = history.order('created_at DESC')
+    end
+    all ? history : history.page(page.presence || "1").per(per_page)
+  end
+
+  def self.history_for_object(model, object, query, sort, sort_reverse, all, page, per_page = (RailsAdmin::Config.default_items_per_page || 20))
+    history = where(:table => model.pretty_name, :item => object.id)
+    history = history.where("message LIKE ? OR username LIKE ?", "%#{query}%", "%#{query}%") if query
+    if sort
+      history = history.order(sort_reverse == "true" ? "#{sort} DESC" : sort)
+    else
+      history = history.order('created_at DESC')
+    end
+    all ? history : history.page(page.presence || "1").per(per_page)
+  end
+end

data/lib/rails_admin/extensions/paper_trail.rb

@@ -0,0 +1,5 @@
+require 'rails_admin/extensions/paper_trail/auditing_adapter'
+
+RailsAdmin.add_extension(:paper_trail, RailsAdmin::Extensions::PaperTrail, {
+  :auditing => true
+})

data/lib/rails_admin/extensions/paper_trail/auditing_adapter.rb

@@ -0,0 +1,92 @@
+module RailsAdmin
+  module Extensions
+    module PaperTrail
+      class VersionProxy
+        def initialize(version, user_class = User)
+          @version = version
+          @user_class = user_class
+        end
+
+        def message
+          "#{@version.event} #{@version.item_type} id #{@version.item_id}"
+        end
+
+        def created_at
+          @version.created_at
+        end
+
+        def table
+          @version.item_type
+        end
+
+        def username
+          @user_class.find_by_id(@version.whodunnit).try(:email) || @version.whodunnit
+        end
+
+        def item
+          @version.item_id
+        end
+      end
+
+      class AuditingAdapter
+        COLUMN_MAPPING = {
+          :table => :item_type,
+          :username => :whodunnit,
+          :item => :item_id,
+          :created_at => :created_at,
+          :message => :event
+        }
+
+        def initialize(controller, user_class = User)
+          raise "PaperTrail not found" unless defined?(PaperTrail)
+          @controller = controller
+          @user_class = user_class
+        end
+
+        def latest
+          Version.limit(100).map{|version| VersionProxy.new(version, @user_class)}
+        end
+
+        def delete_object(message, object, model, user)
+          # do nothing
+        end
+
+        def update_object(model, object, associations_before, associations_after, modified_associations, old_object, user)
+          # do nothing
+        end
+
+        def create_object(message, object, abstract_model, user)
+          # do nothing
+        end
+
+        def listing_for_model(model, query, sort, sort_reverse, all, page, per_page = (RailsAdmin::Config.default_items_per_page || 20))
+          if sort.present?
+            sort = COLUMN_MAPPING[sort.to_sym]
+          else
+            sort = :created_at
+            sort_reverse = "true"
+          end
+          versions = Version.where :item_type => model.model.name
+          versions = versions.where("event LIKE ?", "%#{query}%") if query.present?
+          versions = versions.order(sort_reverse == "true" ? "#{sort} DESC" : sort)
+          versions = all ? versions : versions.page(page.presence || "1").per(per_page)
+          versions.map{|version| VersionProxy.new(version, @user_class)}
+        end
+
+        def listing_for_object(model, object, query, sort, sort_reverse, all, page, per_page = (RailsAdmin::Config.default_items_per_page || 20))
+          if sort.present?
+            sort = COLUMN_MAPPING[sort.to_sym]
+          else
+            sort = :created_at
+            sort_reverse = "true"
+          end
+          versions = Version.where :item_type => model.model.name, :item_id => object.id
+          versions = versions.where("event LIKE ?", "%#{query}%") if query.present?
+          versions = versions.order(sort_reverse == "true" ? "#{sort} DESC" : sort)
+          versions = all ? versions : versions.page(page.presence || "1").per(per_page)
+          versions.map{|version| VersionProxy.new(version, @user_class)}
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/i18n_support.rb

@@ -0,0 +1,43 @@
+require 'i18n'
+
+module RailsAdmin
+  module I18nSupport
+    def abbr_day_names
+      begin
+        I18n.t('date.abbr_day_names', :raise => true)
+      rescue I18n::ArgumentError
+        I18n.t('date.abbr_day_names', :locale => :en)
+      end
+    end
+
+    def abbr_month_names
+      begin
+        names = I18n.t('date.abbr_month_names', :raise => true)
+      rescue I18n::ArgumentError
+        names = I18n.t('date.abbr_month_names', :locale => :en)
+      end
+      names[1..-1]
+    end
+
+    def date_format
+      I18n.t('date.formats.default', :default => I18n.t('date.formats.default', :locale => :en))
+    end
+
+    def day_names
+      begin
+        I18n.t('date.day_names', :raise => true)
+      rescue I18n::ArgumentError
+        I18n.t('date.day_names', :locale => :en)
+      end
+    end
+
+    def month_names
+      begin
+        names = I18n.t('date.month_names', :raise => true)
+      rescue I18n::ArgumentError
+        names = I18n.t('date.month_names', :locale => :en)
+      end
+      names[1..-1]
+    end
+  end
+end

data/lib/rails_admin/support/core_extensions.rb

@@ -0,0 +1,44 @@
+class Hash
+
+  def symbolize
+    Hash.symbolize_hash(self)
+  end
+
+  def self.symbolize_hash(obj)
+    case obj
+    when Array
+      obj.inject([]){|res, val|
+        res << case val
+        when Hash, Array
+          symbolize_hash(val)
+        when String
+          val.to_sym
+        else
+          val
+        end
+        res
+      }
+    when Hash
+      obj.inject({}){|res, (key, val)|
+        nkey = case key
+        when String
+          key.to_sym
+        else
+          key
+        end
+        nval = case val
+        when Hash, Array
+          symbolize_hash(val)
+        when String
+          val.to_sym
+        else
+          val
+        end
+        res[nkey] = nval
+        res
+      }
+    else
+      obj
+    end
+  end
+end

data/lib/rails_admin/support/csv_converter.rb

@@ -0,0 +1,109 @@
+# encoding: UTF-8
+require RUBY_VERSION < '1.9' ? 'fastercsv' : 'csv'
+
+module RailsAdmin
+
+  CSVClass = RUBY_VERSION < '1.9' ? ::FasterCSV : ::CSV
+  NON_ASCII_ENCODINGS = /(UTF\-16)|(UTF\-32)|(ISO\-2022\-JP)|(Big5\-HKSCS)|(UTF\-7)/
+
+  class CSVConverter
+
+    def initialize(objects = [], schema = {})
+      return self if (@objects = objects).blank?
+
+      @model = objects.first.class
+      @abstract_model = RailsAdmin::AbstractModel.new(@model)
+      @model_config = @abstract_model.config
+      @methods = [(schema[:only] || []) + (schema[:methods] || [])].flatten.compact
+      @fields = @model_config.export.fields.select{|f| @methods.include? f.name }
+      @empty = ::I18n.t('admin.export.empty_value_for_associated_objects')
+      @associations = {}
+
+      (schema.delete(:include) || {}).each do |key, values|
+        association = @model_config.export.fields.find{|f| f.name == key && f.association?}
+        model_config = association.associated_model_config
+        abstract_model = model_config.abstract_model
+        model = abstract_model.model
+        methods = [(values[:only] || []) + (values[:methods] || [])].flatten.compact
+        fields = model_config.export.fields.select{|f| methods.include? f.name }
+
+        @associations[key] = {
+          :association => association,
+          :model => model,
+          :abstract_model => abstract_model,
+          :model_config => model_config,
+          :fields => fields
+        }
+      end
+    end
+
+    def to_csv(options)
+      options ||= {}
+      return '' if @objects.blank?
+
+      # encoding shenanigans first
+      @encoding_from = if [nil, '', 'utf8', 'utf-8', 'UTF8', 'UTF-8'].include?(encoding = Rails.configuration.database_configuration[Rails.env]['encoding'])
+        'UTF-8'
+      else
+        encoding
+      end
+
+      unless options[:encoding_to].blank?
+        @encoding_to = options[:encoding_to]
+        unless @encoding_to == @encoding_from
+          require 'iconv'
+          @iconv = (Iconv.new("#{@encoding_to}//TRANSLIT//IGNORE", @encoding_from) rescue (Rails.logger.error("Iconv cannot convert to #{@encoding_to}: #{$!}\nNo conversion will take place"); nil))
+        end
+      else
+        @encoding_to = @encoding_from
+      end
+
+      csv_string = CSVClass.generate(options[:generator] ? options[:generator].symbolize_keys.delete_if {|key, value| value.blank? } : {}) do |csv|
+        unless options[:skip_header]
+          csv << @fields.map do |field|
+            output(::I18n.t('admin.export.csv.header_for_root_methods', :name => field.label, :model => @abstract_model.pretty_name))
+          end +
+          @associations.map do |association_name, option_hash|
+            option_hash[:fields].map do |field|
+              output(::I18n.t('admin.export.csv.header_for_association_methods', :name => field.label, :association => option_hash[:association].label))
+            end
+          end.flatten
+        end
+        @objects.each do |o|
+
+
+          csv << @fields.map do |field|
+            output(field.with(:object => o).export_value)
+          end +
+          @associations.map do |association_name, option_hash|
+
+            associated_objects = [o.send(association_name)].flatten.compact
+            option_hash[:fields].map do |field|
+              output(associated_objects.map{ |ao| field.with(:object => ao).export_value.presence || @empty }.join(','))
+            end
+          end.flatten
+        end
+      end
+
+      # Add a BOM for utf8 encodings, helps with utf8 auto-detect for some versions of Excel.
+      # Don't add if utf8 but user don't want to touch input encoding:
+      # If user chooses utf8, he will open it in utf8 and BOM will disappear at reading.
+      # But that way "English" users who don't bother and chooses to let utf8 by default won't get BOM added
+      # and will not see it if Excel opens the file with a different encoding.
+      csv_string = "\xEF\xBB\xBF#{csv_string.respond_to?(:force_encoding) ? csv_string.force_encoding('UTF-8') : csv_string}" if options[:encoding_to] == 'UTF-8'
+      csv_string = ((@iconv ? @iconv.iconv(csv_string) : csv_string) rescue str) if @encoding_to =~ NON_ASCII_ENCODINGS # global conversion for non ASCII encodings
+      [!options[:skip_header], @encoding_to, csv_string]
+    end
+
+    private
+
+    def output(str)
+      unless @encoding_to =~ NON_ASCII_ENCODINGS  # can't use the csv generator with encodings that are no supersets of ASCII-7
+        (@iconv ? @iconv.iconv(str.to_s) : str.to_s) rescue str.to_s   # convert piece by piece
+      else
+        str.to_s
+      end
+    end
+  end
+end
+

data/lib/rails_admin/version.rb

@@ -0,0 +1,6 @@
+module RailsAdmin
+  # FIXME: this needs to be manually kept in sync with the gemspec's
+  # s.version until http://jira.codehaus.org/browse/JRUBY-5319 is
+  # fixed
+  VERSION = "0.0.1"
+end

data/lib/tasks/prepare_ci_env.rake

@@ -0,0 +1,27 @@
+namespace :rails_admin do
+  desc "Prepare Continuous Integration environment"
+  task :prepare_ci_env do
+    ENV['SKIP_RAILS_ADMIN_INITIALIZER'] = 'true'
+    adapter = ENV["CI_DB_ADAPTER"] || "sqlite3"
+    database = ENV["CI_DB_DATABASE"] || ("sqlite3" == adapter ? "db/development.sqlite3" : "ci_rails_admin")
+
+    configuration = {
+      "test" => {
+        "adapter" => adapter,
+        "database" => database,
+        "username" => ENV["CI_DB_USERNAME"],
+        "password" => ENV["CI_DB_PASSWORD"],
+        "host" => ENV["CI_DB_HOST"] || "localhost",
+        "encoding" => ENV["CI_DB_ENCODING"] || "utf8",
+        "pool" => (ENV["CI_DB_POOL"] || 5).to_int,
+        "timeout" => (ENV["CI_DB_TIMEOUT"] || 5000).to_int
+      }
+    }
+
+    filename = Rails.root.join("config/database.yml")
+
+    File.open(filename, "w") do |f|
+      f.write(configuration.to_yaml)
+    end
+  end
+end