upstream-rails_admin 1.0.2

data/lib/rails_admin/config/proxyable.rb

@@ -0,0 +1,12 @@
+require 'rails_admin/config/proxyable/proxy'
+module RailsAdmin
+  module Config
+    module Proxyable
+      attr_accessor :bindings
+
+      def with(bindings = {})
+        RailsAdmin::Config::Proxyable::Proxy.new(self, bindings)
+      end
+    end
+  end
+end

data/lib/rails_admin/config/proxyable/proxy.rb

@@ -0,0 +1,43 @@
+module RailsAdmin
+  module Config
+    module Proxyable
+
+      class Proxy
+
+        instance_methods.each {|m| undef_method m unless m =~ /^(__|instance_eval|object_id)/ }
+
+        attr_reader :bindings
+
+        def initialize(object, bindings = {})
+          @object = object
+          @bindings = bindings
+        end
+
+        # Bind variables to be used by the configuration options
+        def bind(key, value = nil)
+          if key.kind_of?(Hash)
+            @bindings = key
+          else
+            @bindings[key] = value
+          end
+          self
+        end
+
+        def method_missing(name, *args, &block)
+          if @object.respond_to?(name)
+            reset = @object.instance_variable_get("@bindings")
+            begin
+              @object.instance_variable_set("@bindings", @bindings)
+              response = @object.__send__(name, *args, &block)
+            ensure
+              @object.instance_variable_set("@bindings", @reset)
+            end
+            response
+          else
+            super(name, *args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/config/sections.rb

@@ -0,0 +1,39 @@
+require 'active_support/core_ext/string/inflections'
+require 'rails_admin/config/sections/base'
+require 'rails_admin/config/sections/edit'
+require 'rails_admin/config/sections/update'
+require 'rails_admin/config/sections/create'
+require 'rails_admin/config/sections/nested'
+require 'rails_admin/config/sections/modal'
+require 'rails_admin/config/sections/list'
+require 'rails_admin/config/sections/export'
+require 'rails_admin/config/sections/show'
+
+
+module RailsAdmin
+  module Config
+    # Sections describe different views in the RailsAdmin engine. Configurable sections are
+    # list and navigation.
+    #
+    # Each section's class object can store generic configuration about that section (such as the
+    # number of visible tabs in the main navigation), while the instances (accessed via model
+    # configuration objects) store model specific configuration (such as the visibility of the
+    # model).
+    module Sections
+      def self.included(klass)
+        # Register accessors for all the sections in this namespace
+        constants.each do |name|
+          section = "RailsAdmin::Config::Sections::#{name}".constantize
+          name = name.to_s.underscore.to_sym
+          klass.send(:define_method, name) do |&block|
+            @sections = {} unless @sections
+            @sections[name] = section.new(self) unless @sections[name]
+            @sections[name].instance_eval &block if block
+            @sections[name]
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/rails_admin/config/sections/base.rb

@@ -0,0 +1,29 @@
+require 'rails_admin/config/proxyable'
+require 'rails_admin/config/configurable'
+require 'rails_admin/config/has_fields'
+require 'rails_admin/config/has_groups'
+
+module RailsAdmin
+  module Config
+    module Sections
+      # Configuration of the show view for a new object
+      class Base
+        include RailsAdmin::Config::Proxyable
+        include RailsAdmin::Config::Configurable
+
+        include RailsAdmin::Config::HasFields
+        include RailsAdmin::Config::HasGroups
+
+        attr_reader :abstract_model
+        attr_reader :parent, :root
+
+        def initialize(parent)
+          @parent = parent
+          @root = parent.root
+
+          @abstract_model = root.abstract_model
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/config/sections/create.rb

@@ -0,0 +1,11 @@
+require 'rails_admin/config/sections/edit'
+
+module RailsAdmin
+  module Config
+    module Sections
+      # Configuration of the edit view for a new object
+      class Create < RailsAdmin::Config::Sections::Edit
+      end
+    end
+  end
+end

data/lib/rails_admin/config/sections/edit.rb

@@ -0,0 +1,11 @@
+require 'rails_admin/config/sections/base'
+
+module RailsAdmin
+  module Config
+    module Sections
+      # Configuration of the edit view for an existing object
+      class Edit < RailsAdmin::Config::Sections::Base
+      end
+    end
+  end
+end

data/lib/rails_admin/config/sections/export.rb

@@ -0,0 +1,11 @@
+require 'rails_admin/config/sections/base'
+
+module RailsAdmin
+  module Config
+    module Sections
+      # Configuration of the navigation view
+      class Export < RailsAdmin::Config::Sections::Base
+      end
+    end
+  end
+end

data/lib/rails_admin/config/sections/list.rb

@@ -0,0 +1,27 @@
+require 'rails_admin/config/sections/base'
+
+module RailsAdmin
+  module Config
+    module Sections
+      # Configuration of the list view
+      class List < RailsAdmin::Config::Sections::Base
+        register_instance_option :filters do
+          []
+        end
+
+        # Number of items listed per page
+        register_instance_option :items_per_page do
+          RailsAdmin::Config.default_items_per_page
+        end
+
+        register_instance_option :sort_by do
+          parent.abstract_model.primary_key
+        end
+
+        register_instance_option :sort_reverse? do
+          true # By default show latest first
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin/config/sections/modal.rb

@@ -0,0 +1,10 @@
+require 'rails_admin/config/sections/edit'
+
+module RailsAdmin
+  module Config
+    module Sections
+      class Modal < RailsAdmin::Config::Sections::Edit
+      end
+    end
+  end
+end

data/lib/rails_admin/config/sections/nested.rb

@@ -0,0 +1,10 @@
+require 'rails_admin/config/sections/edit'
+
+module RailsAdmin
+  module Config
+    module Sections
+      class Nested < RailsAdmin::Config::Sections::Edit
+      end
+    end
+  end
+end

data/lib/rails_admin/config/sections/show.rb

@@ -0,0 +1,10 @@
+require 'rails_admin/config/sections/base'
+
+module RailsAdmin
+  module Config
+    module Sections
+      class Show < RailsAdmin::Config::Sections::Base
+      end
+    end
+  end
+end

data/lib/rails_admin/config/sections/update.rb

@@ -0,0 +1,10 @@
+require 'rails_admin/config/sections/edit'
+
+module RailsAdmin
+  module Config
+    module Sections
+      class Update < RailsAdmin::Config::Sections::Edit
+      end
+    end
+  end
+end

data/lib/rails_admin/engine.rb

@@ -0,0 +1,22 @@
+require 'rails'
+require 'jquery-rails'
+require 'remotipart'
+require 'bootstrap-sass'
+require 'kaminari'
+require 'rack-pjax'
+require 'jquery-ui-rails'
+require 'nested_form'
+require 'rails_admin'
+
+module RailsAdmin
+  class Engine < Rails::Engine
+    isolate_namespace RailsAdmin
+    initializer "RailsAdmin precompile hook" do |app|
+      app.config.assets.precompile += ['rails_admin/rails_admin.js', 'rails_admin/rails_admin.css', 'rails_admin/jquery.colorpicker.js', 'rails_admin/jquery.colorpicker.css']
+    end
+
+    initializer "RailsAdmin pjax hook" do |app|
+      app.config.middleware.use Rack::Pjax
+    end
+  end
+end

data/lib/rails_admin/extension.rb

@@ -0,0 +1,29 @@
+
+module RailsAdmin
+  EXTENSIONS = []
+  AUTHORIZATION_ADAPTERS = {}
+  AUDITING_ADAPTERS = {}
+  CONFIGURATION_ADAPTERS = {}
+
+  # Extend RailsAdmin
+  #
+  # The extension may define various adapters (e.g., for authorization) and
+  # register those via the options hash.
+  def self.add_extension(extension_key, extension_definition, options = {})
+    options.assert_valid_keys(:authorization, :configuration, :auditing)
+
+    EXTENSIONS << extension_key
+
+    if(authorization = options[:authorization])
+      AUTHORIZATION_ADAPTERS[extension_key] = extension_definition::AuthorizationAdapter
+    end
+
+    if(configuration = options[:configuration])
+      CONFIGURATION_ADAPTERS[extension_key] = extension_definition::ConfigurationAdapter
+    end
+
+    if(configuration = options[:auditing])
+      AUDITING_ADAPTERS[extension_key] = extension_definition::AuditingAdapter
+    end
+  end
+end

data/lib/rails_admin/extensions/cancan.rb

@@ -0,0 +1,5 @@
+require 'rails_admin/extensions/cancan/authorization_adapter'
+
+RailsAdmin.add_extension(:cancan, RailsAdmin::Extensions::CanCan, {
+  :authorization => true
+})

data/lib/rails_admin/extensions/cancan/authorization_adapter.rb

@@ -0,0 +1,59 @@
+module RailsAdmin
+  module Extensions
+    module CanCan
+      # This adapter is for the CanCan[https://github.com/ryanb/cancan] authorization library.
+      # You can create another adapter for different authorization behavior, just be certain it
+      # responds to each of the public methods here.
+      class AuthorizationAdapter
+        # See the +authorize_with+ config method for where the initialization happens.
+        def initialize(controller, ability = ::Ability)
+          @controller = controller
+          @controller.instance_variable_set '@ability', ability
+          @controller.extend ControllerExtension
+          @controller.current_ability.authorize! :access, :rails_admin
+        end
+
+        # This method is called in every controller action and should raise an exception
+        # when the authorization fails. The first argument is the name of the controller
+        # action as a symbol (:create, :bulk_delete, etc.). The second argument is the
+        # AbstractModel instance that applies. The third argument is the actual model
+        # instance if it is available.
+        def authorize(action, abstract_model = nil, model_object = nil)
+          @controller.current_ability.authorize!(action, model_object || abstract_model && abstract_model.model) if action
+        end
+
+        # This method is called primarily from the view to determine whether the given user
+        # has access to perform the action on a given model. It should return true when authorized.
+        # This takes the same arguments as +authorize+. The difference is that this will
+        # return a boolean whereas +authorize+ will raise an exception when not authorized.
+        def authorized?(action, abstract_model = nil, model_object = nil)
+          @controller.current_ability.can?(action, model_object || abstract_model && abstract_model.model) if action
+        end
+
+        # This is called when needing to scope a database query. It is called within the list
+        # and bulk_delete/destroy actions and should return a scope which limits the records
+        # to those which the user can perform the given action on.
+        def query(action, abstract_model)
+          abstract_model.model.accessible_by(@controller.current_ability, action)
+        end
+
+        # This is called in the new/create actions to determine the initial attributes for new
+        # records. It should return a hash of attributes which match what the user
+        # is authorized to create.
+        def attributes_for(action, abstract_model)
+          @controller.current_ability.attributes_for(action, abstract_model && abstract_model.model)
+        end
+
+        private
+
+        module ControllerExtension
+          def current_ability
+            # use _current_user instead of default current_user so it works with
+            # whatever current user method is defined with RailsAdmin
+            @current_ability ||= @ability.new(_current_user)
+          end
+        end
+      end
+    end
+  end
+end

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,70 @@
+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]
+
+  attr_accessible :message, :item, :table, :username
+
+  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