activeadmin-rails 1.7.0

data/lib/active_admin/cancan_adapter.rb

@@ -0,0 +1,36 @@
+unless ActiveAdmin::Dependency.cancan? || ActiveAdmin::Dependency.cancancan?
+  ActiveAdmin::Dependency.cancan!
+end
+
+require 'cancan'
+
+# Add a setting to the application to configure the ability
+ActiveAdmin::Application.inheritable_setting :cancan_ability_class, "Ability"
+
+module ActiveAdmin
+
+  class CanCanAdapter < AuthorizationAdapter
+
+    def authorized?(action, subject = nil)
+      cancan_ability.can?(action, subject)
+    end
+
+    def cancan_ability
+      @cancan_ability ||= initialize_cancan_ability
+    end
+
+    def scope_collection(collection, action = ActiveAdmin::Auth::READ)
+      collection.accessible_by(cancan_ability, action)
+    end
+
+    private
+
+    def initialize_cancan_ability
+      klass = resource.namespace.cancan_ability_class
+      klass = klass.constantize if klass.is_a? String
+      klass.new user
+    end
+
+  end
+
+end

data/lib/active_admin/component.rb

@@ -0,0 +1,5 @@
+module ActiveAdmin
+  class Component < Arbo::Component
+
+  end
+end

data/lib/active_admin/controller_action.rb

@@ -0,0 +1,12 @@
+module ActiveAdmin
+  class ControllerAction
+    attr_reader :name
+    def initialize(name, options = {})
+      @name, @options = name, options
+    end
+
+    def http_verb
+      @options[:method] ||= :get
+    end
+  end
+end

data/lib/active_admin/csv_builder.rb

@@ -0,0 +1,136 @@
+module ActiveAdmin
+  # CSVBuilder stores CSV configuration
+  #
+  # Usage example:
+  #
+  #   csv_builder = CSVBuilder.new
+  #   csv_builder.column :id
+  #   csv_builder.column("Name") { |resource| resource.full_name }
+  #   csv_builder.column(:name, humanize_name: false)
+  #   csv_builder.column("name", humanize_name: false) { |resource| resource.full_name }
+  #
+  #   csv_builder = CSVBuilder.new col_sep: ";"
+  #   csv_builder = CSVBuilder.new humanize_name: false
+  #   csv_builder.column :id
+  #
+  #
+  class CSVBuilder
+
+    # Return a default CSVBuilder for a resource
+    # The CSVBuilder's columns would be Id followed by this
+    # resource's content columns
+    def self.default_for_resource(resource)
+      new resource: resource do
+        column :id
+        resource.content_columns.each { |c| column c }
+      end
+    end
+
+    attr_reader :columns, :options, :view_context
+
+    COLUMN_TRANSITIVE_OPTIONS = [:humanize_name].freeze
+
+    def initialize(options = {}, &block)
+      @resource = options.delete(:resource)
+      @columns = []
+      @options = ActiveAdmin.application.csv_options.merge options
+      @block = block
+    end
+
+    def column(name, options = {}, &block)
+      @columns << Column.new(name, @resource, column_transitive_options.merge(options), block)
+    end
+
+    def build(controller, csv)
+      @collection  = controller.send :find_collection, except: :pagination
+      columns      = exec_columns controller.view_context
+      bom          = options.delete :byte_order_mark
+      column_names = options.delete(:column_names) { true }
+      csv_options  = options.except :encoding_options, :humanize_name
+
+      csv << bom if bom
+
+      if column_names
+        csv << CSV.generate_line(columns.map { |c| encode c.name, options }, **csv_options)
+      end
+
+      ActiveRecord::Base.uncached do
+        (1..paginated_collection.total_pages).each do |page|
+          paginated_collection(page).each do |resource|
+            resource = controller.send :apply_decorator, resource
+            csv << CSV.generate_line(build_row(resource, columns, options), **csv_options)
+          end
+        end
+      end
+
+      csv
+    end
+
+    def exec_columns(view_context = nil)
+      @view_context = view_context
+      @columns = [] # we want to re-render these every instance
+      instance_exec &@block if @block.present?
+      columns
+    end
+
+    def build_row(resource, columns, options)
+      columns.map do |column|
+        encode call_method_or_proc_on(resource, column.data), options
+      end
+    end
+
+    def encode(content, options)
+      if options[:encoding]
+        if options[:encoding_options]
+          content.to_s.encode options[:encoding], **options[:encoding_options]
+        else
+          content.to_s.encode options[:encoding]
+        end
+      else
+        content
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      if @view_context.respond_to? method
+        @view_context.public_send method, *args, &block
+      else
+        super
+      end
+    end
+
+    class Column
+      attr_reader :name, :data, :options
+
+      DEFAULT_OPTIONS = { humanize_name: true }
+
+      def initialize(name, resource = nil, options = {}, block = nil)
+        @options = options.reverse_merge(DEFAULT_OPTIONS)
+        @name = humanize_name(name, resource, @options[:humanize_name])
+        @data = block || name.to_sym
+      end
+
+      def humanize_name(name, resource, humanize_name_option)
+        if humanize_name_option
+          name.is_a?(Symbol) && resource ? resource.resource_class.human_attribute_name(name) : name.to_s.humanize
+        else
+          name.to_s
+        end
+      end
+    end
+
+    private
+
+    def column_transitive_options
+      @column_transitive_options ||= @options.slice(*COLUMN_TRANSITIVE_OPTIONS)
+    end
+
+    def paginated_collection(page_no = 1)
+      @collection.public_send(Kaminari.config.page_method_name, page_no).per(batch_size)
+    end
+
+    def batch_size
+      1000
+    end
+  end
+end

data/lib/active_admin/dependency.rb

@@ -0,0 +1,96 @@
+module ActiveAdmin
+  module Dependency
+    module Requirements
+      DEVISE = '>= 3.2', '< 5'
+    end
+
+    # Provides a clean interface to check for gem dependencies at runtime.
+    #
+    # ActiveAdmin::Dependency.draper
+    # => #<ActiveAdmin::Dependency::Matcher for draper 1.2.1>
+    #
+    # ActiveAdmin::Dependency.draper?
+    # => true
+    #
+    # ActiveAdmin::Dependency.draper? '>= 1.5.0'
+    # => false
+    #
+    # ActiveAdmin::Dependency.draper? '= 1.2.1'
+    # => true
+    #
+    # ActiveAdmin::Dependency.draper? '~> 1.2.0'
+    # => true
+    #
+    # ActiveAdmin::Dependency.rails? '>= 4.2.7', '<= 5.0.2'
+    # => true
+    #
+    # ActiveAdmin::Dependency.rails! '5'
+    # -> ActiveAdmin::DependencyError: You provided rails 4.2.7 but we need: 5.
+    #
+    # ActiveAdmin::Dependency.devise!
+    # -> ActiveAdmin::DependencyError: To use devise you need to specify it in your Gemfile.
+    #
+    #
+    # All but the pessimistic operator (~>) can also be run using Ruby's comparison syntax.
+    #
+    # ActiveAdmin::Dependency.rails >= '4.2.7'
+    # => true
+    #
+    # Which is especially useful if you're looking up a gem with dashes in the name.
+    #
+    # ActiveAdmin::Dependency['jquery-rails'] < 5
+    # => false
+    #
+    def self.method_missing(name, *args)
+      if name[-1] == '?'
+        Matcher.new(name[0..-2]).match? args
+      elsif name[-1] == '!'
+        Matcher.new(name[0..-2]).match! args
+      else
+        Matcher.new name.to_s
+      end
+    end
+
+    def self.[](name)
+      Matcher.new name.to_s
+    end
+
+    class Matcher
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def spec
+        @spec ||= Gem.loaded_specs[name]
+      end
+
+      def spec!
+        spec || raise(DependencyError, "To use #{name} you need to specify it in your Gemfile.")
+      end
+
+      def match?(*reqs)
+        !!spec && Gem::Requirement.create(reqs).satisfied_by?(spec.version)
+      end
+
+      def match!(*reqs)
+        unless match? reqs
+          raise DependencyError, "You provided #{spec!.name} #{spec!.version} but we need: #{reqs.join ', '}."
+        end
+      end
+
+      include Comparable
+
+      def <=>(other)
+        spec!.version <=> Gem::Version.create(other)
+      end
+
+      def inspect
+        info = spec ? "#{spec.name} #{spec.version}" : '(missing)'
+        "<ActiveAdmin::Dependency::Matcher for #{info}>"
+      end
+    end
+
+  end
+end

data/lib/active_admin/deprecation.rb

@@ -0,0 +1,10 @@
+module ActiveAdmin
+  module Deprecation
+    module_function
+
+    def warn(message, callstack = caller)
+      ActiveSupport::Deprecation.warn "Active Admin: #{message}", callstack
+    end
+
+  end
+end

data/lib/active_admin/devise.rb

@@ -0,0 +1,80 @@
+ActiveAdmin::Dependency.devise! ActiveAdmin::Dependency::Requirements::DEVISE
+
+require 'devise'
+
+module ActiveAdmin
+  module Devise
+
+    def self.config
+      {
+        path: ActiveAdmin.application.default_namespace || "/",
+        controllers: ActiveAdmin::Devise.controllers,
+        path_names: { sign_in: 'login', sign_out: "logout" },
+        sign_out_via: [*::Devise.sign_out_via, ActiveAdmin.application.logout_link_method].uniq
+      }
+    end
+
+    def self.controllers
+      {
+        sessions: "active_admin/devise/sessions",
+        passwords: "active_admin/devise/passwords",
+        unlocks: "active_admin/devise/unlocks",
+        registrations: "active_admin/devise/registrations",
+        confirmations: "active_admin/devise/confirmations"
+      }
+    end
+
+    module Controller
+      extend ::ActiveSupport::Concern
+      included do
+        layout 'active_admin_logged_out'
+        helper ::ActiveAdmin::ViewHelpers
+      end
+
+      # Redirect to the default namespace on logout
+      def root_path
+        namespace = ActiveAdmin.application.default_namespace.presence
+        root_path_method = [namespace, :root_path].compact.join('_')
+
+        path = if Helpers::Routes.respond_to? root_path_method
+                 Helpers::Routes.send root_path_method
+               else
+                 # Guess a root_path when url_helpers not helpful
+                 "/#{namespace}"
+               end
+
+        # NOTE: `relative_url_root` is deprecated by Rails.
+        #       Remove prefix here if it is removed completely.
+        prefix = Rails.configuration.action_controller[:relative_url_root] || ''
+        prefix + path
+      end
+    end
+
+    class SessionsController < ::Devise::SessionsController
+      include ::ActiveAdmin::Devise::Controller
+    end
+
+    class PasswordsController < ::Devise::PasswordsController
+      include ::ActiveAdmin::Devise::Controller
+    end
+
+    class UnlocksController < ::Devise::UnlocksController
+      include ::ActiveAdmin::Devise::Controller
+    end
+
+    class RegistrationsController < ::Devise::RegistrationsController
+      include ::ActiveAdmin::Devise::Controller
+    end
+
+    class ConfirmationsController < ::Devise::ConfirmationsController
+      include ::ActiveAdmin::Devise::Controller
+    end
+
+    def self.controllers_for_filters
+      [SessionsController, PasswordsController, UnlocksController,
+        RegistrationsController, ConfirmationsController
+      ]
+    end
+
+  end
+end

data/lib/active_admin/dsl.rb

@@ -0,0 +1,193 @@
+module ActiveAdmin
+
+  # The Active Admin DSL. This class is where all the registration blocks
+  # are evaluated. This is the central place for the API given to
+  # users of Active Admin.
+  #
+  class DSL
+
+    def initialize(config)
+      @config = config
+    end
+
+    # Runs the registration block inside this object
+    def run_registration_block(&block)
+      instance_exec &block if block_given?
+    end
+
+    # The instance of ActiveAdmin::Resource that's being registered
+    # currently. You can use this within your registration blocks to
+    # modify options:
+    #
+    # eg:
+    #
+    #   ActiveAdmin.register Post do
+    #     config.sort_order = "id_desc"
+    #   end
+    #
+    def config
+      @config
+    end
+
+    # Include a module with this resource. The modules's `included` method
+    # is called with the instance of the `ActiveAdmin::DSL` passed into it.
+    #
+    # eg:
+    #
+    #   module HelpSidebar
+    #
+    #     def self.included(dsl)
+    #       dsl.sidebar "Help" do
+    #         "Call us for Help"
+    #       end
+    #     end
+    #
+    #   end
+    #
+    #   ActiveAdmin.register Post do
+    #     include HelpSidebar
+    #   end
+    #
+    # @param [Module] mod A module to include
+    #
+    # @return [Nil]
+    def include(mod)
+      mod.included(self)
+    end
+
+    # Returns the controller for this resource. If you pass a
+    # block, it will be evaluated in the controller.
+    #
+    # Example:
+    #
+    #   ActiveAdmin.register Post do
+    #
+    #     controller do
+    #       def some_method_on_controller
+    #         # Method gets added to Admin::PostsController
+    #       end
+    #     end
+    #
+    #   end
+    #
+    def controller(&block)
+      @config.controller.class_exec(&block) if block_given?
+      @config.controller
+    end
+
+    # Add a new action item to the resource
+    #
+    # @param [Symbol] name
+    # @param [Hash] options valid keys include:
+    #                 :only:  A single or array of controller actions to display
+    #                         this action item on.
+    #                 :except: A single or array of controller actions not to
+    #                          display this action item on.
+    def action_item(name = nil, options = {}, &block)
+      if name.is_a?(Hash)
+        options = name
+        name = nil
+      end
+
+      Deprecation.warn "using `action_item` without a name is deprecated! Use `action_item(:edit)`." unless name
+
+      config.add_action_item(name, options, &block)
+    end
+
+    # Add a new batch action item to the resource
+    # Provide a symbol/string to register the action, options, & block to execute on request
+    #
+    # To unregister an existing action, just provide the symbol & pass false as the second param
+    #
+    # @param [Symbol or String] title
+    # @param [Hash] options valid keys include:
+    # => :if is a proc that will be called to determine if the BatchAction should be displayed
+    # => :sort_order is used to sort the batch actions ascending
+    # => :confirm is a string which the user will have to accept in order to process the action
+    #
+    def batch_action(title, options = {}, &block)
+      # Create symbol & title information
+      if title.is_a? String
+        sym = title.titleize.tr(' ', '').underscore.to_sym
+      else
+        sym = title
+        title = sym.to_s.titleize
+      end
+
+      # Either add/remove the batch action
+      unless options == false
+        config.add_batch_action(sym, title, options, &block)
+      else
+        config.remove_batch_action sym
+      end
+    end
+
+    # Set the options that are available for the item that will be placed in the global
+    # navigation of the menu.
+    def menu(options = {})
+      config.menu_item_options = options
+    end
+
+    # Set the name of the navigation menu to display. This is mainly used in conjunction with the
+    # `#belongs_to` functionality.
+    #
+    # @param [Symbol] menu_name The name of the menu to display as the global navigation
+    #                 when viewing this resource. Defaults to a menu named `:default`.
+    #
+    # Pass a block returning the name of a menu you want rendered for the request, being
+    # executed in the context of the controller
+    #
+    def navigation_menu(menu_name = nil, &block)
+      config.navigation_menu_name = menu_name || block
+    end
+
+    # Rewrite breadcrumb links.
+    # Block will be executed inside controller.
+    # Block must return an array if you want to rewrite breadcrumb links.
+    #
+    # Example:
+    #   ActiveAdmin.register Post do
+    #
+    #     breadcrumb do
+    #       [
+    #         link_to('my piece', '/my/link/to/piece')
+    #       ]
+    #     end
+    #   end
+    #
+    def breadcrumb(&block)
+      config.breadcrumb = block
+    end
+
+    def sidebar(name, options = {}, &block)
+      if block_given?
+        config.sidebar_sections << ActiveAdmin::SidebarSection.new(name, options, &block)
+      else
+        config.add_sidebar_section(name, options)
+      end
+    end
+
+    protected
+
+    def set_title_before_action(name, title)
+      controller do
+        before_action(only: [name]) { @page_title = title }
+      end
+    end
+
+    def define_controller_method(name, &block)
+      if block_given?
+        warn "Warning: method `#{name}` already defined in #{controller.name}" if controller.method_defined?(name)
+
+        controller do
+          define_method(name, &block)
+        end
+      elsif !controller.method_defined?(name)
+        controller do
+          define_method(name, Proc.new{})
+        end
+      end
+    end
+
+  end
+end

data/lib/active_admin/dynamic_setting.rb

@@ -0,0 +1,38 @@
+module ActiveAdmin
+
+  class DynamicSetting
+    def self.build(setting, type)
+      (type ? klass(type) : self).new(setting)
+    end
+
+    def self.klass(type)
+      klass = "#{type.to_s.camelcase}Setting"
+      raise ArgumentError, "Unknown type: #{type}" unless ActiveAdmin.const_defined?(klass)
+      ActiveAdmin.const_get(klass)
+    end
+
+    def initialize(setting)
+      @setting = setting
+    end
+
+    def value(*_args)
+      @setting
+    end
+  end
+
+  # Many configuration options (Ex: site_title, title_image) could either be
+  # static (String), methods (Symbol) or procs (Proc). This wrapper takes care of
+  # returning the content when String or using instance_eval when Symbol or Proc.
+  #
+  class StringSymbolOrProcSetting < DynamicSetting
+    def value(context = self)
+      case @setting
+      when Symbol, Proc
+        context.instance_eval(&@setting)
+      else
+        @setting
+      end
+    end
+  end
+
+end

data/lib/active_admin/dynamic_settings_node.rb

@@ -0,0 +1,28 @@
+require 'active_admin/dynamic_setting'
+require 'active_admin/settings_node'
+
+module ActiveAdmin
+
+  class DynamicSettingsNode < SettingsNode
+    class << self
+      def register(name, value, type = nil)
+        class_attribute "#{name}_setting"
+        add_reader(name)
+        add_writer(name, type)
+        send "#{name}=", value
+      end
+
+      def add_reader(name)
+        define_singleton_method(name) do |*args|
+          send("#{name}_setting").value(*args)
+        end
+      end
+
+      def add_writer(name, type)
+        define_singleton_method("#{name}=") do |value|
+          send("#{name}_setting=", DynamicSetting.build(value, type))
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/engine.rb

@@ -0,0 +1,22 @@
+module ActiveAdmin
+  class Engine < ::Rails::Engine
+    # Set default values for app_path and load_paths before running initializers
+    initializer "active_admin.load_app_path", before: :load_config_initializers do |app|
+      ActiveAdmin::Application.setting :app_path, app.root
+      ActiveAdmin::Application.setting :load_paths, [File.expand_path('app/admin', app.root)]
+    end
+
+    initializer "active_admin.precompile", group: :all do |app|
+      ActiveAdmin.application.stylesheets.each do |path, _|
+        app.config.assets.precompile << path
+      end
+      ActiveAdmin.application.javascripts.each do |path|
+        app.config.assets.precompile << path
+      end
+    end
+
+    initializer 'active_admin.routes' do
+      require 'active_admin/helpers/routes/url_helpers'
+    end
+  end
+end