ultra-quick-hub 0.0.1

data/activeadmin-3.5.1/lib/active_admin/filters/dsl.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+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(*attributes)
+        config.remove_filter(*attributes)
+      end
+
+      # For docs, please see ActiveAdmin::Filters::ResourceExtension#preserve_default_filters!
+      def preserve_default_filters!
+        config.preserve_default_filters!
+      end
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/filters/forms.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+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
+      self.input_namespaces = [::Object, ::ActiveAdmin::Inputs::Filters, ::ActiveAdmin::Inputs, ::Formtastic::Inputs]
+
+      # TODO: remove input class finders after formtastic 4 (where it will be default)
+      self.input_class_finder = ::Formtastic::InputClassFinder
+
+      def filter(method, options = {})
+        if method.present? && options[:as] ||= default_input_type(method)
+          template.concat 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 =~ /_(eq|cont|start|end)\z/
+          :string
+        elsif klass._ransackers.key?(method.to_s)
+          klass._ransackers[method.to_s].type
+        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, :citext
+            :string
+          when :integer, :float, :decimal
+            :numeric
+          when :boolean
+            :boolean
+          end
+        end
+      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|
+            next if opts.key?(:if) && !call_method_or_proc_on(self, opts[:if])
+            next if opts.key?(:unless) && call_method_or_proc_on(self, opts[:unless])
+
+            filter_opts = opts.except(:if, :unless)
+            filter_opts[:input_html] = instance_exec(&filter_opts[:input_html]) if filter_opts[:input_html].is_a?(Proc)
+
+            f.filter attribute, filter_opts
+          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: except_hidden_fields)
+          end
+
+          f.template.concat buttons
+        end
+      end
+
+      private
+
+      def except_hidden_fields
+        [:q, :page]
+      end
+    end
+
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/filters/formtastic_addons.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+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 klass.ransackable_associations.include?(method.to_s) && reflection && reflection.options[:through]
+          reflection.through_reflection.klass.ransackable_attributes.include? reflection.foreign_key
+        else
+          false
+        end
+      end
+
+      def seems_searchable?
+        column_for(method).nil? && (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 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/activeadmin-3.5.1/lib/active_admin/filters/resource_extension.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module Filters
+
+    class Disabled < RuntimeError
+      def initialize(action)
+        super "Cannot #{action} 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, "remove" 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, "add" 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)
+
+          # Check high-arity associations for filterable columns
+          max = namespace.maximum_association_filter_arity
+          if max != :unlimited
+            high_arity, low_arity = not_poly.partition do |r|
+              r.klass.reorder(nil).limit(max + 1).count > max
+            end
+
+            # Remove high-arity associations with no searchable column
+            high_arity = high_arity.select(&method(:searchable_column_for))
+
+            high_arity = high_arity.map { |r| r.name.to_s + "_" + searchable_column_for(r) + namespace.filter_method_for_large_association }
+
+            filters = poly.map(&:foreign_type) + low_arity.map(&:name) + high_arity
+          end
+
+          filters.map &:to_sym
+        else
+          []
+        end
+      end
+
+      def search_columns
+        @search_columns ||= namespace.filter_columns_for_large_association.map(&:to_s)
+      end
+
+      def searchable_column_for(relation)
+        relation.klass.column_names.find { |name| search_columns.include?(name) }
+      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/activeadmin-3.5.1/lib/active_admin/filters.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+require "active_admin/filters/dsl"
+require "active_admin/filters/resource_extension"
+require "active_admin/filters/formtastic_addons"
+require "active_admin/filters/forms"
+require "active_admin/helpers/optional_display"
+require "active_admin/filters/active_sidebar"
+
+# Add our Extensions
+ActiveAdmin::ResourceDSL.send :include, ActiveAdmin::Filters::DSL
+ActiveAdmin::Resource.send :include, ActiveAdmin::Filters::ResourceExtension
+ActiveAdmin::ViewHelpers.send :include, ActiveAdmin::Filters::ViewHelper

data/activeadmin-3.5.1/lib/active_admin/form_builder.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+# 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, :remove_record
+
+    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)
+      @remove_record = options.delete(:remove_record)
+      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(&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
+          remove_text = remove_record.is_a?(String) ? remove_record : I18n.t("active_admin.has_many_remove")
+          template.link_to remove_text, "#", 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(&form_block)
+      assoc_name = assoc_klass.model_name
+      placeholder = "NEW_#{assoc_name.to_s.underscore.upcase.tr('/', '_')}_RECORD"
+      opts = options.merge(
+        for: [assoc, assoc_klass.new],
+        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/activeadmin-3.5.1/lib/active_admin/generators/boilerplate.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+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 assignable_attributes
+        attributes - %w(id created_at updated_at)
+      end
+
+      def permit_params
+        assignable_attributes.map { |a| a.to_sym.inspect }.join(", ")
+      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
+        assignable_attributes.map { |a| form_input(a) }.join("\n  ")
+      end
+
+      def form_input(name)
+        "#     f.input :#{name.gsub(/_id$/, '')}"
+      end
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/helpers/collection.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+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)
+        return c.count if c.is_a?(Array)
+        return c.length if c.limit_value
+
+        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/activeadmin-3.5.1/lib/active_admin/helpers/i18n.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module Helpers
+    module I18n
+      PLURAL_MANY_COUNT = 2.1
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/helpers/optional_display.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+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