yousty-activeadmin 1.0.0.pre

data/lib/active_admin/devise.rb

@@ -0,0 +1,70 @@
+require 'devise'
+
+module ActiveAdmin
+  module Devise
+
+    def self.config
+      config = {
+        :path => ActiveAdmin.application.default_namespace,
+        :controllers => ActiveAdmin::Devise.controllers,
+        :path_names => { :sign_in => 'login', :sign_out => "logout" }
+      }
+
+      if ::Devise.respond_to?(:sign_out_via)
+        logout_methods = [::Devise.sign_out_via, ActiveAdmin.application.logout_link_method].flatten.uniq
+        config.merge!( :sign_out_via => logout_methods)
+      end
+
+      config
+    end
+
+    def self.controllers
+      {
+        :sessions => "active_admin/devise/sessions",
+        :passwords => "active_admin/devise/passwords",
+        :unlocks => "active_admin/devise/unlocks"
+      }
+    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('_')
+
+        url_helpers = Rails.application.routes.url_helpers
+
+        path = if url_helpers.respond_to? root_path_method
+                 url_helpers.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
+
+  end
+end

data/lib/active_admin/dsl.rb

@@ -0,0 +1,166 @@
+module ActiveAdmin
+
+  #
+  # The Active Admin DSL. This class is where all the registration blocks
+  # are instance eval'd. 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_eval &block if block_given?
+    end
+
+    # The instance of ActiveAdmin::Config 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
+    #
+    # @returns [Nil]
+    def include(mod)
+      mod.included(self)
+    end
+
+    # Returns the controller for this resource. If you pass a
+    # block, it will be eval'd 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_eval(&block) if block_given?
+      @config.controller
+    end
+
+    # Add a new action item to the resource
+    #
+    # @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(options = {}, &block)
+      config.add_action_item(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.gsub(' ', '').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 conjuction 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)
+      config.sidebar_sections << ActiveAdmin::SidebarSection.new(name, options, &block)
+    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
+  end
+end

data/lib/active_admin/engine.rb

@@ -0,0 +1,7 @@
+module ActiveAdmin
+  class Engine < ::Rails::Engine
+    initializer "ActiveAdmin precompile hook", :group => :all do |app|
+      app.config.assets.precompile += %w(active_admin.js active_admin.css active_admin/print.css)
+    end
+  end
+end

data/lib/active_admin/event.rb

@@ -0,0 +1,33 @@
+module ActiveAdmin
+
+  class EventDispatcher
+    def initialize
+      @events = {}
+    end
+
+    def clear_all_subscribers!
+      @events = {}
+    end
+
+    def subscribe(*event_names, &block)
+      event_names.each do |event|
+        @events[event] ||= []
+        @events[event] << block
+      end
+    end
+
+    def subscribers(event)
+      @events[event] || []
+    end
+
+    def dispatch(event, *args)
+      subscribers(event).each do |subscriber|
+        subscriber.call(*args)
+      end
+    end
+  end
+
+  # ActiveAdmin::Event is set to a dispatcher
+  Event = EventDispatcher.new
+
+end

data/lib/active_admin/filters/dsl.rb

@@ -0,0 +1,21 @@
+module ActiveAdmin
+  module Filters
+    module DSL
+
+      # For docs, please see ActiveAdmin::Filters::ResourceExtension#add_filter
+      def filter(attribute, options = {})
+        config.add_filter(attribute, options)
+      end
+
+      # For docs, please see ActiveAdmin::Filters::ResourceExtension#remove_filter
+      def remove_filter(attribute)
+        config.remove_filter(attribute)
+      end
+
+      # For docs, please see ActiveAdmin::Filters::ResourceExtension#preserve_default_filters!
+      def preserve_default_filters!
+        config.preserve_default_filters!
+      end
+    end
+  end
+end

data/lib/active_admin/filters/forms.rb

@@ -0,0 +1,89 @@
+module ActiveAdmin
+  module Filters
+
+    # This form builder defines methods to build filter forms such
+    # as the one found in the sidebar of the index page of a standard resource.
+    class FormBuilder < ::ActiveAdmin::FormBuilder
+      include ::ActiveAdmin::Filters::FormtasticAddons
+
+      def initialize(*args)
+        @use_form_buffer = true # force ActiveAdmin::FormBuilder to use the form buffer
+        super
+      end
+
+      def filter(method, options = {})
+        if method.present? && options[:as] ||= default_input_type(method)
+          input(method, options)
+        end
+      end
+
+      protected
+
+      # Returns the default filter type for a given attribute. If you want
+      # to use a custom search method, you have to specify the type yourself.
+      def default_input_type(method, options = {})
+        if method =~ /_(contains|starts_with|ends_with)\z/
+          :string
+        elsif reflection_for(method) || polymorphic_foreign_type?(method)
+          :select
+        elsif column = column_for(method)
+          case column.type
+          when :date, :datetime
+            :date_range
+          when :string, :text
+            :string
+          when :integer, :float, :decimal
+            :numeric
+          when :boolean
+            :boolean
+          end
+        end
+      end
+
+      def custom_input_class_name(as)
+        "Filter#{as.to_s.camelize}Input"
+      end
+
+      def active_admin_input_class_name(as)
+        "ActiveAdmin::Inputs::Filter#{as.to_s.camelize}Input"
+      end
+
+    end
+
+
+    # This module is included into the view
+    module ViewHelper
+
+      # Helper method to render a filter form
+      def active_admin_filters_form_for(search, filters, options = {})
+        defaults = { :builder => ActiveAdmin::Filters::FormBuilder,
+                     :url     => collection_path,
+                     :html    => {:class  => 'filter_form'} }
+        required = { :html    => {:method => :get},
+                     :as      => :q }
+        options  = defaults.deep_merge(options).deep_merge(required)
+
+        form_for search, options do |f|
+          filters.each do |attribute, opts|
+            should   = opts.delete(:if)     || proc{ true }
+            shouldnt = opts.delete(:unless) || proc{ false }
+
+            if call_method_or_proc_on(self, should) && !call_method_or_proc_on(self, shouldnt)
+              f.filter attribute, opts
+            end
+          end
+
+          buttons = content_tag :div, :class => "buttons" do
+            f.submit(I18n.t('active_admin.filters.buttons.filter')) +
+              link_to(I18n.t('active_admin.filters.buttons.clear'), '#', :class => 'clear_filters_btn') +
+              hidden_field_tags_for(params, :except => [:q, :page])
+          end
+
+          f.form_buffers.last + buttons
+        end
+      end
+
+    end
+
+  end
+end

data/lib/active_admin/filters/formtastic_addons.rb

@@ -0,0 +1,70 @@
+module ActiveAdmin
+  module Filters
+    module FormtasticAddons
+
+      #
+      # The below are Formtastic method overrides that jump inside of the Ransack
+      # search object to get at the object being searched upon.
+      #
+
+      def humanized_method_name
+        if klass.respond_to?(:human_attribute_name)
+          klass.human_attribute_name(method)
+        else
+          method.to_s.send(builder.label_str_method)
+        end
+      end
+
+      def reflection_for(method)
+        klass.reflect_on_association(method) if klass.respond_to? :reflect_on_association
+      end
+
+      def column_for(method)
+        klass.columns_hash[method.to_s] if klass.respond_to? :columns_hash
+      end
+
+      def column
+        column_for method
+      end
+
+      #
+      # The below are custom methods that Formtastic does not provide.
+      #
+
+      # The resource class, unwrapped from Ransack
+      def klass
+        @object.object.klass
+      end
+
+      def polymorphic_foreign_type?(method)
+        klass.reflections.values.select{ |r| r.macro == :belongs_to && r.options[:polymorphic] }
+          .map(&:foreign_type).include? method.to_s
+      end
+
+      def searchable_through_association?(method = method)
+        ref = reflection_for(method)
+        ref.options[:through] && ref.through_reflection.klass.ransackable_attributes.include?(ref.foreign_key) if ref
+      end
+
+      #
+      # These help figure out whether the given method will be recognized by Ransack.
+      #
+
+      def seems_searchable?
+        has_predicate? || ransacker?
+      end
+
+      # If the given method has a predicate (like _eq or _lteq), it's pretty
+      # likely we're dealing with a valid search method.
+      def has_predicate?
+        !!Ransack::Predicate.detect_and_strip_from_string!(method.to_s)
+      end
+
+      # Ransack lets you define custom search methods, so we need to check for them.
+      def ransacker?
+        klass._ransackers.key? method.to_s
+      end
+
+    end
+  end
+end

data/lib/active_admin/filters/resource_extension.rb

@@ -0,0 +1,136 @@
+module ActiveAdmin
+  module Filters
+
+    class Disabled < RuntimeError
+      def initialize
+        super "Can't remove a filter when filters are disabled. Enable filters with 'config.filters = true'"
+      end
+    end
+
+    module ResourceExtension
+
+      def initialize(*)
+        super
+        add_filters_sidebar_section
+      end
+
+      # Returns the filters for this resource. If filters are not enabled,
+      # it will always return an empty array.
+      #
+      # @return [Array] Filters that apply for this resource
+      def filters
+        return [] unless filters_enabled?
+        filter_lookup
+      end
+
+      # Setter to enable / disable filters on this resource.
+      #
+      # Set to `nil` to inherit the setting from the namespace
+      def filters=(bool)
+        @filters_enabled = bool
+      end
+
+      # @return [Boolean] If filters are enabled for this resource
+      def filters_enabled?
+        @filters_enabled.nil? ? namespace.filters : @filters_enabled
+      end
+
+      def preserve_default_filters!
+        @preserve_default_filters = true
+      end
+
+      def preserve_default_filters?
+        @preserve_default_filters == true
+      end
+
+      # Remove a filter for this resource. If filters are not enabled, this method
+      # will raise a RuntimeError
+      #
+      # @param [Symbol] attribute The attribute to not filter on
+      def remove_filter(attribute)
+        raise Disabled unless filters_enabled?
+
+        (@filters_to_remove ||= []) << attribute.to_sym
+      end
+
+      # Add a filter for this resource. If filters are not enabled, this method
+      # will raise a RuntimeError
+      #
+      # @param [Symbol] attribute The attribute to filter on
+      # @param [Hash] options The set of options that are passed through to
+      #                       ransack for the field definition.
+      def add_filter(attribute, options = {})
+        raise Disabled unless filters_enabled?
+
+        (@filters ||= {})[attribute.to_sym] = options
+      end
+
+      # Reset the filters to use defaults
+      def reset_filters!
+        @filters = nil
+        @filters_to_remove = nil
+      end
+
+    private
+
+      # Collapses the waveform, if you will, of which filters should be displayed.
+      # Removes filters and adds in default filters as desired.
+      def filter_lookup
+        filters = @filters.try(:deep_dup) || {}
+
+        if filters.empty? || preserve_default_filters?
+          default_filters.each do |f|
+            filters[f] ||= {}
+          end
+        end
+
+        if @filters_to_remove
+          @filters_to_remove.each &filters.method(:delete)
+        end
+
+        filters
+      end
+
+      # @return [Array] The array of default filters for this resource
+      def default_filters
+        default_association_filters + default_content_filters
+      end
+
+      # Returns a default set of filters for the associations
+      def default_association_filters
+        if resource_class.respond_to?(:reflect_on_all_associations)
+          poly, not_poly = resource_class.reflect_on_all_associations.partition{ |r| r.macro == :belongs_to && r.options[:polymorphic] }
+
+          # remove associations nested more than twice
+          not_poly.reject!{ |r| r.chain.length > 2 }
+
+          filters = poly.map(&:foreign_type) + not_poly.map(&:name)
+          filters.map &:to_sym
+        else
+          []
+        end
+      end
+
+      # Returns a default set of filters for the content columns
+      def default_content_filters
+        if resource_class.respond_to? :content_columns
+          resource_class.content_columns.map{ |c| c.name.to_sym }
+        else
+          []
+        end
+      end
+
+      def add_filters_sidebar_section
+        self.sidebar_sections << filters_sidebar_section
+      end
+
+      def filters_sidebar_section
+        ActiveAdmin::SidebarSection.new :filters, only: :index, if: ->{ active_admin_config.filters.any? } do
+          active_admin_filters_form_for assigns[:search], active_admin_config.filters
+        end
+      end
+
+    end
+
+  end
+end

data/lib/active_admin/filters.rb

@@ -0,0 +1,9 @@
+require 'active_admin/filters/dsl'
+require 'active_admin/filters/resource_extension'
+require 'active_admin/filters/formtastic_addons'
+require 'active_admin/filters/forms'
+
+# Add our Extensions
+ActiveAdmin::ResourceDSL.send :include, ActiveAdmin::Filters::DSL
+ActiveAdmin::Resource.send    :include, ActiveAdmin::Filters::ResourceExtension
+ActiveAdmin::ViewHelpers.send :include, ActiveAdmin::Filters::ViewHelper