super-sharp-tool 0.0.1

data/activeadmin-3.5.1/lib/active_admin/views/components/menu_item.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module Views
+
+    # Arbre component used to render ActiveAdmin::MenuItem
+    class MenuItem < Component
+      builder_method :menu_item
+      attr_reader :label
+      attr_reader :url
+      attr_reader :priority
+
+      def build(item, options = {})
+        super(options.merge(id: item.id))
+        @label = helpers.render_in_context self, item.label
+        @url = helpers.render_in_context self, item.url
+        @priority = item.priority
+        @submenu = nil
+
+        add_class "current" if item.current? assigns[:current_tab]
+
+        if url
+          text_node link_to label, url, **item.html_options
+        else
+          span label, item.html_options
+        end
+
+        if item.items.any?
+          add_class "has_nested"
+          @submenu = menu(item)
+        end
+      end
+
+      def tag_name
+        "li"
+      end
+
+      # Sorts by priority first, then alphabetically by label if needed.
+      def <=>(other)
+        result = priority <=> other.priority
+        result == 0 ? label <=> other.label : result
+      end
+
+      def visible?
+        url.nil? || real_url? || @submenu && @submenu.children.any?
+      end
+
+      def to_s
+        visible? ? super : ""
+      end
+
+      private
+
+      # URL is not nil, empty, or '#'
+      def real_url?
+        url && url.present? && url != "#"
+      end
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/views/components/paginated_collection.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+require "active_admin/helpers/collection"
+require "active_admin/view_helpers/download_format_links_helper"
+
+module ActiveAdmin
+  module Views
+
+    # Wraps the content with pagination and available formats.
+    #
+    # *Example:*
+    #
+    #   paginated_collection collection, entry_name: "Post" do
+    #     div do
+    #       h2 "Inside the
+    #     end
+    #   end
+    #
+    # This will create a div with a sentence describing the number of
+    # posts in one of the following formats:
+    #
+    # * "No Posts found"
+    # * "Displaying all 10 Posts"
+    # * "Displaying Posts 1 - 30 of 31 in total"
+    #
+    # It will also generate pagination links.
+    #
+    class PaginatedCollection < ActiveAdmin::Component
+      builder_method :paginated_collection
+
+      attr_reader :collection
+
+      # Builds a new paginated collection component
+      #
+      # collection => A paginated collection from kaminari
+      # options    => These options will be passed to `page_entries_info`
+      #   entry_name     => The name to display for this resource collection
+      #   params         => Extra parameters for pagination (e.g. { anchor: 'details' })
+      #   param_name     => Parameter name for page number in the links (:page by default)
+      #   download_links => Download links override (false or [:csv, :pdf])
+      #
+      def build(collection, options = {})
+        @collection = collection
+        @params = options.delete(:params)
+        @param_name = options.delete(:param_name)
+        @download_links = options.delete(:download_links)
+        @display_total = options.delete(:pagination_total) { true }
+        @per_page = options.delete(:per_page)
+
+        unless collection.respond_to?(:total_pages)
+          raise(StandardError, "Collection is not a paginated scope. Set collection.page(params[:page]).per(10) before calling :paginated_collection.")
+        end
+
+        @contents = div(class: "paginated_collection_contents")
+        build_pagination_with_formats(options)
+        @built = true
+      end
+
+      # Override add_child to insert all children into the @contents div
+      def add_child(*args, &block)
+        if @built
+          @contents.add_child(*args, &block)
+        else
+          super
+        end
+      end
+
+      protected
+
+      def build_pagination_with_formats(options)
+        div id: "index_footer" do
+          build_per_page_select if @per_page.is_a?(Array)
+          build_pagination
+          div(page_entries_info(options).html_safe, class: "pagination_information")
+
+          formats = build_download_formats @download_links
+          build_download_format_links formats if formats.any?
+        end
+      end
+
+      def build_per_page_select
+        div class: "pagination_per_page" do
+          text_node I18n.t("active_admin.pagination.per_page")
+          select do
+            @per_page.each do |per_page|
+              option(
+                per_page,
+                value: per_page,
+                selected: collection.limit_value == per_page ? "selected" : nil
+              )
+            end
+          end
+        end
+      end
+
+      def build_pagination
+        options = { theme: @display_total ? "active_admin" : "active_admin_countless" }
+        options[:params] = @params if @params
+        options[:param_name] = @param_name if @param_name
+
+        if !@display_total
+          # The #paginate method in kaminari will query the resource with a
+          # count(*) to determine how many pages there should be unless
+          # you pass in the :total_pages option. We issue a query to determine
+          # if there is another page or not, but the limit/offset make this
+          # query fast.
+          offset_scope = collection.offset(collection.current_page * collection.limit_value)
+          # Support array collections. Kaminari::PaginatableArray does not respond to except
+          offset_scope = offset_scope.except(:select, :order) if offset_scope.respond_to?(:except)
+          offset = offset_scope.limit(1).count
+          options[:total_pages] = collection.current_page + offset
+          options[:right] = 0
+        end
+
+        text_node paginate collection, **options
+      end
+
+      include ::ActiveAdmin::Helpers::Collection
+      include ::ActiveAdmin::ViewHelpers::DownloadFormatLinksHelper
+
+      # modified from will_paginate
+      def page_entries_info(options = {})
+        if options[:entry_name]
+          entry_name = options[:entry_name]
+          entries_name = options[:entries_name] || entry_name.pluralize
+        elsif collection_is_empty?
+          entry_name = I18n.t "active_admin.pagination.entry", count: 1, default: "entry"
+          entries_name = I18n.t "active_admin.pagination.entry", count: 2, default: "entries"
+        else
+          key = "activerecord.models." + collection.first.class.model_name.i18n_key.to_s
+
+          entry_name = I18n.translate key, count: 1, default: collection.first.class.name.underscore.sub("_", " ")
+          entries_name = I18n.translate key, count: collection.size, default: entry_name.pluralize
+        end
+
+        if @display_total
+          if collection.total_pages < 2
+            case collection_size
+            when 0; I18n.t("active_admin.pagination.empty", model: entries_name)
+            when 1; I18n.t("active_admin.pagination.one", model: entry_name)
+            else; I18n.t("active_admin.pagination.one_page", model: entries_name, n: collection.total_count)
+            end
+          else
+            offset = (collection.current_page - 1) * collection.limit_value
+            total = collection.total_count
+            I18n.t "active_admin.pagination.multiple",
+                   model: entries_name,
+                   total: total,
+                   from: offset + 1,
+                   to: offset + collection_size
+          end
+        else
+          # Do not display total count, in order to prevent a `SELECT count(*)`.
+          # To do so we must not call `collection.total_pages`
+          offset = (collection.current_page - 1) * collection.limit_value
+          I18n.t "active_admin.pagination.multiple_without_total",
+                 model: entries_name,
+                 from: offset + 1,
+                 to: offset + collection_size
+        end
+      end
+
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/views/components/panel.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module Views
+
+    class Panel < ActiveAdmin::Component
+      builder_method :panel
+
+      def build(title, attributes = {})
+        super(attributes)
+        add_class "panel"
+        @title = h3(title.to_s)
+        @contents = div(class: "panel_contents")
+      end
+
+      def add_child(child)
+        if @contents
+          @contents << child
+        else
+          super
+        end
+      end
+
+      # Override children? to only report children when the panel's
+      # contents have been added to. This ensures that the panel
+      # correcly appends string values, etc.
+      def children?
+        @contents.children?
+      end
+
+      def header_action(*args)
+        action = args[0]
+
+        @title << div(class: "header_action") do
+          action
+        end
+      end
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/views/components/scopes.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+require "active_admin/helpers/collection"
+require "active_admin/view_helpers/method_or_proc_helper"
+
+module ActiveAdmin
+  module Views
+
+    # Renders a collection of ActiveAdmin::Scope objects as a
+    # simple list with a seperator
+    class Scopes < ActiveAdmin::Component
+      builder_method :scopes_renderer
+
+      include ActiveAdmin::ScopeChain
+      include ::ActiveAdmin::Helpers::Collection
+
+      def default_class_name
+        "scopes"
+      end
+
+      def tag_name
+        "div"
+      end
+
+      def build(scopes, options = {})
+        scopes.group_by(&:group).each do |group, group_scopes|
+          ul class: "table_tools_segmented_control #{group_class(group)}" do
+            group_scopes.each do |scope|
+              build_scope(scope, options) if call_method_or_exec_proc(scope.display_if_block)
+            end
+
+            nil
+          end
+        end
+      end
+
+      protected
+
+      def build_scope(scope, options)
+        li class: classes_for_scope(scope) do
+          params = request.query_parameters.except :page, :scope, :commit, :format
+
+          a href: url_for(scope: scope.id, params: params), class: "table_tools_button" do
+            text_node scope_name(scope)
+            span class: "count" do
+              "(#{get_scope_count(scope)})"
+            end if options[:scope_count] && scope.show_count
+          end
+        end
+      end
+
+      def classes_for_scope(scope)
+        classes = ["scope", scope.id]
+        classes << "selected" if current_scope?(scope)
+        classes.join(" ")
+      end
+
+      def current_scope?(scope)
+        if params[:scope]
+          params[:scope] == scope.id
+        else
+          active_admin_config.default_scope(self) == scope
+        end
+      end
+
+      # Return the count for the scope passed in.
+      def get_scope_count(scope)
+        collection_size(scope_chain(scope, collection_before_scope))
+      end
+
+      def group_class(group)
+        group.present? ? "scope-group-#{group}" : "scope-default-group"
+      end
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/views/components/sidebar.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module Views
+
+    class Sidebar < Component
+      builder_method :sidebar
+
+      def build(sections, attributes = {})
+        super(attributes)
+        sections.map(&method(:sidebar_section))
+      end
+    end
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/views/components/sidebar_section.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module Views
+
+    class SidebarSection < Panel
+      builder_method :sidebar_section
+
+      # Takes a ActiveAdmin::SidebarSection instance
+      def build(section)
+        @section = section
+        super(@section.title)
+        add_class @section.custom_class if @section.custom_class
+        self.id = @section.id
+        build_sidebar_content
+      end
+
+      # Renders attributes_table_for current resource
+      def attributes_table(*args, &block)
+        attributes_table_for resource, *args, &block
+      end
+
+      protected
+
+      def build_sidebar_content
+        if @section.block
+          rvalue = instance_exec(&@section.block)
+          self << rvalue if rvalue.is_a?(String)
+        else
+          render(@section.partial_name)
+        end
+      end
+    end
+
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/views/components/site_title.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module Views
+
+    class SiteTitle < Component
+
+      def tag_name
+        "h1"
+      end
+
+      def build(namespace)
+        super(id: "site_title")
+        @namespace = namespace
+
+        if site_title_link?
+          text_node site_title_with_link
+        else
+          text_node site_title_content
+        end
+      end
+
+      def site_title_link?
+        @namespace.site_title_link.present?
+      end
+
+      def site_title_image
+        @site_title_image ||= @namespace.site_title_image(helpers)
+      end
+
+      private
+
+      def site_title_with_link
+        helpers.link_to(site_title_content, @namespace.site_title_link)
+      end
+
+      def site_title_content
+        if site_title_image.present?
+          title_image
+        else
+          title_text
+        end
+      end
+
+      def title_text
+        @title_text ||= @namespace.site_title(helpers)
+      end
+
+      def title_image
+        helpers.image_tag(site_title_image, id: "site_title_image", alt: title_text)
+      end
+
+    end
+
+  end
+end

data/activeadmin-3.5.1/lib/active_admin/views/components/status_tag.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module Views
+    # Build a StatusTag
+    class StatusTag < ActiveAdmin::Component
+      builder_method :status_tag
+
+      def tag_name
+        "span"
+      end
+
+      def default_class_name
+        "status_tag"
+      end
+
+      # @overload status_tag(status, options = {})
+      #   @param [String] status the status to display. One of the span classes will be an underscored version of the status.
+      #   @param [Hash] options
+      #   @option options [String] :class to override the default class
+      #   @option options [String] :id to override the default id
+      #   @option options [String] :label to override the default label
+      #   @return [ActiveAdmin::Views::StatusTag]
+      #
+      # @example
+      #   status_tag('In Progress')
+      #   # => <span class='status_tag in_progress'>In Progress</span>
+      #
+      # @example
+      #   status_tag('active', class: 'important', id: 'status_123', label: 'on')
+      #   # => <span class='status_tag active important' id='status_123'>on</span>
+      #
+      def build(status, options = {})
+        label = options.delete(:label)
+        classes = options.delete(:class)
+        status = convert_to_boolean_status(status)
+
+        if status
+          content = label || if s = status.to_s and s.present?
+                               I18n.t "active_admin.status_tag.#{s.downcase}", default: s.titleize
+                             end
+        end
+
+        super(content, options)
+
+        add_class(status_to_class(status)) if status
+        add_class(classes) if classes
+      end
+
+      protected
+
+      def convert_to_boolean_status(status)
+        case status
+        when true, "true"
+          "Yes"
+        when false, "false"
+          "No"
+        when nil
+          "Unset"
+        else
+          status
+        end
+      end
+
+      def status_to_class(status)
+        case status
+        when "Unset"
+          "unset no"
+        when String, Symbol
+          status.to_s.titleize.gsub(/\s/, "").underscore
+        else
+          ""
+        end
+      end
+    end
+  end
+end