activeadmin-rails 1.7.0

data/lib/active_admin/resource_dsl.rb

@@ -0,0 +1,221 @@
+module ActiveAdmin
+  # This is the class where all the register blocks are evaluated.
+  class ResourceDSL < DSL
+
+    private
+
+    # Redefine sort behaviour for column
+    #
+    # For example:
+    #
+    #   # nulls last
+    #   order_by(:age) do |order_clause|
+    #     [order_clause.to_sql, 'NULLS LAST'].join(' ')  if order_clause.order == 'desc'
+    #   end
+    #
+    #   # by last_name but in the case that there is no last name, by first_name.
+    #   order_by(:full_name) do |order_clause|
+    #     ['COALESCE(NULLIF(last_name, ''), first_name), first_name', order_clause.order].join(' ')
+    #   end
+    #
+    #
+    def order_by(column, &block)
+      config.ordering[column] = block
+    end
+
+    def belongs_to(target, options = {})
+      config.belongs_to(target, options)
+    end
+
+    # Scope collection to a relation
+    def scope_to(*args, &block)
+      config.scope_to(*args, &block)
+    end
+
+    # Create a scope
+    def scope(*args, &block)
+      config.scope(*args, &block)
+    end
+
+    # Store relations that should be included
+    def includes(*args)
+      config.includes.push *args
+    end
+
+    #
+    # Keys included in the `permitted_params` setting are automatically whitelisted.
+    #
+    # Either
+    #
+    #   permit_params :title, :author, :body, tags: []
+    #
+    # Or
+    #
+    #   permit_params do
+    #     defaults = [:title, :body]
+    #     if current_user.admin?
+    #       defaults + [:author]
+    #     else
+    #       defaults
+    #     end
+    #   end
+    #
+    def permit_params(*args, &block)
+      config.permitted_attr_names = block_given? ? block : args
+    end
+
+    # Configure the index page for the resource
+    def index(options = {}, &block)
+      if block_given?
+        options[:as] ||= :table
+        config.set_page_presenter :index, ActiveAdmin::PagePresenter.new(options, &block)
+      else
+        config.set_page_options :index, options
+      end
+    end
+
+    # Configure the show page for the resource
+    def show(options = {}, &block)
+      if block_given?
+        config.set_page_presenter :show, ActiveAdmin::PagePresenter.new(options, &block)
+      else
+        config.set_page_options :show, options
+      end
+    end
+
+    def form(options = {}, &block)
+      if block_given?
+        config.set_page_presenter :form, ActiveAdmin::PagePresenter.new(options, &block)
+      else
+        config.set_page_options :form, options
+      end
+    end
+
+    # Configure the CSV format
+    #
+    # For example:
+    #
+    #   csv do
+    #     column :name
+    #     column("Author") { |post| post.author.full_name }
+    #   end
+    #
+    #   csv col_sep: ";", force_quotes: true do
+    #     column :name
+    #   end
+    #
+    def csv(options = {}, &block)
+      options[:resource] = config
+
+      config.csv_builder = CSVBuilder.new(options, &block)
+    end
+
+    # Member Actions give you the functionality of defining both the
+    # action and the route directly from your ActiveAdmin registration
+    # block.
+    #
+    # For example:
+    #
+    #   ActiveAdmin.register Post do
+    #     member_action :comments do
+    #       @post = Post.find(params[:id]
+    #       @comments = @post.comments
+    #     end
+    #   end
+    #
+    # Will create a new controller action comments and will hook it up to
+    # the named route (comments_admin_post_path) /admin/posts/:id/comments
+    #
+    # You can treat everything within the block as a standard Rails controller
+    # action.
+    #
+    def member_action(name, options = {}, &block)
+      if (title = options.delete(:title))
+        set_title_before_action(name, title)
+      end
+
+      define_controller_method(name, &block)
+
+      config.add_member_route(name, options)
+    end
+
+    def collection_action(name, options = {}, &block)
+      if (title = options.delete(:title))
+        set_title_before_action(name, title)
+      end
+
+      define_controller_method(name, &block)
+
+      config.add_collection_route(name, options)
+    end
+
+    def decorate_with(decorator_class)
+      # Force storage as a string. This will help us with reloading issues.
+      # Assuming decorator_class.to_s will return the name of the class allows
+      # us to handle a string or a class.
+      config.decorator_class_name = "::#{ decorator_class }"
+    end
+
+    # Defined Callbacks
+    #
+    # == After Build
+    # Called after the resource is built in the new and create actions.
+    #
+    # ActiveAdmin.register Post do
+    #   after_build do |post|
+    #     post.author = current_user
+    #   end
+    # end
+    #
+    # == Before / After Create
+    # Called before and after a resource is saved to the db on the create action.
+    #
+    # == Before / After Update
+    # Called before and after a resource is saved to the db on the update action.
+    #
+    # == Before / After Save
+    # Called before and after the object is saved in the create and update action.
+    # Note: Gets called after the create and update callbacks
+    #
+    # == Before / After Destroy
+    # Called before and after the object is destroyed from the database.
+    #
+    delegate :before_build,   :after_build,   to: :controller
+    delegate :before_create,  :after_create,  to: :controller
+    delegate :before_update,  :after_update,  to: :controller
+    delegate :before_save,    :after_save,    to: :controller
+    delegate :before_destroy, :after_destroy, to: :controller
+
+    # This code defines both *_filter and *_action for Rails 5.0 and  *_action for Rails >= 5.1
+    phases = [
+      :before, :skip_before,
+      :after,  :skip_after,
+      :around, :skip
+    ]
+    keywords = if Rails::VERSION::MAJOR == 5 && Rails::VERSION::MINOR >= 1
+                 [:action]
+               else
+                 [:action, :filter]
+               end
+
+    keywords.each do |name|
+      phases.each do |action|
+       define_method "#{action}_#{name}" do |*args, &block|
+         controller.public_send "#{action}_action", *args, &block
+       end
+     end
+    end
+
+    # Specify which actions to create in the controller
+    #
+    # Eg:
+    #
+    #   ActiveAdmin.register Post do
+    #     actions :index, :show
+    #   end
+    #
+    # Will only create the index and show actions (no create, update or delete)
+    delegate :actions, to: :controller
+
+  end
+end

data/lib/active_admin/router.rb

@@ -0,0 +1,113 @@
+module ActiveAdmin
+  # @private
+  class Router
+    attr_reader :namespaces, :router
+
+    def initialize(router:, namespaces:)
+      @router, @namespaces = router, namespaces
+    end
+
+    def apply
+      define_root_routes
+      define_resources_routes
+    end
+
+    private
+
+    def define_root_routes
+      namespaces.each do |namespace|
+        if namespace.root?
+          router.root namespace.root_to_options.merge(to: namespace.root_to, as: nil)
+        else
+          router.namespace namespace.name, namespace.route_options.dup do
+            router.root namespace.root_to_options.merge(to: namespace.root_to, as: :root)
+          end
+        end
+      end
+    end
+
+    # Defines the routes for each resource
+    def define_resources_routes
+      resources = namespaces.flat_map{ |n| n.resources.values }
+      resources.each do |config|
+        define_resource_routes(config)
+      end
+    end
+
+    def define_resource_routes(config)
+      if config.namespace.root?
+        define_routes(config)
+      else
+        # Add on the namespace if required
+        define_namespace(config)
+      end
+    end
+
+    def define_routes(config)
+      if config.belongs_to?
+        define_belongs_to_routes(config)
+      else
+        page_or_resource_routes(config)
+      end
+    end
+
+    def page_or_resource_routes(config)
+      config.is_a?(Page) ? page_routes(config) : resource_routes(config)
+    end
+
+    def resource_routes(config)
+      router.resources config.resource_name.route_key, only: config.defined_actions do
+        define_actions(config)
+      end
+    end
+
+    def page_routes(config)
+      page = config.underscored_resource_name
+      router.get "/#{page}" => "#{page}#index"
+      config.page_actions.each do |action|
+        Array.wrap(action.http_verb).each do |verb|
+          build_route(verb, "/#{page}/#{action.name}" => "#{page}##{action.name}")
+        end
+      end
+    end
+
+    # Defines member and collection actions
+    def define_actions(config)
+      router.member do
+        config.member_actions.each { |action| build_action(action) }
+      end
+
+      router.collection do
+        config.collection_actions.each { |action| build_action(action) }
+        router.post :batch_action if config.batch_actions_enabled?
+      end
+    end
+
+    # Deals with +ControllerAction+ instances
+    # Builds one route for each HTTP verb passed in
+    def build_action(action)
+      build_route(action.http_verb, action.name)
+    end
+
+    def build_route(verbs, *args)
+      Array.wrap(verbs).each { |verb| router.send(verb, *args) }
+    end
+
+    def define_belongs_to_routes(config)
+      # If it's optional, make the normal resource routes
+      page_or_resource_routes(config) if config.belongs_to_config.optional?
+
+      # Make the nested belongs_to routes
+      # :only is set to nothing so that we don't clobber any existing routes on the resource
+      router.resources config.belongs_to_config.target.resource_name.plural, only: [] do
+        page_or_resource_routes(config)
+      end
+    end
+
+    def define_namespace(config)
+      router.namespace config.namespace.name, config.namespace.route_options.dup do
+        define_routes(config)
+      end
+    end
+  end
+end

data/lib/active_admin/scope.rb

@@ -0,0 +1,60 @@
+module ActiveAdmin
+  class Scope
+
+    attr_reader :scope_method, :id, :scope_block, :display_if_block, :show_count, :default_block, :group
+
+    # Create a Scope
+    #
+    # Examples:
+    #
+    #   Scope.new(:published)
+    #   # => Scope with name 'Published' and scope method :published
+    #
+    #   Scope.new('Published', :public)
+    #   # => Scope with name 'Published' and scope method :public
+    #
+    #   Scope.new 'Published', :public, if: proc { current_admin_user.can? :manage, resource_class } do |articles|
+    #     articles.where published: true
+    #   end
+    #   # => Scope with name 'Published' and scope method :public, optionally displaying the scope per the :if block
+    #
+    #   Scope.new('Published') { |articles| articles.where(published: true) }
+    #   # => Scope with name 'Published' using a block to scope
+    #
+    #   Scope.new ->{Date.today.strftime '%A'}, :published_today
+    #   # => Scope with dynamic title using the :published_today scope method
+    #
+    #   Scope.new :published, nil, group: :status
+    #   # => Scope with the group :status
+    #
+    def initialize(name, method = nil, options = {}, &block)
+      @name, @scope_method = name, method.try(:to_sym)
+
+      if name.is_a? Proc
+        raise "A string/symbol is required as the second argument if your label is a proc." unless method
+        @id = method.to_s.parameterize(separator: "_")
+      else
+        @scope_method ||= name.to_sym
+        @id = name.to_s.parameterize(separator: "_")
+      end
+
+      @scope_method               = nil        if @scope_method == :all
+      @scope_method, @scope_block = nil, block if block_given?
+
+      @localizer        = options[:localizer]
+      @show_count       = options.fetch(:show_count, true)
+      @display_if_block = options[:if]      || proc{ true }
+      @default_block    = options[:default] || proc{ false }
+      @group            = options[:group].try(:to_sym)
+    end
+
+    def name
+      case @name
+      when String then @name
+      when Symbol then @localizer ? @localizer.t(@name, scope: 'scopes') : @name.to_s.titleize
+      else @name
+      end
+    end
+
+  end
+end

data/lib/active_admin/settings_node.rb

@@ -0,0 +1,19 @@
+module ActiveAdmin
+
+  class SettingsNode
+    class << self
+      # Never instantiated.  Variables are stored in the singleton_class.
+      private_class_method :new
+
+      # @returns anonymous class with same accessors as the superclass.
+      def build(superclass = self)
+        Class.new(superclass)
+      end
+
+      def register(name, value)
+        class_attribute name
+        send "#{name}=", value
+      end
+    end
+  end
+end

data/lib/active_admin/sidebar_section.rb

@@ -0,0 +1,37 @@
+module ActiveAdmin
+
+  class SidebarSection
+    include ActiveAdmin::OptionalDisplay
+
+    attr_accessor :name, :options, :block
+
+    def initialize(name, options = {}, &block)
+      @name, @options, @block = name.to_s, options, block
+      normalize_display_options!
+    end
+
+    # The id gets used for the div in the view
+    def id
+      "#{name.downcase.underscore}_sidebar_section".parameterize
+    end
+
+    # The title gets displayed within the section in the view
+    def title
+      I18n.t("active_admin.sidebars.#{name}", default: name.titlecase)
+    end
+
+    # If a block is not passed in, the name of the partial to render
+    def partial_name
+      options[:partial] || "#{name.downcase.tr(' ', '_')}_sidebar"
+    end
+
+    def custom_class
+      options[:class]
+    end
+
+    def priority
+      options[:priority] || 10
+    end
+  end
+
+end

data/lib/active_admin/version.rb

@@ -0,0 +1,3 @@
+module ActiveAdmin
+  VERSION = '1.7.0'
+end

data/lib/active_admin/view_factory.rb

@@ -0,0 +1,10 @@
+require 'active_admin/abstract_view_factory'
+
+module ActiveAdmin
+  class ViewFactory < AbstractViewFactory
+
+    # Register Helper Renderers
+    register  site_title:          ActiveAdmin::Views::SiteTitle,
+              index_scopes:        ActiveAdmin::Views::Scopes
+  end
+end

data/lib/active_admin/view_helpers/active_admin_application_helper.rb

@@ -0,0 +1,12 @@
+module ActiveAdmin
+  module ViewHelpers
+    module ActiveAdminApplicationHelper
+
+      # Returns the current Active Admin application instance
+      def active_admin_application
+        ActiveAdmin.application
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/auto_link_helper.rb

@@ -0,0 +1,45 @@
+module ActiveAdmin
+  module ViewHelpers
+    module AutoLinkHelper
+
+      # Automatically links objects to their resource controllers. If
+      # the resource has not been registered, a string representation of
+      # the object is returned.
+      #
+      # The default content in the link is returned from ActiveAdmin::ViewHelpers::DisplayHelper#display_name
+      #
+      # You can pass in the content to display
+      #   eg: auto_link(@post, "My Link")
+      #
+      def auto_link(resource, content = display_name(resource))
+        if url = auto_url_for(resource)
+          link_to content, url
+        else
+          content
+        end
+      end
+
+      # Like `auto_link`, except that it only returns a URL instead of a full <a> tag
+      def auto_url_for(resource)
+        config = active_admin_resource_for(resource.class)
+        return unless config
+
+        if config.controller.action_methods.include?("show") &&
+          authorized?(ActiveAdmin::Auth::READ, resource)
+          url_for config.route_instance_path resource, url_options
+        elsif config.controller.action_methods.include?("edit") &&
+          authorized?(ActiveAdmin::Auth::UPDATE, resource)
+          url_for config.route_edit_instance_path resource, url_options
+        end
+      end
+
+      # Returns the ActiveAdmin::Resource instance for a class
+      def active_admin_resource_for(klass)
+        if respond_to? :active_admin_namespace
+          active_admin_namespace.resource_for klass
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/breadcrumb_helper.rb

@@ -0,0 +1,52 @@
+module ActiveAdmin
+  module ViewHelpers
+    module BreadcrumbHelper
+
+      # Returns an array of links to use in a breadcrumb
+      def breadcrumb_links(path = request.path)
+        setting = active_admin_config.breadcrumb
+
+        if setting.blank?
+          nil
+        elsif setting.is_a?(Proc)
+          instance_exec(controller, &setting)
+        else
+          default_breadcrumb_links(path)
+        end
+      end
+
+      GUID_REGEX = '(?:[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12})'
+      ID_REGEX = '\d+|[a-f0-9]{24}|' + GUID_REGEX
+
+      def default_breadcrumb_links(path)
+        # remove leading "/" and split up the URL
+        # and remove last since it's used as the page title
+        parts = path.split('/').select(&:present?)[0..-2]
+
+        parts.each_with_index.map do |part, index|
+          config = breadcrumb_part_config(parts[index-1]) if part.match?(/\A(#{ID_REGEX})\z/)
+
+          # 1. try using `display_name` if we can locate a DB object
+          # 2. try using the model name translation
+          # 3. default to calling `titlecase` on the URL fragment
+          name = config && display_name(config.find_resource part)
+          name ||= I18n.t "activerecord.models.#{part.singularize}", count: ::ActiveAdmin::Helpers::I18n::PLURAL_MANY_COUNT, default: part.titlecase
+
+          # Don't create a link if the resource's show action is disabled
+          if !config || config.defined_actions.include?(:show)
+            link_to name, '/' + parts[0..index].join('/')
+          else
+            name
+          end
+        end
+      end
+
+      def breadcrumb_part_config(parent_part)
+        config = active_admin_config
+        parent = config.belongs_to_config.try :target
+        parent && parent.resource_name.route_key == parent_part ? parent :  config
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/display_helper.rb

@@ -0,0 +1,95 @@
+module ActiveAdmin
+  module ViewHelpers
+    module DisplayHelper
+
+      DISPLAY_NAME_FALLBACK = ->{
+        name, klass = "", self.class
+        name << klass.model_name.human         if klass.respond_to? :model_name
+        name << " ##{send(klass.primary_key)}" if klass.respond_to? :primary_key
+        name.present? ? name : to_s
+      }
+      def DISPLAY_NAME_FALLBACK.inspect
+        'DISPLAY_NAME_FALLBACK'
+      end
+
+      # Attempts to call any known display name methods on the resource.
+      # See the setting in `application.rb` for the list of methods and their priority.
+      def display_name(resource)
+        sanitize(render_in_context(resource, display_name_method_for(resource)).to_s) unless resource.nil?
+      end
+
+      # Looks up and caches the first available display name method.
+      # To prevent conflicts, we exclude any methods that happen to be associations.
+      # If no methods are available and we're about to use the Kernel's `to_s`, provide our own.
+      def display_name_method_for(resource)
+        @@display_name_methods_cache ||= {}
+        @@display_name_methods_cache[resource.class] ||= begin
+          methods = active_admin_application.display_name_methods - association_methods_for(resource)
+          method  = methods.detect{ |method| resource.respond_to? method }
+
+          if method != :to_s || resource.method(method).source_location
+            method
+          else
+            DISPLAY_NAME_FALLBACK
+          end
+        end
+      end
+
+      def association_methods_for(resource)
+        return [] unless resource.class.respond_to? :reflect_on_all_associations
+        resource.class.reflect_on_all_associations.map(&:name)
+      end
+
+      def format_attribute(resource, attr)
+        value = find_value resource, attr
+
+        if value.is_a?(Arbo::Element)
+          value
+        elsif boolean_attr?(resource, attr, value)
+          Arbo::Context.new { status_tag value }
+        else
+          pretty_format value
+        end
+      end
+
+      def find_value(resource, attr)
+        if attr.is_a? Proc
+          attr.call resource
+        elsif resource.respond_to? attr
+          resource.public_send attr
+        elsif resource.respond_to? :[]
+          resource[attr]
+        end
+      end
+
+      # Attempts to create a human-readable string for any object
+      def pretty_format(object)
+        case object
+        when String, Numeric, Symbol, Arbo::Element
+          object.to_s
+        when Date, Time
+          I18n.localize object, format: active_admin_application.localize_format
+        else
+          if defined?(::ActiveRecord) && object.is_a?(ActiveRecord::Base) ||
+             defined?(::Mongoid)      && object.class.include?(Mongoid::Document)
+            auto_link object
+          else
+            display_name object
+          end
+        end
+      end
+
+      def boolean_attr?(resource, attr, value)
+        case value
+        when TrueClass, FalseClass
+          true
+        else
+          if resource.class.respond_to? :columns_hash
+            column = resource.class.columns_hash[attr.to_s] and column.type == :boolean
+          end
+        end
+      end
+
+    end
+  end
+end