super-sharp-tool 0.0.1

data/activeadmin-3.5.1/lib/active_admin/resource_controller/decorators.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  class ResourceController < BaseController
+    module Decorators
+
+      protected
+
+      def apply_decorator(resource)
+        decorate? ? decorator_class.new(resource) : resource
+      end
+
+      def apply_collection_decorator(collection)
+        if decorate?
+          collection_decorator.decorate collection, with: decorator_class
+        else
+          collection
+        end
+      end
+
+      def self.undecorate(resource)
+        if resource.respond_to?(:decorated?) && resource.decorated?
+          resource.model
+        else
+          resource
+        end
+      end
+
+      private
+
+      def decorate?
+        case action_name
+        when "new", "edit", "create", "update"
+          form = active_admin_config.get_page_presenter :form
+          form && form.options[:decorate] && decorator_class.present?
+        else
+          decorator_class.present?
+        end
+      end
+
+      def decorator_class
+        active_admin_config.decorator_class
+      end
+
+      # When using Draper, we wrap the collection draper in a new class that
+      # correctly delegates methods that Active Admin depends on.
+      def collection_decorator
+        if decorator_class
+          Wrapper.wrap decorator_class
+        end
+      end
+
+      class Wrapper
+        @cache = {}
+
+        def self.wrap(decorator)
+          collection_decorator = find_collection_decorator(decorator)
+          name = "#{collection_decorator.name} of #{decorator} + ActiveAdmin"
+          @cache[name] ||= wrap! collection_decorator, name
+        end
+
+        def self.wrap!(parent, name)
+          ::Class.new parent do
+            delegate :reorder, :page, :current_page, :total_pages, :limit_value,
+                     :total_count, :offset, :to_key, :group_values,
+                     :except, :find_each, :ransack, to: :object
+
+            define_singleton_method(:name) { name }
+          end
+        end
+
+        def self.find_collection_decorator(decorator)
+          if decorator.respond_to?(:collection_decorator_class)
+            decorator.collection_decorator_class
+          else
+            CollectionDecorator
+          end
+        end
+      end
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/resource_controller/polymorphic_routes.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require "active_admin/resource"
+require "active_admin/resource/model"
+
+module ActiveAdmin
+  class ResourceController < BaseController
+    module PolymorphicRoutes
+      def polymorphic_url(record_or_hash_or_array, options = {})
+        super(map_named_resources_for(record_or_hash_or_array), options)
+      end
+
+      def polymorphic_path(record_or_hash_or_array, options = {})
+        super(map_named_resources_for(record_or_hash_or_array), options)
+      end
+
+      private
+
+      def map_named_resources_for(record_or_hash_or_array)
+        return record_or_hash_or_array unless record_or_hash_or_array.is_a?(Array)
+
+        record_or_hash_or_array.map { |record| to_named_resource(record) }
+      end
+
+      def to_named_resource(record)
+        if record.is_a?(resource_class)
+          return ActiveAdmin::Model.new(active_admin_config, record)
+        end
+
+        belongs_to_resource = active_admin_config.belongs_to_config.try(:resource)
+        if belongs_to_resource && record.is_a?(belongs_to_resource.resource_class)
+          return ActiveAdmin::Model.new(belongs_to_resource, record)
+        end
+
+        record
+      end
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/resource_controller/resource_class_methods.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  class ResourceController < BaseController
+    module ResourceClassMethods
+
+      # Override the default `resource_class` class and instance
+      # methods to only return the class defined in the instance
+      # of ActiveAdmin::Resource
+      def override_resource_class_methods!
+        class_exec do
+          def self.resource_class=(klass); end
+
+          def self.resource_class
+            @active_admin_config ? @active_admin_config.resource_class : nil
+          end
+
+          private
+
+          def resource_class
+            self.class.resource_class
+          end
+        end
+      end
+
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/resource_controller/scoping.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  class ResourceController < BaseController
+
+    # This module deals with scoping entire controllers to a relation
+    module Scoping
+      extend ActiveSupport::Concern
+
+      protected
+
+      # Override the default InheritedResource #begin_of_association_chain to allow
+      # the scope to be defined in the active admin configuration.
+      #
+      # If scope_to is a proc, we eval it, otherwise we call the method on the controller.
+      #
+      # Collection can be scoped conditionally with an :if or :unless proc.
+      def begin_of_association_chain
+        return nil unless active_admin_config.scope_to?(self)
+        MethodOrProcHelper.render_in_context(self, active_admin_config.scope_to_method)
+      end
+
+      # Overriding from InheritedResources::BaseHelpers
+      #
+      # Returns the method for the association chain when using
+      # the scope_to option
+      def method_for_association_chain
+        active_admin_config.scope_to_association_method || super
+      end
+
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/resource_controller/sidebars.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  class ResourceController < BaseController
+
+    module Sidebars
+
+      protected
+
+      def skip_sidebar!
+        @skip_sidebar = true
+      end
+
+      def skip_sidebar?
+        @skip_sidebar == true
+      end
+    end
+
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/resource_controller/streaming.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require "csv"
+
+module ActiveAdmin
+  class ResourceController < BaseController
+
+    # This module overrides CSV responses to allow large data downloads.
+    # Could be expanded to JSON and XML in the future.
+    #
+    module Streaming
+
+      def index
+        super do |format|
+          format.csv { stream_csv }
+          yield(format) if block_given?
+        end
+      end
+
+      protected
+
+      def stream_resource(&block)
+        headers["X-Accel-Buffering"] = "no"
+        headers["Cache-Control"] = "no-cache"
+        headers["Last-Modified"] = Time.current.httpdate
+
+        if ActiveAdmin.application.disable_streaming_in.include? Rails.env
+          self.response_body = block[String.new]
+        else
+          self.response_body = Enumerator.new &block
+        end
+      end
+
+      def csv_filename
+        "#{resource_collection_name.to_s.gsub('_', '-')}-#{Time.zone.now.to_date.to_s}.csv"
+      end
+
+      def stream_csv
+        headers["Content-Type"] = "text/csv; charset=utf-8" # In Rails 5 it's set to HTML??
+        headers["Content-Disposition"] = %{attachment; filename="#{csv_filename}"}
+        stream_resource &active_admin_config.csv_builder.method(:build).to_proc.curry[self]
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+require "active_admin/collection_decorator"
+require "active_admin/resource_controller/action_builder"
+require "active_admin/resource_controller/data_access"
+require "active_admin/resource_controller/decorators"
+require "active_admin/resource_controller/polymorphic_routes"
+require "active_admin/resource_controller/scoping"
+require "active_admin/resource_controller/streaming"
+require "active_admin/resource_controller/sidebars"
+require "active_admin/resource_controller/resource_class_methods"
+
+module ActiveAdmin
+  # All Resources Controller inherits from this controller.
+  # It implements actions and helpers for resources.
+  class ResourceController < BaseController
+    layout :determine_active_admin_layout
+
+    respond_to :html, :xml, :json
+    respond_to :csv, only: :index
+
+    include ActionBuilder
+    include Decorators
+    include DataAccess
+    include PolymorphicRoutes
+    include Scoping
+    include Streaming
+    include Sidebars
+    include ViewHelpers::DownloadFormatLinksHelper
+    extend ResourceClassMethods
+
+    def self.active_admin_config=(config)
+      if @active_admin_config = config
+        defaults resource_class: config.resource_class,
+                 route_prefix: config.route_prefix,
+                 instance_name: config.resource_name.singular
+      end
+    end
+
+    # Inherited Resources uses the `self.inherited(base)` hook to add
+    # in `self.resource_class`. To override it, we need to install
+    # our resource_class method each time we're inherited from.
+    def self.inherited(base)
+      super(base)
+      base.override_resource_class_methods!
+    end
+
+    private
+
+    # Returns the renderer class to use for the given action.
+    def renderer_for(action)
+      active_admin_namespace.view_factory["#{action}_page"]
+    end
+
+    helper_method :renderer_for
+
+    def restrict_format_access!
+      unless request.format.html?
+        presenter = active_admin_config.get_page_presenter(:index)
+        download_formats = (presenter || {}).fetch(:download_links, active_admin_config.namespace.download_links)
+        unless build_download_formats(download_formats).include?(request.format.symbol)
+          raise ActiveAdmin::AccessDenied.new(current_active_admin_user, :index)
+        end
+      end
+    end
+
+    before_action :restrict_format_access!, only: [:index, :show]
+  end
+end

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

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  # This is the class where all the register blocks are evaluated.
+  class ResourceDSL < DSL
+
+    private
+
+    # Redefine sort behaviour for column
+    #
+    # For example:
+    #
+    #   # nulls last
+    #   order_by(:age) do |order_clause|
+    #     [order_clause.to_sql, 'NULLS LAST'].join(' ')  if order_clause.order == 'desc'
+    #   end
+    #
+    #   # by last_name but in the case that there is no last name, by first_name.
+    #   order_by(:full_name) do |order_clause|
+    #     ['COALESCE(NULLIF(last_name, ''), first_name), first_name', order_clause.order].join(' ')
+    #   end
+    #
+    #
+    def order_by(column, &block)
+      config.ordering[column] = block
+    end
+
+    def belongs_to(target, options = {})
+      config.belongs_to(target, options)
+    end
+
+    # Scope collection to a relation
+    def scope_to(*args, &block)
+      config.scope_to(*args, &block)
+    end
+
+    # Create a scope
+    def scope(*args, &block)
+      config.scope(*args, &block)
+    end
+
+    # Store relations that should be included
+    def includes(*args)
+      config.includes.push *args
+    end
+
+    #
+    # Keys included in the `permitted_params` setting are automatically whitelisted.
+    #
+    # Either
+    #
+    #   permit_params :title, :author, :body, tags: []
+    #
+    # Or
+    #
+    #   permit_params do
+    #     defaults = [:title, :body]
+    #     if current_user.admin?
+    #       defaults + [:author]
+    #     else
+    #       defaults
+    #     end
+    #   end
+    #
+    def permit_params(*args, &block)
+      param_key = config.param_key.to_sym
+
+      controller do
+        define_method :permitted_params do
+          belongs_to_param = active_admin_config.belongs_to_param
+          create_another_param = :create_another if active_admin_config.create_another
+
+          permitted_params =
+            active_admin_namespace.permitted_params +
+              Array.wrap(belongs_to_param) +
+              Array.wrap(create_another_param)
+
+          params.permit(*permitted_params, param_key => block ? instance_exec(&block) : args)
+        end
+
+        private :permitted_params
+      end
+    end
+
+    # Configure the index page for the resource
+    def index(options = {}, &block)
+      options[:as] ||= :table
+      config.set_page_presenter :index, ActiveAdmin::PagePresenter.new(options, &block)
+    end
+
+    # Configure the show page for the resource
+    def show(options = {}, &block)
+      config.set_page_presenter :show, ActiveAdmin::PagePresenter.new(options, &block)
+    end
+
+    def form(options = {}, &block)
+      config.set_page_presenter :form, ActiveAdmin::PagePresenter.new(options, &block)
+    end
+
+    # Configure the CSV format
+    #
+    # For example:
+    #
+    #   csv do
+    #     column :name
+    #     column("Author") { |post| post.author.full_name }
+    #   end
+    #
+    #   csv col_sep: ";", force_quotes: true do
+    #     column :name
+    #   end
+    #
+    def csv(options = {}, &block)
+      options[:resource] = config
+
+      config.csv_builder = CSVBuilder.new(options, &block)
+    end
+
+    # Member Actions give you the functionality of defining both the
+    # action and the route directly from your ActiveAdmin registration
+    # block.
+    #
+    # For example:
+    #
+    #   ActiveAdmin.register Post do
+    #     member_action :comments do
+    #       @post = Post.find(params[:id])
+    #       @comments = @post.comments
+    #     end
+    #   end
+    #
+    # Will create a new controller action comments and will hook it up to
+    # the named route (comments_admin_post_path) /admin/posts/:id/comments
+    #
+    # You can treat everything within the block as a standard Rails controller
+    # action.
+    #
+    def action(set, name, options = {}, &block)
+      warn "Warning: method `#{name}` already defined in #{controller.name}" if controller.method_defined?(name)
+
+      set << ControllerAction.new(name, options)
+      title = options.delete(:title)
+
+      controller do
+        before_action(only: [name]) { @page_title = title } if title
+        define_method(name, &block || Proc.new {})
+      end
+    end
+
+    def member_action(name, options = {}, &block)
+      action config.member_actions, name, options, &block
+    end
+
+    def collection_action(name, options = {}, &block)
+      action config.collection_actions, name, options, &block
+    end
+
+    def decorate_with(decorator_class)
+      # Force storage as a string. This will help us with reloading issues.
+      # Assuming decorator_class.to_s will return the name of the class allows
+      # us to handle a string or a class.
+      config.decorator_class_name = "::#{ decorator_class }"
+    end
+
+    # Defined Callbacks
+    #
+    # == After Build
+    # Called after the resource is built in the new and create actions.
+    #
+    # ActiveAdmin.register Post do
+    #   after_build do |post|
+    #     post.author = current_user
+    #   end
+    # end
+    #
+    # == Before / After Create
+    # Called before and after a resource is saved to the db on the create action.
+    #
+    # == Before / After Update
+    # Called before and after a resource is saved to the db on the update action.
+    #
+    # == Before / After Save
+    # Called before and after the object is saved in the create and update action.
+    # Note: Gets called after the create and update callbacks
+    #
+    # == Before / After Destroy
+    # Called before and after the object is destroyed from the database.
+    #
+    delegate :before_build, :after_build, to: :controller
+    delegate :before_create, :after_create, to: :controller
+    delegate :before_update, :after_update, to: :controller
+    delegate :before_save, :after_save, to: :controller
+    delegate :before_destroy, :after_destroy, to: :controller
+
+    standard_rails_filters =
+      AbstractController::Callbacks::ClassMethods.public_instance_methods.select { |m| m.match(/_action\z/) }
+    delegate *standard_rails_filters, to: :controller
+
+    # Specify which actions to create in the controller
+    #
+    # Eg:
+    #
+    #   ActiveAdmin.register Post do
+    #     actions :index, :show
+    #   end
+    #
+    # Will only create the index and show actions (no create, update or delete)
+    delegate :actions, to: :controller
+
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  # @private
+  class Router
+    attr_reader :namespaces, :router
+
+    def initialize(router:, namespaces:)
+      @router = router
+      @namespaces = namespaces
+    end
+
+    def apply
+      define_root_routes
+      define_resources_routes
+    end
+
+    private
+
+    def define_root_routes
+      namespaces.each do |namespace|
+        if namespace.root?
+          router.root namespace.root_to_options.merge(to: namespace.root_to)
+        else
+          router.namespace namespace.name, **namespace.route_options.dup do
+            router.root namespace.root_to_options.merge(to: namespace.root_to, as: :root)
+          end
+        end
+      end
+    end
+
+    # Defines the routes for each resource
+    def define_resources_routes
+      resources = namespaces.flat_map { |n| n.resources.values }
+      resources.each do |config|
+        define_resource_routes(config)
+      end
+    end
+
+    def define_resource_routes(config)
+      if config.namespace.root?
+        define_routes(config)
+      else
+        # Add on the namespace if required
+        define_namespace(config)
+      end
+    end
+
+    def define_routes(config)
+      if config.belongs_to?
+        define_belongs_to_routes(config)
+      else
+        page_or_resource_routes(config)
+      end
+    end
+
+    def page_or_resource_routes(config)
+      config.is_a?(Page) ? page_routes(config) : resource_routes(config)
+    end
+
+    def resource_routes(config)
+      router.resources config.resource_name.route_key, only: config.defined_actions do
+        define_actions(config)
+      end
+    end
+
+    def page_routes(config)
+      page = config.underscored_resource_name
+      router.get "/#{page}", to: "#{page}#index"
+      config.page_actions.each do |action|
+        Array.wrap(action.http_verb).each do |verb|
+          build_route(verb, "/#{page}/#{action.name}" => "#{page}##{action.name}")
+        end
+      end
+    end
+
+    # Defines member and collection actions
+    def define_actions(config)
+      router.member do
+        config.member_actions.each { |action| build_action(action) }
+      end
+
+      router.collection do
+        config.collection_actions.each { |action| build_action(action) }
+        router.post :batch_action if config.batch_actions_enabled?
+      end
+    end
+
+    # Deals with +ControllerAction+ instances
+    # Builds one route for each HTTP verb passed in
+    def build_action(action)
+      build_route(action.http_verb, action.name)
+    end
+
+    def build_route(verbs, ...)
+      Array.wrap(verbs).each { |verb| router.send(verb, ...) }
+    end
+
+    def define_belongs_to_routes(config)
+      # If it's optional, make the normal resource routes
+      page_or_resource_routes(config) if config.belongs_to_config.optional?
+
+      # Make the nested belongs_to routes
+      # :only is set to nothing so that we don't clobber any existing routes on the resource
+      router.resources config.belongs_to_config.target.resource_name.plural, only: [] do
+        page_or_resource_routes(config)
+      end
+    end
+
+    def define_namespace(config)
+      router.namespace config.namespace.name, **config.namespace.route_options.dup do
+        define_routes(config)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  class Scope
+
+    attr_reader :scope_method, :id, :scope_block, :display_if_block, :show_count, :default_block, :group
+
+    # Create a Scope
+    #
+    # Examples:
+    #
+    #   Scope.new(:published)
+    #   # => Scope with name 'Published' and scope method :published
+    #
+    #   Scope.new('Published', :public)
+    #   # => Scope with name 'Published' and scope method :public
+    #
+    #   Scope.new 'Published', :public, if: proc { current_admin_user.can? :manage, resource_class } do |articles|
+    #     articles.where published: true
+    #   end
+    #   # => Scope with name 'Published' and scope method :public, optionally displaying the scope per the :if block
+    #
+    #   Scope.new('Published') { |articles| articles.where(published: true) }
+    #   # => Scope with name 'Published' using a block to scope
+    #
+    #   Scope.new ->{Date.today.strftime '%A'}, :published_today
+    #   # => Scope with dynamic title using the :published_today scope method
+    #
+    #   Scope.new :published, nil, group: :status
+    #   # => Scope with the group :status
+    #
+    def initialize(name, method = nil, options = {}, &block)
+      @name = name
+      @scope_method = method.try(:to_sym)
+
+      if name.is_a? Proc
+        raise "A string/symbol is required as the second argument if your label is a proc." unless method
+        @id = method.to_s.parameterize(separator: "_")
+      else
+        @scope_method ||= name.to_sym
+        @id = name.to_s.parameterize(separator: "_")
+      end
+
+      @scope_method = nil if @scope_method == :all
+      if block_given?
+        @scope_method = nil
+        @scope_block = block
+      end
+
+      @localizer = options[:localizer]
+      @show_count = options.fetch(:show_count, true)
+      @display_if_block = options[:if] || proc { true }
+      @default_block = options[:default] || proc { false }
+      @group = options[:group].try(:to_sym)
+    end
+
+    def name
+      case @name
+      when String then @name
+      when Symbol then @localizer ? @localizer.t(@name, scope: "scopes") : @name.to_s.titleize
+      else @name
+      end
+    end
+
+  end
+end