ultra-quick-hub 0.0.1

data/activeadmin-3.5.1/lib/active_admin/helpers/routes/url_helpers.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+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/activeadmin-3.5.1/lib/active_admin/helpers/scope_chain.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module ScopeChain
+    private
+    # 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/activeadmin-3.5.1/lib/active_admin/inputs/datepicker_input.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+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
+
+      # Can pass proc to filter label option
+      def label_from_options
+        res = super
+        res = res.call if res.is_a? Proc
+        res
+      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/activeadmin-3.5.1/lib/active_admin/inputs/filters/base/search_method_select.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+# 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 NumericInput < ::Formtastic::Inputs::NumberInput
+#     include Base
+#     include Base::SearchMethodSelect
+#
+#     filter :eq, :gt, :lt
+#   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("ransack.predicates.#{filter}").capitalize, "#{method}_#{filter}"]
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/inputs/filters/base.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+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
+          opts = super
+          (opts[:class] ||= "") << " filter_form_field filter_#{as}"
+          opts
+        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/activeadmin-3.5.1/lib/active_admin/inputs/filters/boolean_input.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module Inputs
+    module Filters
+      class BooleanInput < ::Formtastic::Inputs::SelectInput
+        include Base
+
+        def input_name
+          return method if seems_searchable?
+
+          "#{method}_eq"
+        end
+
+        def input_html_options_name
+          "#{object_name}[#{input_name}]" # was "#{object_name}[#{association_primary_key}]"
+        end
+
+        # Provide the AA translation to the blank input field.
+        def include_blank
+          I18n.t "active_admin.any" if super
+        end
+      end
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/inputs/filters/check_boxes_input.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module Inputs
+    module Filters
+      class CheckBoxesInput < ::Formtastic::Inputs::CheckBoxesInput
+        include Base
+
+        def input_name
+          "#{object_name}[#{searchable_method_name}_in][]"
+        end
+
+        def selected_values
+          @object.public_send("#{searchable_method_name}_in") || []
+        end
+
+        def searchable_method_name
+          if searchable_has_many_through?
+            "#{reflection.through_reflection.name}_#{reflection.foreign_key}"
+          else
+            association_primary_key || method
+          end
+        end
+
+        # Add whitespace before label
+        def choice_label(choice)
+          " " + super
+        end
+
+        # Don't wrap in UL tag
+        def choices_group_wrapping(&block)
+          template.capture(&block)
+        end
+
+        # Don't wrap in LI tag
+        def choice_wrapping(html_options, &block)
+          template.capture(&block)
+        end
+
+        # Don't render hidden fields
+        def hidden_field_for_all
+          ""
+        end
+
+        # Don't render hidden fields
+        def hidden_fields?
+          false
+        end
+      end
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/inputs/filters/date_picker_input.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module Inputs
+    module Filters
+      class DatePickerInput < ::Formtastic::Inputs::DatePickerInput
+        include Base
+
+        def input_html_options
+          super.merge(class: "datepicker")
+        end
+      end
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/inputs/filters/date_range_input.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module Inputs
+    module Filters
+      class DateRangeInput < ::Formtastic::Inputs::StringInput
+        include Base
+
+        def to_html
+          input_wrapping do
+            [ label_html,
+              builder.text_field(gt_input_name, input_html_options_for(gt_input_name, gt_input_placeholder)),
+              builder.text_field(lt_input_name, input_html_options_for(lt_input_name, lt_input_placeholder)),
+            ].join("\n").html_safe
+          end
+        end
+
+        def gt_input_name
+          "#{method}_gteq"
+        end
+        alias :input_name :gt_input_name
+
+        def lt_input_name
+          "#{method}_lteq"
+        end
+
+        def input_html_options
+          { size: 12,
+            class: "datepicker",
+            maxlength: 10 }.merge(options[:input_html] || {})
+        end
+
+        def input_html_options_for(input_name, placeholder)
+          current_value = begin
+                            #cast value to date object before rendering input
+                            @object.public_send(input_name).to_s.to_date
+                          rescue
+                            nil
+                          end
+          { placeholder: placeholder,
+            value: current_value ? current_value.strftime("%Y-%m-%d") : "" }.merge(input_html_options)
+        end
+
+        def gt_input_placeholder
+          I18n.t("active_admin.filters.predicates.from")
+        end
+
+        def lt_input_placeholder
+          I18n.t("active_admin.filters.predicates.to")
+        end
+      end
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/inputs/filters/numeric_input.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module Inputs
+    module Filters
+      class NumericInput < ::Formtastic::Inputs::NumberInput
+        include Base
+        include Base::SearchMethodSelect
+
+        filter :eq, :gt, :lt
+      end
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/inputs/filters/select_input.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module Inputs
+    module Filters
+      class SelectInput < ::Formtastic::Inputs::SelectInput
+        include Base
+
+        def input_name
+          return method if seems_searchable?
+
+          searchable_method_name + (multiple? ? "_in" : "_eq")
+        end
+
+        def searchable_method_name
+          if searchable_has_many_through?
+            "#{reflection.through_reflection.name}_#{reflection.foreign_key}"
+          else
+            reflection_searchable? ? "#{method}_#{reflection.association_primary_key}" : method.to_s
+          end
+        end
+
+        # Provide the AA translation to the blank input field.
+        def include_blank
+          I18n.t "active_admin.any" if super
+        end
+
+        def input_html_options_name
+          "#{object_name}[#{input_name}]" # was "#{object_name}[#{association_primary_key}]"
+        end
+
+        # Would normally return true for has_many and HABTM, which would subsequently
+        # cause the select field to be multi-select instead of a dropdown.
+        def multiple_by_association?
+          false
+        end
+
+        # Provides an efficient default lookup query if the attribute is a DB column.
+        def collection
+          if !options[:collection] && column
+            pluck_column
+          else
+            super
+          end
+        rescue ActiveRecord::QueryCanceled => error
+          raise ActiveRecord::QueryCanceled.new "#{error.message.strip} while querying the values for the ActiveAdmin :#{method} filter"
+        end
+
+        def pluck_column
+          klass.reorder("#{method} asc").distinct.pluck method
+        end
+
+        def reflection_searchable?
+          reflection && !reflection.polymorphic?
+        end
+
+      end
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/inputs/filters/string_input.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module Inputs
+    module Filters
+      class StringInput < ::Formtastic::Inputs::StringInput
+        include Base
+        include Base::SearchMethodSelect
+
+        filter :cont, :eq, :start, :end
+
+        # If the filter method includes a search condition, build a normal string search field.
+        # Else, build a search field with a companion dropdown to choose a search condition from.
+        def to_html
+          if seems_searchable?
+            input_wrapping do
+              label_html <<
+              builder.text_field(method, input_html_options)
+            end
+          else
+            super # SearchMethodSelect#to_html
+          end
+        end
+
+      end
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/inputs/filters/text_input.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module Inputs
+    module Filters
+      class TextInput < ::Formtastic::Inputs::TextInput
+        include Base
+        include Base::SearchMethodSelect
+
+        def input_html_options
+          {
+            cols: builder.default_text_area_width,
+            rows: builder.default_text_area_height
+          }.merge(super)
+        end
+
+        def to_html
+          input_wrapping do
+            label_html <<
+            builder.text_area(method, input_html_options)
+          end
+        end
+
+      end
+    end
+  end
+end

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

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

data/activeadmin-3.5.1/lib/active_admin/localizers/resource_localizer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module Localizers
+    class ResourceLocalizer
+      class << self
+        def from_resource(resource_config)
+          new(resource_config.resource_name.i18n_key, resource_config.resource_label)
+        end
+
+        def translate(key, options)
+          new(options.delete(:model_name), options.delete(:model)).translate(key, options)
+        end
+        alias_method :t, :translate
+      end
+
+      def initialize(model_name, model = nil)
+        @model_name = model_name
+        @model = model || model_name.to_s.titleize
+      end
+
+      def translate(key, options = {})
+        scope = options.delete(:scope)
+        specific_key = array_to_key("resources", @model_name, scope, key)
+        defaults = [array_to_key(scope, key), key.to_s.titleize]
+        ::I18n.t specific_key, **options.reverse_merge(model: @model, default: defaults, scope: "active_admin")
+      end
+      alias_method :t, :translate
+
+      protected
+
+      def array_to_key(*arr)
+        arr.flatten.compact.join(".").to_sym
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+require "active_admin/localizers/resource_localizer"
+
+module ActiveAdmin
+  module Localizers
+    class << self
+      def resource(active_admin_config)
+        ResourceLocalizer.from_resource(active_admin_config)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+module ActiveAdmin
+
+  # Each Namespace builds up it's own menu as the global navigation
+  #
+  # To build a new menu:
+  #
+  #   menu = Menu.new do |m|
+  #     m.add label: 'Dashboard', url: '/'
+  #     m.add label: 'Users',     url: '/users'
+  #   end
+  #
+  # If you're interested in configuring a menu item, take a look at the
+  # options available in `ActiveAdmin::MenuItem`
+  #
+  class Menu
+
+    def initialize
+      super # MenuNode
+      yield(self) if block_given?
+    end
+
+    module MenuNode
+      def initialize
+        @children = {}
+      end
+
+      def [](id)
+        @children[normalize_id(id)]
+      end
+
+      def []=(id, child)
+        @children[normalize_id(id)] = child
+      end
+
+      # Recursively builds any given menu items. There are two syntaxes supported,
+      # as shown in the below examples. Both create an identical menu structure.
+      #
+      # Example 1:
+      #   menu = Menu.new
+      #   menu.add label: 'Dashboard' do |dash|
+      #     dash.add label: 'My Child Dashboard'
+      #   end
+      #
+      # Example 2:
+      #   menu = Menu.new
+      #   menu.add label:  'Dashboard'
+      #   menu.add parent: 'Dashboard', label: 'My Child Dashboard'
+      #
+      def add(options)
+        options = options.dup # Make sure parameter is not modified
+        parent_chain = Array.wrap(options.delete(:parent))
+
+        item = if parent = parent_chain.shift
+                 options[:parent] = parent_chain if parent_chain.any?
+                 (self[parent] || add(label: parent)).add options
+               else
+                 _add options.merge parent: self
+               end
+
+        yield(item) if block_given?
+
+        item
+      end
+
+      # Whether any children match the given item.
+      def include?(item)
+        @children.values.include?(item) || @children.values.any? { |child| child.include?(item) }
+      end
+
+      # Used in the UI to visually distinguish which menu item is selected.
+      def current?(item)
+        self == item || include?(item)
+      end
+
+      def items
+        @children.values
+      end
+
+      attr_reader :children
+      private
+      attr_writer :children
+
+      # The method that actually adds new menu items. Called by the public method.
+      # If this ID is already taken, transfer the children of the existing item to the new item.
+      def _add(options)
+        item = ActiveAdmin::MenuItem.new(options)
+        item.send :children=, self[item.id].children if self[item.id]
+        self[item.id] = item
+      end
+
+      def normalize_id(id)
+        case id
+        when String, Symbol, ActiveModel::Name
+          id.to_s.downcase.tr " ", "_"
+        when ActiveAdmin::Resource::Name
+          id.param_key
+        else
+          raise TypeError, "#{id.class} isn't supported as a Menu ID"
+        end
+      end
+    end
+
+    include MenuNode
+
+  end
+end