super-sharp-tool 0.0.1

data/activeadmin-3.5.1/lib/active_admin/batch_actions/views/selection_cells.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+require "active_admin/component"
+
+module ActiveAdmin
+  module BatchActions
+
+    # Creates the toggle checkbox used to toggle the collection selection on/off
+    class ResourceSelectionToggleCell < ActiveAdmin::Component
+      builder_method :resource_selection_toggle_cell
+
+      def build(label_text = "")
+        label do
+          input type: "checkbox", id: "collection_selection_toggle_all", name: "collection_selection_toggle_all", class: "toggle_all"
+          text_node label_text if label_text.present?
+        end
+      end
+    end
+
+    # Creates the checkbox used to select a resource in the collection selection
+    class ResourceSelectionCell < ActiveAdmin::Component
+      builder_method :resource_selection_cell
+
+      def build(resource)
+        input type: "checkbox", id: "batch_action_item_#{resource.id}", value: resource.id, class: "collection_selection", name: "collection_selection[]"
+      end
+    end
+
+    # Creates a wrapper panel for all index pages, except for the table, as the table has the checkbox in the thead
+    class ResourceSelectionTogglePanel < ActiveAdmin::Component
+      builder_method :resource_selection_toggle_panel
+
+      def build
+        super(id: "collection_selection_toggle_panel")
+        resource_selection_toggle_cell(I18n.t("active_admin.batch_actions.selection_toggle_explanation", default: "(Toggle Selection)"))
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+ActiveAdmin.before_load do |app|
+  require "active_admin/batch_actions/resource_extension"
+  require "active_admin/batch_actions/controller"
+
+  # Add our Extensions
+  ActiveAdmin::Resource.send :include, ActiveAdmin::BatchActions::ResourceExtension
+  ActiveAdmin::ResourceController.send :include, ActiveAdmin::BatchActions::Controller
+
+  # Require all the views
+  require "active_admin/batch_actions/views/batch_action_form"
+  require "active_admin/batch_actions/views/selection_cells"
+  require "active_admin/batch_actions/views/batch_action_selector"
+
+  # Register the views with the view factory
+  app.view_factory.register batch_action_selector: ActiveAdmin::BatchActions::BatchActionSelector
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    private
+
+    # Simple callback system. Implements before and after callbacks for
+    # use within the controllers.
+    #
+    # We didn't use the ActiveSupport callbacks because they do not support
+    # passing in any arbitrary object into the callback method (which we
+    # need to do)
+
+    def run_callback(method, *args)
+      case method
+      when Symbol
+        send(method, *args)
+      when Proc
+        instance_exec(*args, &method)
+      else
+        raise "Please register with callbacks using a symbol or a block/proc."
+      end
+    end
+
+    module ClassMethods
+
+      private
+
+      # Define a new callback.
+      #
+      # Example:
+      #
+      #   class MyClassWithCallbacks
+      #     include ActiveAdmin::Callbacks
+      #
+      #     define_active_admin_callbacks :save
+      #
+      #     before_save do |arg1, arg2|
+      #       # runs before save
+      #     end
+      #
+      #     after_save :call_after_save
+      #
+      #     def save
+      #       # Will run before, yield, then after
+      #       run_save_callbacks :arg1, :arg2 do
+      #         save!
+      #       end
+      #     end
+      #
+      #     protected
+      #
+      #     def call_after_save(arg1, arg2)
+      #       # runs after save
+      #     end
+      #   end
+      #
+      def define_active_admin_callbacks(*names)
+        names.each do |name|
+          [:before, :after].each do |type|
+            callback_name = "#{type}_#{name}_callbacks"
+            callback_ivar = "@#{callback_name}"
+
+            # def self.before_create_callbacks
+            singleton_class.send :define_method, callback_name do
+              instance_variable_get(callback_ivar) || instance_variable_set(callback_ivar, [])
+            end
+            singleton_class.send :private, callback_name
+
+            # def self.before_create
+            singleton_class.send :define_method, "#{type}_#{name}" do |method = nil, &block|
+              send(callback_name).push method || block
+            end
+          end
+
+          # def run_create_callbacks
+          define_method "run_#{name}_callbacks" do |*args, &block|
+            self.class.send("before_#{name}_callbacks").each { |cbk| run_callback(cbk, *args) }
+            value = block.try :call
+            self.class.send("after_#{name}_callbacks").each { |cbk| run_callback(cbk, *args) }
+            return value
+          end
+          send :private, "run_#{name}_callbacks"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+unless ActiveAdmin::Dependency.cancan? || ActiveAdmin::Dependency.cancancan?
+  ActiveAdmin::Dependency.cancan!
+end
+
+require "cancan"
+
+# Add a setting to the application to configure the ability
+ActiveAdmin::Application.inheritable_setting :cancan_ability_class, "Ability"
+
+module ActiveAdmin
+
+  class CanCanAdapter < AuthorizationAdapter
+
+    def authorized?(action, subject = nil)
+      cancan_ability.can?(action, subject)
+    end
+
+    def cancan_ability
+      @cancan_ability ||= initialize_cancan_ability
+    end
+
+    def scope_collection(collection, action = ActiveAdmin::Auth::READ)
+      collection.accessible_by(cancan_ability, action)
+    end
+
+    private
+
+    def initialize_cancan_ability
+      klass = resource.namespace.cancan_ability_class
+      klass = klass.constantize if klass.is_a? String
+      klass.new user
+    end
+
+  end
+
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  # This class decorates a collection of objects delegating
+  # mehods to behave like an Array. It's used to decouple ActiveAdmin
+  # from Draper and thus being able to use PORO decorators as well.
+  #
+  # It's implementation is heavily based on the Draper::CollectionDecorator
+  # https://github.com/drapergem/draper/blob/aaa06bd2f1e219838b241a5534e7ca513edd1fe2/lib/draper/collection_decorator.rb
+  class CollectionDecorator
+    # @return the collection being decorated.
+    attr_reader :object
+
+    # @return [Class] the decorator class used to decorate each item, as set by {#initialize}.
+    attr_reader :decorator_class
+
+    array_methods = Array.instance_methods - Object.instance_methods
+    delegate :==, :as_json, *array_methods, to: :decorated_collection
+
+    def initialize(object, with:)
+      @object = object
+      @decorator_class = with
+    end
+
+    class << self
+      alias_method :decorate, :new
+    end
+
+    def decorated_collection
+      @decorated_collection ||= object.map { |item| decorator_class.new(item) }
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  class Component < Arbre::Component
+
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  class ControllerAction
+    attr_reader :name
+    def initialize(name, options = {})
+      @name = name
+      @options = options
+    end
+
+    def http_verb
+      @options[:method] ||= :get
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  # CSVBuilder stores CSV configuration
+  #
+  # Usage example:
+  #
+  #   csv_builder = CSVBuilder.new
+  #   csv_builder.column :id
+  #   csv_builder.column("Name") { |resource| resource.full_name }
+  #   csv_builder.column(:name, humanize_name: false)
+  #   csv_builder.column("name", humanize_name: false) { |resource| resource.full_name }
+  #
+  #   csv_builder = CSVBuilder.new col_sep: ";"
+  #   csv_builder = CSVBuilder.new humanize_name: false
+  #   csv_builder.column :id
+  #
+  #
+  class CSVBuilder
+
+    # Return a default CSVBuilder for a resource
+    # The CSVBuilder's columns would be Id followed by this
+    # resource's content columns
+    def self.default_for_resource(resource)
+      new resource: resource do
+        column :id
+        resource.content_columns.each { |c| column c }
+      end
+    end
+
+    attr_reader :columns, :options, :view_context
+
+    COLUMN_TRANSITIVE_OPTIONS = [:humanize_name].freeze
+
+    def initialize(options = {}, &block)
+      @resource = options.delete(:resource)
+      @columns = []
+      @options = ActiveAdmin.application.csv_options.merge options
+      @block = block
+    end
+
+    def column(name, options = {}, &block)
+      @columns << Column.new(name, @resource, column_transitive_options.merge(options), block)
+    end
+
+    def build(controller, csv)
+      columns = exec_columns controller.view_context
+      bom = options[:byte_order_mark]
+      column_names = options.delete(:column_names) { true }
+      csv_options = options.except :encoding_options, :humanize_name, :byte_order_mark
+
+      csv << bom if bom
+
+      if column_names
+        csv << CSV.generate_line(columns.map { |c| sanitize(encode(c.name, options)) }, **csv_options)
+      end
+
+      controller.send(:in_paginated_batches) do |resource|
+        csv << CSV.generate_line(build_row(resource, columns, options), **csv_options)
+      end
+
+      csv
+    end
+
+    def exec_columns(view_context = nil)
+      @view_context = view_context
+      @columns = [] # we want to re-render these every instance
+      instance_exec &@block if @block.present?
+      columns
+    end
+
+    def build_row(resource, columns, options)
+      columns.map do |column|
+        sanitize(encode(call_method_or_proc_on(resource, column.data), options))
+      end
+    end
+
+    def encode(content, options)
+      if options[:encoding]
+        if options[:encoding_options]
+          content.to_s.encode options[:encoding], **options[:encoding_options]
+        else
+          content.to_s.encode options[:encoding]
+        end
+      else
+        content
+      end
+    end
+
+    def sanitize(content)
+      Sanitizer.sanitize(content)
+    end
+
+    def method_missing(method, *args, &block)
+      if @view_context.respond_to? method
+        @view_context.public_send method, *args, &block
+      else
+        super
+      end
+    end
+
+    class Column
+      attr_reader :name, :data, :options
+
+      DEFAULT_OPTIONS = { humanize_name: true }
+
+      def initialize(name, resource = nil, options = {}, block = nil)
+        @options = options.reverse_merge(DEFAULT_OPTIONS)
+        @name = humanize_name(name, resource, @options[:humanize_name])
+        @data = block || name.to_sym
+      end
+
+      def humanize_name(name, resource, humanize_name_option)
+        if humanize_name_option
+          name.is_a?(Symbol) && resource ? resource.resource_class.human_attribute_name(name) : name.to_s.humanize
+        else
+          name.to_s
+        end
+      end
+    end
+
+    private
+
+    def column_transitive_options
+      @column_transitive_options ||= @options.slice(*COLUMN_TRANSITIVE_OPTIONS)
+    end
+  end
+
+  # Prevents CSV Injection according to https://owasp.org/www-community/attacks/CSV_Injection
+  module Sanitizer
+    extend self
+
+    ATTACK_CHARACTERS = ["=", "+", "-", "@", "\t", "\r"].freeze
+
+    def sanitize(value)
+      return "'#{value}" if require_sanitization?(value)
+
+      value
+    end
+
+    def require_sanitization?(value)
+      value.is_a?(String) && value.starts_with?(*ATTACK_CHARACTERS)
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module Dependency
+    module Requirements
+      DEVISE = ">= 4.0", "< 6"
+    end
+
+    # Provides a clean interface to check for gem dependencies at runtime.
+    #
+    # ActiveAdmin::Dependency.rails
+    # => #<ActiveAdmin::Dependency::Matcher for rails 6.0.3.2>
+    #
+    # ActiveAdmin::Dependency.rails?
+    # => true
+    #
+    # ActiveAdmin::Dependency.rails? '>= 6.1'
+    # => false
+    #
+    # ActiveAdmin::Dependency.rails? '= 6.0.3.2'
+    # => true
+    #
+    # ActiveAdmin::Dependency.rails? '~> 6.0.3'
+    # => true
+    #
+    # ActiveAdmin::Dependency.rails? '>= 6.0.3', '<= 6.1.0'
+    # => true
+    #
+    # ActiveAdmin::Dependency.rails! '5'
+    # -> ActiveAdmin::DependencyError: You provided rails 4.2.7 but we need: 5.
+    #
+    # ActiveAdmin::Dependency.devise!
+    # -> ActiveAdmin::DependencyError: To use devise you need to specify it in your Gemfile.
+    #
+    #
+    # All but the pessimistic operator (~>) can also be run using Ruby's comparison syntax.
+    #
+    # ActiveAdmin::Dependency.rails >= '4.2.7'
+    # => true
+    #
+    # Which is especially useful if you're looking up a gem with dashes in the name.
+    #
+    # ActiveAdmin::Dependency['jquery-rails'] < 5
+    # => false
+    #
+    def self.method_missing(name, *args)
+      if name[-1] == "?"
+        Matcher.new(name[0..-2]).match? args
+      elsif name[-1] == "!"
+        Matcher.new(name[0..-2]).match! args
+      else
+        Matcher.new name.to_s
+      end
+    end
+
+    def self.[](name)
+      Matcher.new name.to_s
+    end
+
+    class Matcher
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def spec
+        @spec ||= Gem.loaded_specs[name]
+      end
+
+      def spec!
+        spec || raise(DependencyError, "To use #{name} you need to specify it in your Gemfile.")
+      end
+
+      def match?(*reqs)
+        !!spec && Gem::Requirement.create(reqs).satisfied_by?(spec.version)
+      end
+
+      def match!(*reqs)
+        unless match? reqs
+          raise DependencyError, "You provided #{spec!.name} #{spec!.version} but we need: #{reqs.join ', '}."
+        end
+      end
+
+      include Comparable
+
+      def <=>(other)
+        spec!.version <=> Gem::Version.create(other)
+      end
+
+      def inspect
+        info = spec ? "#{spec.name} #{spec.version}" : "(missing)"
+        "<ActiveAdmin::Dependency::Matcher for #{info}>"
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+ActiveAdmin::Dependency.devise! ActiveAdmin::Dependency::Requirements::DEVISE
+
+require "devise"
+
+module ActiveAdmin
+  module Devise
+
+    def self.config
+      {
+        path: ActiveAdmin.application.default_namespace || "/",
+        controllers: ActiveAdmin::Devise.controllers,
+        path_names: { sign_in: "login", sign_out: "logout" },
+        sign_out_via: [*::Devise.sign_out_via, ActiveAdmin.application.logout_link_method].uniq
+      }
+    end
+
+    def self.controllers
+      {
+        sessions: "active_admin/devise/sessions",
+        passwords: "active_admin/devise/passwords",
+        unlocks: "active_admin/devise/unlocks",
+        registrations: "active_admin/devise/registrations",
+        confirmations: "active_admin/devise/confirmations"
+      }
+    end
+
+    module Controller
+      extend ::ActiveSupport::Concern
+      included do
+        layout "active_admin_logged_out"
+        helper ::ActiveAdmin::ViewHelpers
+      end
+
+      # Redirect to the default namespace on logout
+      def root_path
+        namespace = ActiveAdmin.application.default_namespace.presence
+        root_path_method = [namespace, :root_path].compact.join("_")
+
+        path = if Helpers::Routes.respond_to? root_path_method
+                 Helpers::Routes.send root_path_method
+               else
+                 # Guess a root_path when url_helpers not helpful
+                 "/#{namespace}"
+               end
+
+        # NOTE: `relative_url_root` is deprecated by Rails.
+        #       Remove prefix here if it is removed completely.
+        prefix = Rails.configuration.action_controller[:relative_url_root] || ""
+        prefix + path
+      end
+    end
+
+    class SessionsController < ::Devise::SessionsController
+      include ::ActiveAdmin::Devise::Controller
+
+      ActiveSupport.run_load_hooks(:active_admin_controller, self)
+    end
+
+    class PasswordsController < ::Devise::PasswordsController
+      include ::ActiveAdmin::Devise::Controller
+
+      ActiveSupport.run_load_hooks(:active_admin_controller, self)
+    end
+
+    class UnlocksController < ::Devise::UnlocksController
+      include ::ActiveAdmin::Devise::Controller
+
+      ActiveSupport.run_load_hooks(:active_admin_controller, self)
+    end
+
+    class RegistrationsController < ::Devise::RegistrationsController
+      include ::ActiveAdmin::Devise::Controller
+
+      ActiveSupport.run_load_hooks(:active_admin_controller, self)
+    end
+
+    class ConfirmationsController < ::Devise::ConfirmationsController
+      include ::ActiveAdmin::Devise::Controller
+
+      ActiveSupport.run_load_hooks(:active_admin_controller, self)
+    end
+
+    def self.controllers_for_filters
+      [SessionsController, PasswordsController, UnlocksController,
+        RegistrationsController, ConfirmationsController
+      ]
+    end
+
+  end
+end