activeadmin_addons 1.4.0 → 1.8.2

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/filters/formtastic_addons.rb

@@ -1,79 +0,0 @@
-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.public_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.reflect_on_all_associations.select{ |r| r.macro == :belongs_to && r.options[:polymorphic] }
-          .map(&:foreign_type).include? method.to_s
-      end
-
-      #
-      # These help figure out whether the given method or association will be recognized by Ransack.
-      #
-
-      def searchable_has_many_through?
-        if reflection && reflection.options[:through]
-          reflection.through_reflection.klass.ransackable_attributes.include? reflection.foreign_key
-        else
-          false
-        end
-      end
-
-      def seems_searchable?
-        has_predicate? || scope?
-      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_from_string(method.to_s)
-      end
-
-      # Ransack lets you define custom search methods, called ransackers.
-      def ransacker?
-        klass._ransackers.key? method.to_s
-      end
-
-      # Ransack supports exposing selected scopes on your model for advanced searches.
-      def scope?
-        context = Ransack::Context.for klass
-        context.respond_to?(:ransackable_scope?) && context.ransackable_scope?(method.to_s, klass)
-      end
-
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/filters/resource_extension.rb

@@ -1,155 +0,0 @@
-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
-        add_search_status_sidebar_section
-      end
-
-      # Returns the filters for this resource. If filters are not enabled,
-      # it will always return an empty hash.
-      #
-      # @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
-
-      # Setter to enable/disable showing current filters on this resource.
-      #
-      # Set to `nil` to inherit the setting from the namespace
-      def current_filters=(bool)
-        @current_filters_enabled = bool
-      end
-
-      # @return [Boolean] If filters are enabled for this resource
-      def filters_enabled?
-        @filters_enabled.nil? ? namespace.filters : @filters_enabled
-      end
-
-      # @return [Boolean] If show current filters are enabled for this resource
-      def current_filters_enabled?
-        @current_filters_enabled.nil? ? namespace.current_filters : @current_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] attributes The attributes 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
-        result = []
-        result.concat default_association_filters if namespace.include_default_association_filters
-        result.concat content_columns
-        result.concat custom_ransack_filters
-        result
-      end
-
-      def custom_ransack_filters
-        if resource_class.respond_to?(:_ransackers)
-          resource_class._ransackers.keys.map(&:to_sym)
-        else
-          []
-        end
-      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
-
-      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
-
-      def add_search_status_sidebar_section
-        self.sidebar_sections << ActiveAdmin::Filters::ActiveSidebar.new
-      end
-
-    end
-
-  end
-end

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

@@ -1,182 +0,0 @@
-# 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 has_many(assoc, options = {}, &block)
-      HasManyBuilder.new(self, assoc, options).render(&block)
-    end
-  end
-
-  # Decorates a FormBuilder with the additional attributes and methods
-  # to build a has_many block.  Nested has_many blocks are handled by
-  # nested decorators.
-  class HasManyBuilder < SimpleDelegator
-    attr_reader :assoc
-    attr_reader :options
-    attr_reader :heading, :sortable_column, :sortable_start
-    attr_reader :new_record, :destroy_option
-
-    def initialize(has_many_form, assoc, options)
-      super has_many_form
-      @assoc = assoc
-      @options = extract_custom_settings!(options.dup)
-      @options.reverse_merge!(for: assoc)
-      @options[:class] = [options[:class], "inputs has_many_fields"].compact.join(' ')
-
-      if sortable_column
-        @options[:for] = [assoc, sorted_children(sortable_column)]
-      end
-    end
-
-    def render(&block)
-      html = "".html_safe
-      html << template.content_tag(:h3) { heading } if heading.present?
-      html << template.capture { content_has_many(&block) }
-      html = wrap_div_or_li(html)
-      template.concat(html) if template.output_buffer
-      html
-    end
-
-    protected
-
-    # remove options that should not render as attributes
-    def extract_custom_settings!(options)
-      @heading = options.key?(:heading) ? options.delete(:heading) : default_heading
-      @sortable_column = options.delete(:sortable)
-      @sortable_start  = options.delete(:sortable_start) || 0
-      @new_record = options.key?(:new_record) ? options.delete(:new_record) : true
-      @destroy_option = options.delete(:allow_destroy)
-      options
-    end
-
-    def default_heading
-      assoc_klass.model_name.
-        human(count: ::ActiveAdmin::Helpers::I18n::PLURAL_MANY_COUNT)
-    end
-
-    def assoc_klass
-      @assoc_klass ||= __getobj__.object.class.reflect_on_association(assoc).klass
-    end
-
-    def content_has_many(&block)
-      form_block = proc do |form_builder|
-        render_has_many_form(form_builder, options[:parent], &block)
-      end
-
-      template.assigns[:has_many_block] = true
-      contents = without_wrapper { inputs(options, &form_block) }
-      contents ||= "".html_safe
-
-      js = new_record ? js_for_has_many(options[:class], &form_block) : ''
-      contents << js
-    end
-
-    # Renders the Formtastic inputs then appends ActiveAdmin delete and sort actions.
-    def render_has_many_form(form_builder, parent, &block)
-      index = parent && form_builder.send(:parent_child_index, parent)
-      template.concat template.capture { yield(form_builder, index) }
-      template.concat has_many_actions(form_builder, "".html_safe)
-    end
-
-    def has_many_actions(form_builder, contents)
-      if form_builder.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 allow_destroy?(form_builder.object)
-        form_builder.input(:_destroy, as: :boolean,
-                            wrapper_html: {class: 'has_many_delete'},
-                            label: I18n.t('active_admin.has_many_delete'))
-      end
-
-      if sortable_column
-        form_builder.input sortable_column, as: :hidden
-
-        contents << template.content_tag(:li, class: 'handle') do
-          I18n.t('active_admin.move')
-        end
-      end
-
-      contents
-    end
-
-    def allow_destroy?(form_object)
-      !! case destroy_option
-         when Symbol, String
-           form_object.public_send destroy_option
-         when Proc
-           destroy_option.call form_object
-         else
-           destroy_option
-         end
-    end
-
-    def sorted_children(column)
-      __getobj__.object.public_send(assoc).sort_by do |o|
-        attribute = o.public_send column
-        [attribute.nil? ? Float::INFINITY : attribute, o.id || Float::INFINITY]
-      end
-    end
-
-    def without_wrapper
-      is_being_wrapped = already_in_an_inputs_block
-      self.already_in_an_inputs_block = false
-
-      html = yield
-
-      self.already_in_an_inputs_block = is_being_wrapped
-      html
-    end
-
-    # Capture the ADD JS
-    def js_for_has_many(class_string, &form_block)
-      assoc_name       = assoc_klass.model_name
-      placeholder      = "NEW_#{assoc_name.to_s.underscore.upcase.gsub(/\//, '_')}_RECORD"
-      opts = {
-        for: [assoc, assoc_klass.new],
-        class: class_string,
-        for_options: { child_index: placeholder }
-      }
-      html = template.capture{ __getobj__.send(: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
-
-    def wrap_div_or_li(html)
-      template.content_tag(already_in_an_inputs_block ? :li : :div,
-                           html,
-                           class: "has_many_container #{assoc}",
-                           'data-sortable' => sortable_column,
-                           'data-sortable-start' => sortable_start)
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/generators/boilerplate.rb

@@ -1,45 +0,0 @@
-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
-
-      def form_inputs
-        attributes.reject{|a| %w(id created_at updated_at).include? a}.map{ |a| form_input(a) }.join("\n")
-      end
-
-      def form_input(name)
-        "#     f.input :#{name.gsub(/_id$/, '')}"
-      end
-    end
-  end
-end