super 0.0.10 → 0.0.15

data/lib/super/badge.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Super
+  class Badge
+    STYLES = {
+      light: "bg-gray-100 text-black",
+      dark: "bg-gray-900 text-white",
+      red: "bg-red-700 text-white",
+      orange: "bg-orange-400 text-black",
+      yellow: "bg-yellow-400 text-black",
+      green: "bg-green-700 text-white",
+      blue: "bg-blue-700 text-white",
+      purple: "bg-purple-800 text-white",
+    }
+
+    def initialize(text, styles: nil)
+      @text = text
+      @requested_styles = Array(styles.presence).flatten
+    end
+
+    def styles
+      return @styles if instance_variable_defined?(:@styles)
+      @styles =
+        if requested_styles.delete(:reset)
+          []
+        else
+          COMMON_STYLES
+        end
+
+      if requested_styles.empty?
+        @styles += [STYLES[:light]]
+      else
+        requested_styles.each do |style|
+          @styles +=
+            if STYLES.key?(style)
+              [STYLES[style]]
+            else
+              [style]
+            end
+        end
+      end
+
+      @styles
+    end
+
+    def to_s
+      ActionController::Base.helpers.content_tag(
+        :span,
+        @text,
+        class: styles.join(" ")
+      )
+    end
+
+    private
+
+    COMMON_STYLES = %w[rounded px-2 py-1 text-xs leading-none font-bold]
+    private_constant :COMMON_STYLES
+
+    attr_reader :requested_styles
+  end
+end

data/lib/super/cheat.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Super
+  class Cheat
+    def controls
+      paths = %w[controls.rb controls/optional.rb controls/steps.rb controls/view.rb]
+      methods =
+        paths
+        .map { |f| File.read(File.join(__dir__, f)) }
+        .flat_map { |content| content.scan(/^\s+def .*$/) }
+        .map { |method| method.strip.sub(/^def /, "#") }
+
+      puts "== Super::Controls"
+      puts methods.join("\n")
+    end
+  end
+end

data/lib/super/client_error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Super
   # A container class for all user-facing (4xx) errors thrown by this library.
   #

data/lib/super/compatibility.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Super
   module Compatability
     module_function
@@ -21,5 +23,24 @@ module Super
         ActiveRecord::Base.sanitize_sql_like(query)
       end
     end
+
+    def polymorphic_path_container
+      if Rails::VERSION::MAJOR == 5 && Rails::VERSION::MINOR == 0
+        @polymorphic_path_container ||=
+          begin
+            klass = Class.new do
+              include ActionDispatch::Routing::PolymorphicRoutes
+
+              def method_missing(method_name)
+                Rails.application.routes.url_helpers.public_send(method_name)
+              end
+            end
+
+            klass.new
+          end
+      else
+        Rails.application.routes.url_helpers
+      end
+    end
   end
 end

data/lib/super/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Super
   # @yield [Configuration]
   # @return [Configuration]
@@ -19,37 +21,27 @@ module Super
   # end
   # ```
   class Configuration
-    def initialize
-      self.title = "Super Admin"
-      self.index_records_per_page = 20
-      self.controller_namespace = "admin"
-      self.route_namespace = :admin
-
-      controller_plugins.use(prepend: Super::Filter::ControllerMethods)
-      controller_plugins.use(prepend: Super::Pagination::ControllerMethods)
+    include ActiveSupport::Configurable
 
-      self.javascripts = [Super::Assets.auto("super/application")]
-      self.stylesheets = [Super::Assets.auto("super/application")]
+    config_accessor(:title) { "Super Admin" }
+    config_accessor(:index_records_per_page) { 100 }
+    config_accessor(:javascripts) do
+      [Super::Assets.auto("super/application")]
     end
-
-    attr_accessor :title
-    attr_accessor :index_records_per_page
-    attr_accessor :controller_namespace
-    attr_writer :route_namespace
-    def route_namespace
-      [@route_namespace].flatten
+    config_accessor(:stylesheets) do
+      [Super::Assets.auto("super/application")]
     end
 
-    attr_accessor :javascripts
-    attr_accessor :stylesheets
+    config_accessor(:path) { "/admin" }
+    config_accessor(:generator_module) { "admin" }
+    config_accessor(:generator_as) { "admin" }
 
-    def controller_plugins
-      Plugin::Registry.controller
+    def initialize
+      controller_plugins.use(prepend: Super::Pagination::ControllerMethods)
     end
 
-    # @api private
-    def path_parts(*parts)
-      route_namespace + parts
+    def controller_plugins
+      Plugin::Registry.controller
     end
   end
 end

data/lib/super/controls.rb

@@ -1,13 +1,22 @@
+# frozen_string_literal: true
+
 require "super/controls/optional"
-require "super/controls/required"
 require "super/controls/steps"
+require "super/controls/view"
 
 module Super
   # The base Controls class. Most parts of Super can be configured by
   # customizing its methods.
   class Controls
-    include Required
     include Optional
     include Steps
+    include View
+
+    # Specifies the model. This is a required method
+    #
+    # @return [ActiveRecord::Base]
+    def model
+      raise NotImplementedError
+    end
   end
 end

data/lib/super/controls/optional.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Super
   class Controls
     # Methods for `Controls` that have a sane default implementation
@@ -24,7 +26,7 @@ module Super
       # @param action [ActionInquirer]
       # @return [Display]
       def display_schema(action:)
-        Display.new(action: action) do |fields, type|
+        Display.new do |fields, type|
           Display::Guesser.new(model: model, action: action, fields: fields, type: type).call
         end
       end
@@ -74,6 +76,47 @@ module Super
           Super::Link.find_all(:show, :edit, :destroy)
         end
       end
+
+      def filters_enabled?
+        true
+      end
+
+      def filter_schema
+        Super::Filter.new do |fields, type|
+          Super::Filter::Guesser.new(model: model, fields: fields, type: type).call
+        end
+      end
+
+      def sort_enabled?
+        true
+      end
+
+      def sortable_columns
+        action = ActionInquirer.new(
+          ActionInquirer.default_for_resources,
+          "index"
+        )
+        attribute_names =
+          display_schema(action: action).each_attribute.map do |key, val|
+            val = val.build if val.respond_to?(:build)
+            key if val.real?
+          end
+
+        attribute_names.compact
+      end
+
+      def default_sort
+        { id: :desc }
+      end
+
+      # Specifies how many records to show per page
+      #
+      # @param action [ActionInquirer]
+      # @param query_params [Hash]
+      # @return [ActiveRecord::Relation]
+      def records_per_page(action:, query_params:)
+        Super.configuration.index_records_per_page
+      end
     end
   end
 end

data/lib/super/controls/steps.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Super
   class Controls
     # Methods that are called by controller actions. All of these methods have
@@ -66,49 +68,66 @@ module Super
         record.destroy
       end
 
-      def build_index_view
-        Super::Layout.new(
-          mains: [
-            Super::Panel.new(
-              Super::Partial.new("collection_header"),
-              :@display
-            ),
-          ]
+      def initialize_query_form(params:, current_path:)
+        Super::Query::FormObject.new(
+          model: model,
+          params: params,
+          namespace: :q,
+          current_path: current_path,
         )
       end
 
-      def build_show_view
-        Super::Layout.new(
-          mains: [
-            Super::Panel.new(
-              Super::Partial.new("member_header"),
-              :@display
-            ),
-          ]
-        )
+      def apply_queries(query_form:, records:)
+        query_form.apply_changes(records)
       end
 
-      def build_new_view
-        Super::Layout.new(
-          mains: [
-            Super::Panel.new(
-              Super::Partial.new("collection_header"),
-              :@form
-            ),
-          ]
-        )
+      def initialize_filter_form(query_form:)
+        if filters_enabled?
+          query_form.add(
+            Super::Filter::FormObject,
+            namespace: :f,
+            schema: filter_schema
+          )
+        end
       end
 
-      def build_edit_view
-        Super::Layout.new(
-          mains: [
-            Super::Panel.new(
-              Super::Partial.new("member_header"),
-              :@form
-            ),
-          ]
+      def initialize_sort_form(query_form:)
+        if sort_enabled?
+          query_form.add(
+            Super::Sort::FormObject,
+            namespace: :s,
+            default: default_sort,
+            sortable_columns: sortable_columns
+          )
+        end
+      end
+
+      # Sets up pagination
+      #
+      # @param action [ActionInquirer]
+      # @param records [ActiveRecord::Relation]
+      # @param query_params [Hash]
+      # @return [Pagination]
+      def initialize_pagination(action:, records:, query_params:)
+        Pagination.new(
+          total_count: records.size,
+          limit: records_per_page(action: action, query_params: query_params),
+          query_params: query_params,
+          page_query_param: :page
         )
       end
+
+      # Paginates
+      #
+      # @param action [ActionInquirer]
+      # @param records [ActiveRecord::Relation]
+      # @param pagination [Pagination]
+      # @return [ActiveRecord::Relation]
+      def paginate_records(action:, records:, pagination:)
+        records
+          .limit(pagination.limit)
+          .offset(pagination.offset)
+      end
     end
   end
 end

data/lib/super/controls/view.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Super
+  class Controls
+    # Methods for `Controls` that have a sane default implementation
+    module View
+      def index_view
+        Super::Layout.new(
+          mains: [
+            Super::Panel.new(
+              Super::Partial.new("collection_header"),
+              :@display
+            ),
+          ],
+          asides: [
+            :@query_form,
+          ]
+        )
+      end
+
+      def show_view
+        Super::Layout.new(
+          mains: [
+            Super::Panel.new(
+              Super::Partial.new("member_header"),
+              :@display
+            ),
+          ]
+        )
+      end
+
+      def new_view
+        Super::Layout.new(
+          mains: [
+            Super::Panel.new(
+              Super::Partial.new("collection_header"),
+              :@form
+            ),
+          ]
+        )
+      end
+
+      def edit_view
+        Super::Layout.new(
+          mains: [
+            Super::Panel.new(
+              Super::Partial.new("member_header"),
+              :@form
+            ),
+          ]
+        )
+      end
+    end
+  end
+end

data/lib/super/display.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Super
   # This schema type is meant to be used for +#index+ or +#show+ actions to
   # transform database fields into something that is human friendly.
@@ -23,39 +25,53 @@ module Super
   class Display
     include Schema::Common
 
-    def initialize(action:)
-      @action_inquirer = action
+    def initialize
       @fields = Super::Schema::Fields.new
       @schema_types = SchemaTypes.new(fields: @fields)
 
       yield(@fields, @schema_types)
+    end
 
-      return if !@action_inquirer.index?
-      return if @schema_types.actions_called?
+    def apply(action:)
+      @action_inquirer = action
+      return self if !@action_inquirer.index?
+      return self if @schema_types.actions_called?
       @fields[:actions] = @schema_types.actions
+      self
     end
 
     def to_partial_path
-      if @action_inquirer.index?
-        "super_schema_display_index"
+      if @action_inquirer.nil?
+        raise Super::Error::Initalization,
+          "You must call the `#apply` method after instantiating Super::Display"
+      elsif @action_inquirer.index?
+        "display_index"
       elsif @action_inquirer.show?
-        "super_schema_display_show"
+        "display_show"
       else
-        "super_schema_display_#{@action_inquirer.action}"
+        "display_#{@action_inquirer.action}"
       end
     end
 
     # @private
-    def render_field(template:, record:, column:)
+    def render_attribute(template:, record:, column:)
       formatter = @fields[column]
+      formatter = formatter.build if formatter.respond_to?(:build)
 
       formatted =
-        if formatter.real?
+        SchemaTypes::TYPES
+        .case(formatter.type)
+        .when(:record) do
+          formatter.present(column, record)
+        end
+        .when(:column) do
           value = record.public_send(column)
-          formatter.present(value)
-        else
-          formatter.present
+          formatter.present(column, value)
+        end
+        .when(:none) do
+          formatter.present(column)
         end
+        .result
 
       if formatted.respond_to?(:to_partial_path)
         if formatted.respond_to?(:locals)