activeadmin_addons 1.1.2 → 1.2.0

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/dsl.rb

@@ -0,0 +1,160 @@
+module ActiveAdmin
+
+  # The Active Admin DSL. This class is where all the registration blocks
+  # are evaluated. This is the central place for the API given to
+  # users of Active Admin.
+  #
+  class DSL
+
+    def initialize(config)
+      @config = config
+    end
+
+    # Runs the registration block inside this object
+    def run_registration_block(&block)
+      instance_exec &block if block_given?
+    end
+
+    # The instance of ActiveAdmin::Resource that's being registered
+    # currently. You can use this within your registration blocks to
+    # modify options:
+    #
+    # eg:
+    #
+    #   ActiveAdmin.register Post do
+    #     config.sort_order = "id_desc"
+    #   end
+    #
+    def config
+      @config
+    end
+
+    # Include a module with this resource. The modules's `included` method
+    # is called with the instance of the `ActiveAdmin::DSL` passed into it.
+    #
+    # eg:
+    #
+    #   module HelpSidebar
+    #
+    #     def self.included(dsl)
+    #       dsl.sidebar "Help" do
+    #         "Call us for Help"
+    #       end
+    #     end
+    #
+    #   end
+    #
+    #   ActiveAdmin.register Post do
+    #     include HelpSidebar
+    #   end
+    #
+    # @param [Module] mod A module to include
+    #
+    # @return [Nil]
+    def include(mod)
+      mod.included(self)
+    end
+
+    # Returns the controller for this resource. If you pass a
+    # block, it will be evaluated in the controller.
+    #
+    # Example:
+    #
+    #   ActiveAdmin.register Post do
+    #
+    #     controller do
+    #       def some_method_on_controller
+    #         # Method gets added to Admin::PostsController
+    #       end
+    #     end
+    #
+    #   end
+    #
+    def controller(&block)
+      @config.controller.class_exec(&block) if block_given?
+      @config.controller
+    end
+
+    # Add a new action item to the resource
+    #
+    # @param [Symbol] name
+    # @param [Hash] options valid keys include:
+    #                 :only:  A single or array of controller actions to display
+    #                         this action item on.
+    #                 :except: A single or array of controller actions not to
+    #                          display this action item on.
+    def action_item(name, options = {}, &block)
+      config.add_action_item(name, options, &block)
+    end
+
+    # Add a new batch action item to the resource
+    # Provide a symbol/string to register the action, options, & block to execute on request
+    #
+    # To unregister an existing action, just provide the symbol & pass false as the second param
+    #
+    # @param [Symbol or String] title
+    # @param [Hash] options valid keys include:
+    # => :if is a proc that will be called to determine if the BatchAction should be displayed
+    # => :sort_order is used to sort the batch actions ascending
+    # => :confirm is a string which the user will have to accept in order to process the action
+    #
+    def batch_action(title, options = {}, &block)
+      # Create symbol & title information
+      if title.is_a? String
+        sym = title.titleize.tr(' ', '').underscore.to_sym
+      else
+        sym = title
+        title = sym.to_s.titleize
+      end
+
+      # Either add/remove the batch action
+      unless options == false
+        config.add_batch_action(sym, title, options, &block)
+      else
+        config.remove_batch_action sym
+      end
+    end
+
+    # Set the options that are available for the item that will be placed in the global
+    # navigation of the menu.
+    def menu(options = {})
+      config.menu_item_options = options
+    end
+
+    # Set the name of the navigation menu to display. This is mainly used in conjunction with the
+    # `#belongs_to` functionality.
+    #
+    # @param [Symbol] menu_name The name of the menu to display as the global navigation
+    #                 when viewing this resource. Defaults to a menu named `:default`.
+    #
+    # Pass a block returning the name of a menu you want rendered for the request, being
+    # executed in the context of the controller
+    #
+    def navigation_menu(menu_name = nil, &block)
+      config.navigation_menu_name = menu_name || block
+    end
+
+    # Rewrite breadcrumb links.
+    # Block will be executed inside controller.
+    # Block must return an array if you want to rewrite breadcrumb links.
+    #
+    # Example:
+    #   ActiveAdmin.register Post do
+    #
+    #     breadcrumb do
+    #       [
+    #         link_to('my piece', '/my/link/to/piece')
+    #       ]
+    #     end
+    #   end
+    #
+    def breadcrumb(&block)
+      config.breadcrumb = block
+    end
+
+    def sidebar(name, options = {}, &block)
+      config.sidebar_sections << ActiveAdmin::SidebarSection.new(name, options, &block)
+    end
+
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/dynamic_setting.rb

@@ -0,0 +1,38 @@
+module ActiveAdmin
+
+  class DynamicSetting
+    def self.build(setting, type)
+      (type ? klass(type) : self).new(setting)
+    end
+
+    def self.klass(type)
+      klass = "#{type.to_s.camelcase}Setting"
+      raise ArgumentError, "Unknown type: #{type}" unless ActiveAdmin.const_defined?(klass)
+      ActiveAdmin.const_get(klass)
+    end
+
+    def initialize(setting)
+      @setting = setting
+    end
+
+    def value(*_args)
+      @setting
+    end
+  end
+
+  # Many configuration options (Ex: site_title, title_image) could either be
+  # static (String), methods (Symbol) or procs (Proc). This wrapper takes care of
+  # returning the content when String or using instance_eval when Symbol or Proc.
+  #
+  class StringSymbolOrProcSetting < DynamicSetting
+    def value(context = self)
+      case @setting
+      when Symbol, Proc
+        context.instance_eval(&@setting)
+      else
+        @setting
+      end
+    end
+  end
+
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/dynamic_settings_node.rb

@@ -0,0 +1,28 @@
+require 'active_admin/dynamic_setting'
+require 'active_admin/settings_node'
+
+module ActiveAdmin
+
+  class DynamicSettingsNode < SettingsNode
+    class << self
+      def register(name, value, type = nil)
+        class_attribute "#{name}_setting"
+        add_reader(name)
+        add_writer(name, type)
+        send "#{name}=", value
+      end
+
+      def add_reader(name)
+        define_singleton_method(name) do |*args|
+          send("#{name}_setting").value(*args)
+        end
+      end
+
+      def add_writer(name, type)
+        define_singleton_method("#{name}=") do |value|
+          send("#{name}_setting=", DynamicSetting.build(value, type))
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/engine.rb

@@ -0,0 +1,21 @@
+module ActiveAdmin
+  class Engine < ::Rails::Engine
+    initializer "active_admin.load_app_path" do |app|
+      ActiveAdmin::Application.setting :app_path, app.root
+      ActiveAdmin::Application.setting :load_paths, [File.expand_path('app/admin', app.root)]
+    end
+
+    initializer "active_admin.precompile", group: :all do |app|
+      ActiveAdmin.application.stylesheets.each do |path, _|
+        app.config.assets.precompile << path
+      end
+      ActiveAdmin.application.javascripts.each do |path|
+        app.config.assets.precompile << path
+      end
+    end
+
+    initializer 'active_admin.routes' do
+      require 'active_admin/helpers/routes/url_helpers'
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/error.rb

@@ -0,0 +1,62 @@
+module ActiveAdmin
+  # Exception class to raise when there is an authorized access
+  # exception thrown. The exception has a few goodies that may
+  # be useful for capturing / recognizing security issues.
+  class AccessDenied < StandardError
+    attr_reader :user, :action, :subject
+
+    def initialize(user, action, subject = nil)
+      @user, @action, @subject = user, action, subject
+
+      super()
+    end
+
+    def message
+      I18n.t("active_admin.access_denied.message")
+    end
+  end
+
+  class Error < RuntimeError
+  end
+
+  class ErrorLoading < Error
+    # Locates the most recent file and line from the caught exception's backtrace.
+    def find_cause(folder, backtrace)
+      backtrace.grep(/\/(#{folder}\/.*\.rb):(\d+)/){ [$1, $2] }.first
+    end
+  end
+
+  class DatabaseHitDuringLoad < ErrorLoading
+    def initialize(exception)
+      file, line = find_cause(:app, exception.backtrace)
+
+      super "Your file, #{file} (line #{line}), caused a database error while Active Admin was loading. This " +
+            "is most common when your database is missing or doesn't have the latest migrations applied. To " +
+            "prevent this error, move the code to a place where it will only be run when a page is rendered. " +
+            "One solution can be, to wrap the query in a Proc. " +
+            "Original error message: #{exception.message}"
+    end
+
+    def self.capture
+      yield
+    rescue *database_error_classes => exception
+      raise new exception
+    end
+
+    private
+
+    def self.database_error_classes
+      @classes ||= []
+    end
+  end
+
+  class DependencyError < ErrorLoading
+  end
+
+  class NoMenuError < KeyError
+  end
+
+  class GeneratorError < Error
+  end
+
+end

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

@@ -0,0 +1,11 @@
+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/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/filters/active.rb

@@ -0,0 +1,29 @@
+require 'active_admin/filters/active_filter'
+
+module ActiveAdmin
+  module Filters
+
+    class Active
+      attr_accessor :filters, :resource
+
+      # Instantiate a `Active` object containing collection of current active filters
+
+      # @param resource [ActiveAdmin::Resource] current resource
+      # @param search [Ransack::Search] search object
+      #
+      # @see ActiveAdmin::ResourceController::DataAcces#apply_filtering
+      def initialize(resource, search)
+        @resource = resource
+        @filters = build_filters(search.conditions)
+      end
+
+      private
+
+      def build_filters(conditions)
+        conditions.map { |condition| ActiveFilter.new(resource, condition.dup) }
+      end
+
+    end
+
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/filters/active_filter.rb

@@ -0,0 +1,123 @@
+module ActiveAdmin
+  module Filters
+
+    class ActiveFilter
+      include ActiveAdmin::ViewHelpers
+
+      attr_reader :resource, :condition, :related_class
+
+      # Instantiate a `ActiveFilter`
+      #
+      # @param resource [ActiveAdmin::Resource] current resource
+      # @param condition [Ransack::Nodes::Condition] applied ransack condition
+      def initialize(resource, condition)
+        @resource = resource
+        @condition = condition
+        @related_class = find_class if find_class?
+      end
+
+      def values
+        condition_values = condition.values.map(&:value)
+        if related_class
+          related_class.where(related_primary_key => condition_values)
+        else
+          condition_values
+        end
+      end
+
+      def label
+        # TODO: to remind us to go back to the simpler str.downcase once we support ruby >= 2.4 only.
+        translated_predicate = predicate_name.mb_chars.downcase.to_s
+        if filter_label
+          "#{filter_label} #{translated_predicate}"
+        elsif related_class
+          "#{related_class_name} #{translated_predicate}"
+        else
+          "#{attribute_name} #{translated_predicate}"
+        end.strip
+      end
+
+      def predicate_name
+        I18n.t("active_admin.filters.predicates.#{condition.predicate.name}",
+               default: ransack_predicate_name)
+      end
+
+      def html_options
+        { class: "current_filter current_filter_#{condition.key}" }
+      end
+
+      private
+
+      def resource_class
+        resource.resource_class
+      end
+
+      def attribute_name
+        resource_class.human_attribute_name(name)
+      end
+
+      def related_class_name
+        return unless related_class
+
+        related_class.model_name.human
+      end
+
+      def filter_label
+        return unless filter
+
+        filter[:label]
+      end
+
+      #@return Ransack::Nodes::Attribute
+      def condition_attribute
+        condition.attributes[0]
+      end
+
+      def name
+        condition_attribute.attr_name
+      end
+
+      def ransack_predicate_name
+        Ransack::Translate.predicate(condition.predicate.name)
+      end
+
+      def find_class?
+        ['eq', 'in'].include? condition.predicate.arel_predicate
+      end
+
+      # detect related class for Ransack::Nodes::Attribute
+      def find_class
+        if condition_attribute.klass != resource_class && condition_attribute.klass.primary_key == name.to_s
+          condition_attribute.klass
+        elsif predicate_association
+          predicate_association.klass
+        end
+      end
+
+      def filter
+        resource.filters[name.to_sym]
+      end
+
+      def related_primary_key
+        if predicate_association
+          predicate_association.active_record_primary_key
+        elsif related_class
+          related_class.primary_key
+        end
+      end
+
+      def predicate_association
+        @predicate_association = find_predicate_association unless defined?(@predicate_association)
+        @predicate_association
+      end
+
+      private
+
+      def find_predicate_association
+        condition_attribute.klass.reflect_on_all_associations.
+          reject { |r| r.options[:polymorphic] }. #skip polymorphic
+          detect { |r| r.foreign_key.to_s == name.to_s }
+      end
+    end
+  end
+end