activeadmin_addons 1.1.2 → 1.2.0

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

@@ -1,141 +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 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.3.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/generators/boilerplate.rb

@@ -1,37 +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
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-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.3.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/helpers/scope_chain.rb

@@ -1,23 +0,0 @@
-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.3.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/helpers/settings.rb

@@ -1,115 +0,0 @@
-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.3.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/inputs.rb

@@ -1,20 +0,0 @@
-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.3.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/inputs/datepicker_input.rb

@@ -1,20 +0,0 @@
-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.3.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/inputs/filters/base.rb

@@ -1,42 +0,0 @@
-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

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

@@ -1,75 +0,0 @@
-# This is a common set of Formtastic overrides needed to build a filter form
-# that lets you select from a set of search methods for a given attribute.
-#
-# Your class must declare available filters for this module to work.
-# Those filters must be recognizable by Ransack. For example:
-#
-#   class FilterNumericInput < ::Formtastic::Inputs::NumberInput
-#     include FilterBase
-#     include FilterBase::SearchMethodSelect
-#
-#     filter :equals, :greater_than, :less_than
-#   end
-#
-module ActiveAdmin
-  module Inputs
-    module Filters
-      module Base
-        module SearchMethodSelect
-
-          def self.included(base)
-            base.extend ClassMethods
-          end
-
-          module ClassMethods
-            attr_reader :filters
-
-            def filter(*filters)
-              (@filters ||= []).push *filters
-            end
-          end
-
-          def wrapper_html_options
-            opts = super
-            (opts[:class] ||= '') << ' select_and_search' unless seems_searchable?
-            opts
-          end
-
-          def to_html
-            input_wrapping do
-              label_html  << # your label
-              select_html << # the dropdown that holds the available search methods
-              input_html     # your input field
-            end
-          end
-
-          def input_html
-            builder.text_field current_filter, input_html_options
-          end
-
-          def select_html
-            template.select_tag '', template.options_for_select(filter_options, current_filter)
-          end
-
-          def filters
-            options[:filters] || self.class.filters
-          end
-
-          def current_filter
-            @current_filter ||= begin
-              methods = filters.map{ |f| "#{method}_#{f}" }
-              methods.detect{ |m| @object.public_send m } || methods.first
-            end
-          end
-
-          def filter_options
-            filters.collect do |filter|
-              [I18n.t("active_admin.filters.predicates.#{filter}"), "#{method}_#{filter}"]
-            end
-          end
-
-        end
-      end
-    end
-  end
-end