activeadmin_addons 0.12.0 → 1.0.0

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/form_builder.rb

@@ -0,0 +1,141 @@
+# Provides an intuitive way to build has_many associated records in the same form.
+module Formtastic
+  module Inputs
+    module Base
+      def input_wrapping(&block)
+        html = super
+        template.concat(html) if template.output_buffer && template.assigns[:has_many_block]
+        html
+      end
+    end
+  end
+end
+
+module ActiveAdmin
+  class FormBuilder < ::Formtastic::FormBuilder
+    self.input_namespaces = [::Object, ::ActiveAdmin::Inputs, ::Formtastic::Inputs]
+
+    # TODO: remove both class finders after formtastic 4 (where it will be default)
+    self.input_class_finder = ::Formtastic::InputClassFinder
+    self.action_class_finder = ::Formtastic::ActionClassFinder
+
+    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
+      template.content_tag(:li, li_content, li_attrs)
+    end
+
+    attr_accessor :already_in_an_inputs_block
+
+    def assoc_heading(assoc)
+      object.class.reflect_on_association(assoc).klass.model_name.
+        human(count: ::ActiveAdmin::Helpers::I18n::PLURAL_MANY_COUNT)
+    end
+
+    def has_many(assoc, options = {}, &block)
+      # remove options that should not render as attributes
+      custom_settings = :new_record, :allow_destroy, :heading, :sortable, :sortable_start
+      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(' ')
+      sortable_column = builder_options[:sortable]
+      sortable_start  = builder_options.fetch(:sortable_start, 0)
+
+      if sortable_column
+        options[:for] = [assoc, sorted_children(assoc, sortable_column)]
+      end
+
+      html = "".html_safe
+      unless builder_options.key?(:heading) && !builder_options[:heading]
+        html << template.content_tag(:h3) do
+          builder_options[:heading] || assoc_heading(assoc)
+        end
+      end
+
+      html << template.capture do
+        contents = "".html_safe
+        form_block = proc do |has_many_form|
+          index    = parent_child_index options[:parent] if options[:parent]
+          block.call has_many_form, index
+          template.concat has_many_actions(has_many_form, builder_options, "".html_safe)
+        end
+        
+        template.assign(has_many_block: true)
+        contents = without_wrapper { inputs(options, &form_block) } || "".html_safe
+
+        if builder_options[:new_record]
+          contents << js_for_has_many(assoc, form_block, template, builder_options[:new_record], options[:class])
+        else
+          contents
+        end
+      end
+
+      tag = @already_in_an_inputs_block ? :li : :div
+      html = template.content_tag(tag, html, class: "has_many_container #{assoc}", 'data-sortable' => sortable_column, 'data-sortable-start' => sortable_start)
+      template.concat(html) if template.output_buffer
+      html
+    end
+
+    protected
+
+    def has_many_actions(has_many_form, builder_options, contents)
+      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
+          "MOVE"
+        end
+      end
+
+      contents
+    end
+
+    def sorted_children(assoc, column)
+      object.public_send(assoc).sort_by do |o|
+        attribute = o.public_send column
+        [attribute.nil? ? Float::INFINITY : attribute, o.id || Float::INFINITY]
+      end
+    end
+
+    private
+
+    def without_wrapper
+      is_being_wrapped = @already_in_an_inputs_block
+      @already_in_an_inputs_block = false
+
+      html = 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.underscore.upcase.gsub(/\//, '_')}_RECORD"
+      opts = {
+        for: [assoc, assoc_reflection.klass.new],
+        class: class_string,
+        for_options: { child_index: placeholder }
+      }
+      html = template.capture{ 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/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/generators/boilerplate.rb

@@ -0,0 +1,37 @@
+module ActiveAdmin
+  module Generators
+    class Boilerplate
+      def initialize(class_name)
+        @class_name = class_name
+      end
+
+      def attributes
+        @class_name.constantize.new.attributes.keys
+      end
+
+      def rows
+        attributes.map { |a| row(a) }.join("\n")
+      end
+
+      def row(name)
+        "#   row :#{name.gsub(/_id$/, '')}"
+      end
+
+      def columns
+        attributes.map { |a| column(a) }.join("\n")
+      end
+
+      def column(name)
+        "#   column :#{name.gsub(/_id$/, '')}"
+      end
+
+      def filters
+        attributes.map { |a| filter(a) }.join("\n")
+      end
+
+      def filter(name)
+        "# filter :#{name.gsub(/_id$/, '')}"
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/helpers/collection.rb

@@ -0,0 +1,17 @@
+module ActiveAdmin
+  module Helpers
+    module Collection
+      # 1. removes `select` and `order` to prevent invalid SQL
+      # 2. correctly handles the Hash returned when `group by` is used
+      def collection_size(c = collection)
+        c = c.except :select, :order
+
+        c.group_values.present? ? c.count.count : c.count
+      end
+
+      def collection_is_empty?(c = collection)
+        collection_size(c) == 0
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/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/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/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.public_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/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/helpers/routes/url_helpers.rb

@@ -0,0 +1,15 @@
+module ActiveAdmin
+  module Helpers
+    module Routes
+      module UrlHelpers
+        include Rails.application.routes.url_helpers
+      end
+
+      extend UrlHelpers
+
+      def self.default_url_options
+        Rails.application.routes.default_url_options || {}
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/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.public_send scope.scope_method
+      elsif scope.scope_block
+        instance_exec chain, &scope.scope_block
+      else
+        chain
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/helpers/settings.rb

@@ -0,0 +1,115 @@
+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
+
+        define_method "#{name}?" do
+          value = public_send(name)
+          if value.is_a? Array
+            value.any?
+          else
+            value.present?
+          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

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/inputs.rb

@@ -0,0 +1,20 @@
+module ActiveAdmin
+  module Inputs
+    extend ActiveSupport::Autoload
+
+    autoload :DatepickerInput
+
+    module Filters
+      extend ActiveSupport::Autoload
+
+      autoload :Base
+      autoload :StringInput
+      autoload :DatePickerInput
+      autoload :DateRangeInput
+      autoload :NumericInput
+      autoload :SelectInput
+      autoload :CheckBoxesInput
+      autoload :BooleanInput
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/inputs/datepicker_input.rb

@@ -0,0 +1,20 @@
+module ActiveAdmin
+  module Inputs
+    class DatepickerInput < ::Formtastic::Inputs::StringInput
+      def input_html_options
+        super.tap do |options|
+          options[:class] = [options[:class], "datepicker"].compact.join(' ')
+          options[:data] ||= {}
+          options[:data].merge! datepicker_options
+        end
+      end
+
+      private
+        def datepicker_options
+          options = self.options.fetch(:datepicker_options, {})
+          options = Hash[options.map{ |k, v| [k.to_s.camelcase(:lower), v] }]
+          { datepicker_options: options }
+        end
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/inputs/filters/base.rb

@@ -0,0 +1,42 @@
+module ActiveAdmin
+  module Inputs
+    module Filters
+      module Base
+        include ::Formtastic::Inputs::Base
+        include ::ActiveAdmin::Filters::FormtasticAddons
+
+        extend ::ActiveSupport::Autoload
+        autoload :SearchMethodSelect
+
+        def input_wrapping(&block)
+          template.content_tag :div, template.capture(&block), wrapper_html_options
+        end
+
+        def required?
+          false
+        end
+
+        # Can pass proc to filter label option
+        def label_from_options
+          res = super
+          res = res.call if res.is_a? Proc
+          res
+        end
+
+        def wrapper_html_options
+          { class: "filter_form_field filter_#{as}" }
+        end
+
+        # Override the standard finder to accept a proc
+        def collection_from_options
+          if options[:collection].is_a?(Proc)
+            template.instance_exec(&options[:collection])
+          else
+            super
+          end
+        end
+
+      end
+    end
+  end
+end