activeadministration 0.0.1

data/lib/active_admin/filters/resource_extension.rb

@@ -0,0 +1,135 @@
+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 [Hash] Filters that apply for this resource
+      def filters
+        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(*attributes)
+        raise Disabled unless filters_enabled?
+
+        attributes.each { |attribute| (@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(: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 deeply nested associations
+          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/form_builder.rb

@@ -0,0 +1,185 @@
+# Note for posterity:
+#
+# Here we have two core customizations on top of Formtastic. First, this allows
+# you to build forms in the AA DSL without dealing with the HTML return value of
+# individual form methods (hence the +form_buffers+ object). Second, this provides
+# an intuitive way to build has_many associated records in the same form.
+#
+module ActiveAdmin
+  class FormBuilder < ::Formtastic::FormBuilder
+
+    attr_reader :form_buffers
+
+    def initialize(*args)
+      @form_buffers = ["".html_safe]
+      super
+    end
+
+    def inputs(*args, &block)
+      @use_form_buffer = block_given?
+      form_buffers.last << with_new_form_buffer{ super }
+    end
+
+    # If this `input` call is inside a `inputs` block, add the content
+    # to the form buffer. Else, return it directly.
+    def input(method, *args)
+      content = with_new_form_buffer{ super }
+      @use_form_buffer ? form_buffers.last << content : content
+    end
+
+    def cancel_link(url = {action: "index"}, html_options = {}, li_attrs = {})
+      li_attrs[:class] ||= "cancel"
+      li_content = template.link_to I18n.t('active_admin.cancel'), url, html_options
+      form_buffers.last << template.content_tag(:li, li_content, li_attrs)
+    end
+
+    def actions(*args, &block)
+      form_buffers.last << with_new_form_buffer do
+        block_given? ? super : super{ commit_action_with_cancel_link }
+      end
+    end
+
+    def action(*args)
+      form_buffers.last << with_new_form_buffer{ super }
+    end
+
+    def commit_action_with_cancel_link
+      action(:submit)
+      cancel_link
+    end
+
+    def has_many(assoc, options = {}, &block)
+      # remove options that should not render as attributes
+      custom_settings = :new_record, :allow_destroy, :heading, :sortable
+      builder_options = {new_record: true}.merge! options.slice  *custom_settings
+      options         = {for: assoc      }.merge! options.except *custom_settings
+      options[:class] = [options[:class], "inputs has_many_fields"].compact.join(' ')
+
+      # Add Delete Links
+      form_block = proc do |has_many_form|
+        index    = parent_child_index options[:parent] if options[:parent]
+        contents = block.call has_many_form, index
+
+        if has_many_form.object.new_record?
+          contents << template.content_tag(:li) do
+            template.link_to I18n.t('active_admin.has_many_remove'), "#", class: 'button has_many_remove'
+          end
+        elsif builder_options[:allow_destroy]
+          has_many_form.input :_destroy, as: :boolean, wrapper_html: {class: 'has_many_delete'},
+                                                       label: I18n.t('active_admin.has_many_delete')
+        end
+
+        if builder_options[:sortable]
+          has_many_form.input builder_options[:sortable], as: :hidden
+
+          contents << template.content_tag(:li, class: 'handle') do
+            Iconic.icon :move_vertical
+          end
+        end
+
+        contents
+      end
+
+      # make sure that the sortable children sorted in stable ascending order
+      if column = builder_options[:sortable]
+        children = object.send(assoc)
+        children = children.sort_by {|o| [o.send(column), o.id]}
+        options[:for] = [assoc,  children]
+      end
+
+      html = without_wrapper do
+        unless builder_options.key?(:heading) && !builder_options[:heading]
+          form_buffers.last << template.content_tag(:h3) do
+            builder_options[:heading] || object.class.reflect_on_association(assoc).klass.model_name.human(count: ::ActiveAdmin::Helpers::I18n::PLURAL_MANY_COUNT)
+          end
+        end
+
+        inputs options, &form_block
+
+        form_buffers.last << js_for_has_many(assoc, form_block, template, builder_options[:new_record], options[:class]) if builder_options[:new_record]
+        form_buffers.last
+      end
+
+      form_buffers.last << if @already_in_an_inputs_block
+        template.content_tag :li,  html, class: "has_many_container #{assoc}", 'data-sortable' => builder_options[:sortable]
+      else
+        template.content_tag :div, html, class: "has_many_container #{assoc}", 'data-sortable' => builder_options[:sortable]
+      end
+    end
+
+    def semantic_errors(*args)
+      form_buffers.last << with_new_form_buffer{ super }
+    end
+
+    protected
+
+    def active_admin_input_class_name(as)
+      "ActiveAdmin::Inputs::#{as.to_s.camelize}Input"
+    end
+
+    def input_class(as)
+      @input_classes_cache ||= {}
+      @input_classes_cache[as] ||= begin
+        begin
+          custom_input_class_name(as).constantize
+        rescue NameError
+          begin
+            active_admin_input_class_name(as).constantize
+          rescue NameError
+            standard_input_class_name(as).constantize
+          end
+        end
+      rescue NameError
+        raise Formtastic::UnknownInputError, "Unable to find input class for #{as}"
+      end
+    end
+
+    # This method calls the block it's passed (in our case, the `f.inputs` block)
+    # and wraps the resulting HTML in a fieldset. If your block doesn't have a
+    # valid return value but it was otherwise built correctly, we instead use
+    # the most recent part of the Active Admin form buffer.
+    def field_set_and_list_wrapping(*args, &block)
+      block_given? ? super{
+        (val = yield).is_a?(String) ? val : form_buffers.last
+      } : super
+    end
+
+    private
+
+    def with_new_form_buffer
+      form_buffers << ''.html_safe
+      return_value = (yield || '').html_safe
+      form_buffers.pop
+      return_value
+    end
+
+    def without_wrapper
+      is_being_wrapped = @already_in_an_inputs_block
+      @already_in_an_inputs_block = false
+
+      html = with_new_form_buffer{ yield }
+
+      @already_in_an_inputs_block = is_being_wrapped
+      html
+    end
+
+    # Capture the ADD JS
+    def js_for_has_many(assoc, form_block, template, new_record, class_string)
+      assoc_reflection = object.class.reflect_on_association assoc
+      assoc_name       = assoc_reflection.klass.model_name
+      placeholder      = "NEW_#{assoc_name.to_s.upcase.split(' ').join('_')}_RECORD"
+      opts = {
+        for: [assoc, assoc_reflection.klass.new],
+        class: class_string,
+        for_options: { child_index: placeholder }
+      }
+      html = with_new_form_buffer{ inputs_for_nested_attributes opts, &form_block }
+      text = new_record.is_a?(String) ? new_record : I18n.t('active_admin.has_many_new', model: assoc_name.human)
+
+      template.link_to text, '#', class: "button has_many_add", data: {
+        html: CGI.escapeHTML(html).html_safe, placeholder: placeholder
+      }
+    end
+
+  end
+end

data/lib/active_admin/helpers/collection.rb

@@ -0,0 +1,23 @@
+module ActiveAdmin
+  module Helpers
+    module Collection
+      # Works around this issue: https://github.com/rails/rails/issues/7121
+      #
+      # GROUP BY + COUNT drops SELECT statement. This leads to SQL error when
+      # the ORDER statement mentions a column defined in the SELECT statement.
+      #
+      # We remove the ORDER statement to work around this issue.
+      def collection_size(collection=collection)
+        if collection.group_values.present?
+          collection.reorder("").count # is a Hash
+        else
+          collection
+        end.count
+      end
+
+      def collection_is_empty?(collection=collection)
+        collection_size(collection) == 0
+      end
+    end
+  end
+end

data/lib/active_admin/helpers/i18n.rb

@@ -0,0 +1,7 @@
+module ActiveAdmin
+  module Helpers
+    module I18n
+      PLURAL_MANY_COUNT = 2.1
+    end
+  end
+end

data/lib/active_admin/helpers/optional_display.rb

@@ -0,0 +1,38 @@
+module ActiveAdmin
+
+  # Shareable module to give a #display_on?(action) method
+  # which returns true or false depending on an options hash.
+  #
+  # The options hash accepts:
+  #
+  # only: :index
+  # only: [:index, :show]
+  # except: :index
+  # except: [:index, :show]
+  #
+  # call #normalize_display_options! after @options has been set
+  # to ensure that the display options are setup correctly
+
+  module OptionalDisplay
+    def display_on?(action, render_context = self)
+      return false if @options[:only]   && !@options[:only].include?(action.to_sym)
+      return false if @options[:except] && @options[:except].include?(action.to_sym)
+
+      case condition = @options[:if]
+      when Symbol, String
+        render_context.send condition
+      when Proc
+        render_context.instance_exec &condition
+      else
+        true
+      end
+    end
+
+    private
+
+    def normalize_display_options!
+      @options[:only]   = Array(@options[:only])   if @options[:only]
+      @options[:except] = Array(@options[:except]) if @options[:except]
+    end
+  end
+end

data/lib/active_admin/helpers/scope_chain.rb

@@ -0,0 +1,23 @@
+module ActiveAdmin
+  module ScopeChain
+    # Scope an ActiveRecord::Relation chain
+    #
+    # Example:
+    #   scope_chain(Scope.new(:published), Article)
+    #   # => Article.published
+    #
+    # @param scope The <ActiveAdmin::Scope> we want to scope on
+    # @param chain The ActiveRecord::Relation chain or ActiveRecord::Base class to scope
+    # @return <ActiveRecord::Relation or ActiveRecord::Base> The scoped relation chain
+    #
+    def scope_chain(scope, chain)
+      if scope.scope_method
+        chain.send(scope.scope_method)
+      elsif scope.scope_block
+        instance_exec chain, &scope.scope_block
+      else
+        chain
+      end
+    end
+  end
+end

data/lib/active_admin/helpers/settings.rb

@@ -0,0 +1,106 @@
+module ActiveAdmin
+
+  # Adds a class method to a class to create settings with default values.
+  #
+  # Example:
+  #
+  #   class Configuration
+  #     include ActiveAdmin::Settings
+  #
+  #     setting :site_title, "Default Site Title"
+  #   end
+  #
+  #   conf = Configuration.new
+  #   conf.site_title #=> "Default Site Title"
+  #   conf.site_title = "Override Default"
+  #   conf.site_title #=> "Override Default"
+  #
+  module Settings
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def read_default_setting(name)
+      default_settings[name]
+    end
+
+    private
+
+    def default_settings
+      self.class.default_settings
+    end
+
+    module ClassMethods
+
+      def setting(name, default)
+        default_settings[name] = default
+        attr_writer name
+
+        # Create an accessor that looks up the default value if none is set.
+        define_method name do
+          if instance_variable_defined? "@#{name}"
+            instance_variable_get "@#{name}"
+          else
+            read_default_setting name.to_sym
+          end
+        end
+      end
+
+      def deprecated_setting(name, default, message = nil)
+        setting(name, default)
+
+        message ||= "The #{name} setting is deprecated and will be removed."
+        ActiveAdmin::Deprecation.deprecate self,     name,    message
+        ActiveAdmin::Deprecation.deprecate self, :"#{name}=", message
+      end
+
+      def default_settings
+        @default_settings ||= {}
+      end
+
+    end
+
+
+    # Allows you to define child classes that should receive the same
+    # settings, as well as the same default values.
+    #
+    # Example from the codebase:
+    #
+    #   class Application
+    #     include Settings
+    #     include Settings::Inheritance
+    #
+    #     settings_inherited_by :Namespace
+    #
+    #     inheritable_setting :root_to, 'dashboard#index'
+    #   end
+    #
+    module Inheritance
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+
+        def settings_inherited_by(heir)
+          (@setting_heirs ||= []) << heir
+          heir.send :include, ActiveAdmin::Settings
+        end
+
+        def inheritable_setting(name, default)
+          setting name, default
+          @setting_heirs.each{ |c| c.setting name, default }
+        end
+
+        def deprecated_inheritable_setting(name, default)
+          deprecated_setting name, default
+          @setting_heirs.each{ |c| c.deprecated_setting name, default }
+        end
+
+      end
+    end
+
+  end
+end