super 0.0.11 → 0.0.16

data/lib/super/badge.rb

@@ -0,0 +1,60 @@
+# 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",
+      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 controller
+      paths = %w[../../app/controllers/super/substructure_controller.rb]
+      methods =
+        paths
+        .map { |f| File.read(File.expand_path(f, __dir__)) }
+        .flat_map { |content| content.scan(/^\s+(?:helper_method )?def .*$/) }
+        .map { |method| method.strip.sub(/^(?:helper_method )?def /, "#") }
+
+      puts "== Super::ApplicationController"
+      puts methods.join("\n")
+    end
+  end
+end

data/lib/super/compatibility.rb

@@ -23,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

@@ -21,36 +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::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/display.rb

@@ -45,25 +45,33 @@ module Super
         raise Super::Error::Initalization,
           "You must call the `#apply` method after instantiating Super::Display"
       elsif @action_inquirer.index?
-        "super_schema_display_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)

data/lib/super/display/guesser.rb

@@ -27,6 +27,8 @@ module Super
         case type
         when :datetime
           @type.timestamp
+        when :time
+          @type.time
         else
           @type.text
         end

data/lib/super/display/schema_types.rb

@@ -3,35 +3,102 @@
 module Super
   class Display
     class SchemaTypes
-      class Dynamic
-        def initialize(ignore_nil: true, &transform_block)
-          @transform_block = transform_block
+      TYPES = Useful::Enum.new(:column, :record, :none)
+
+      class Builder
+        extend Useful::Builder
+
+        builder_with_block def transform(&block)
+          @transform_block = block
+        end
+
+        builder def real; @real = true; end
+        builder def computed; @real = false; end
+
+        builder def column; @type = :column; end
+        builder def record; @type = :record; end
+        builder def none; @type = :none; end
+
+        builder def ignore_nil; @ignore_nil = true; end
+
+        def build
+          Built.new(
+            real: @real,
+            type: @type,
+            ignore_nil: !!@ignore_nil,
+            &@transform_block
+          )
+        end
+      end
+
+      class Built
+        def initialize(real:, type:, ignore_nil:, &transform_block)
+          @real = real
+          @type = type
           @ignore_nil = ignore_nil
+          @transform_block = transform_block
         end
 
-        def present(value)
+        def real?; @real; end
+        attr_reader :type
+
+        def present(attribute_name, value = nil)
+          if @transform_block.nil?
+            if attribute_name
+              raise Error::ArgumentError, "Transformation block is not set for column: #{attribute_name}"
+            else
+              raise Error::ArgumentError, "Transformation block is not set!"
+            end
+          end
+
           return nil if value.nil? && @ignore_nil
 
-          @transform_block.call(value)
+          if @type == :none
+            @transform_block.call
+          else
+            @transform_block.call(value)
+          end
+        end
+      end
+
+      class Badge
+        extend Useful::Builder
+
+        def initialize(builder)
+          @builder = builder
+          @whens = {}
+          format_for_lookup(&:itself)
+          format_for_display(&:itself)
         end
 
-        def real?
-          true
+        builder_with_block def when(*patterns, &block)
+          patterns.each do |pattern|
+            @whens[pattern] = block
+          end
         end
-      end
 
-      class Bypass
-        def initialize(partial:, real:)
-          @partial = partial
-          @real = real
+        builder_with_block def else(&block)
+          @else = block
         end
 
-        def present
-          Partial.new(@partial)
+        builder_with_block def format_for_lookup(&block)
+          @format_for_lookup = block
         end
 
-        def real?
-          @real
+        builder_with_block def format_for_display(&block)
+          @format_for_display = block
+        end
+
+        def build
+          @builder.transform do |value|
+            lookup_value = @format_for_lookup.call(value)
+            block = @whens[lookup_value] || @else
+            Super::Badge.new(
+              @format_for_display.call(value),
+              styles: block&.call
+            )
+          end
+          @builder.build
         end
       end
 
@@ -40,33 +107,53 @@ module Super
         @fields = fields
       end
 
-      def string
-        Dynamic.new(&:to_s)
+      def real(type = :column, &transform_block)
+        TYPES
+          .case(type)
+          .when(:column) { Builder.new.real.ignore_nil.column.transform(&transform_block) }
+          .when(:record) { Builder.new.real.ignore_nil.record.transform(&transform_block) }
+          .when(:none)   { Builder.new.real.ignore_nil.none.transform(&transform_block) }
+          .result
       end
 
-      alias text string
+      def computed(type = :column, &transform_block)
+        TYPES
+          .case(type)
+          .when(:column) { Builder.new.computed.ignore_nil.column.transform(&transform_block) }
+          .when(:record) { Builder.new.computed.ignore_nil.record.transform(&transform_block) }
+          .when(:none)   { Builder.new.computed.ignore_nil.none.transform(&transform_block) }
+          .result
+      end
 
-      def timestamp
-        Dynamic.new(&:iso8601)
+      def manual(&transform_block)
+        real(:column, &transform_block)
       end
 
+      def string; real(&:to_s); end
+      alias text string
+
+      def timestamp; real(&:to_s); end
+      def time; real { |value| value.strftime("%H:%M:%S") }; end
+
       def rich_text
-        Dynamic.new do |value|
+        computed do |value|
           Partial.new("display_rich_text", locals: { rich_text: value })
         end
       end
 
-      def manual(&transform_block)
-        Dynamic.new(&transform_block)
-      end
-
-      def dynamic(&transform_block)
-        Dynamic.new(&transform_block)
+      def badge(*builder_methods)
+        builder_methods = %i[real ignore_nil column] if builder_methods.empty?
+        builder = builder_methods.each_with_object(Builder.new) do |builder_method, builder|
+          builder.public_send(builder_method)
+        end
+        Badge.new(builder)
       end
 
       def actions
         @actions_called = true
-        Bypass.new(partial: "super_schema_display_actions", real: false)
+        Builder.new.computed.none.transform do
+          Partial.new("display_actions")
+        end
       end
 
       # @private

data/lib/super/error.rb

@@ -27,5 +27,12 @@ module Super
     # Error raised when something wasn't initalized correctly, and if there isn't
     # a more specific error
     class Initalization < Error; end
+    class ArgumentError < Error; end
+
+    class Enum < Error
+      class ImpossibleValue < Enum; end
+      class ArgumentError < Enum; end
+      class UndefinedCase < Enum; end
+    end
   end
 end

data/lib/super/form.rb

@@ -31,7 +31,7 @@ module Super
     end
 
     def to_partial_path
-      "super_schema_form"
+      "form"
     end
   end
 end

data/lib/super/form/builder.rb

@@ -58,6 +58,65 @@ module Super
           @builder.check_box(attribute, options, checked_value, unchecked_value)
         end
 
+        def date_flatpickr(attribute, options = {})
+          options, defaults = split_defaults(
+            options,
+            class: "super-input w-full",
+            data: {
+              controller: "flatpickr",
+              flatpickr_options_value: {
+                dateFormat: "Y-m-d",
+              }
+            }
+          )
+          options[:class] = join_classes(defaults[:class], options[:class])
+          options[:data] = defaults[:data].deep_merge(options[:data] || {})
+          options[:value] = @builder.object.public_send(attribute).presence&.iso8601
+
+          @builder.text_field(attribute, options)
+        end
+
+        def datetime_flatpickr(attribute, options = {})
+          options, defaults = split_defaults(
+            options,
+            class: "super-input w-full",
+            data: {
+              controller: "flatpickr",
+              flatpickr_options_value: {
+                enableSeconds: true,
+                enableTime: true,
+                dateFormat: "Z",
+              }
+            }
+          )
+          options[:class] = join_classes(defaults[:class], options[:class])
+          options[:data] = defaults[:data].deep_merge(options[:data] || {})
+          options[:value] = @builder.object.public_send(attribute).presence&.iso8601
+
+          @builder.text_field(attribute, options)
+        end
+
+        def time_flatpickr(attribute, options = {})
+          options, defaults = split_defaults(
+            options,
+            class: "super-input w-full",
+            data: {
+              controller: "flatpickr",
+              flatpickr_options_value: {
+                enableSeconds: true,
+                enableTime: true,
+                noCalendar: true,
+                dateFormat: "H:i:S",
+              }
+            }
+          )
+          options[:class] = join_classes(defaults[:class], options[:class])
+          options[:data] = defaults[:data].deep_merge(options[:data] || {})
+          options[:value] = @builder.object.public_send(attribute).presence&.strftime("%H:%M:%S")
+
+          @builder.text_field(attribute, options)
+        end
+
         def password_field(attribute, options = {})
           options, defaults = split_defaults(options, class: "super-input w-full")
           options[:class] = join_classes(defaults[:class], options[:class])
@@ -75,25 +134,10 @@ module Super
         def select(attribute, choices, options = {}, html_options = {}, &block)
           options, defaults = split_defaults(options, include_blank: true)
           options = defaults.merge(options)
-          html_options, html_defaults = split_defaults(html_options, class: "super-input super-input-select-field")
+          html_options, html_defaults = split_defaults(html_options, class: "super-input super-input-select")
           html_options[:class] = join_classes(html_defaults[:class], html_options[:class])
 
-          parts = [
-            %(<div class="super-input-select">).html_safe,
-            @builder.select(attribute, choices, options, html_options, &block),
-            <<~HTML.html_safe,
-              <div class="super-input-select-icon text-blue-700">
-                <span class="h-4 w-4">
-            HTML
-            @template.render("super/feather/chevron_down"),
-            <<~HTML.html_safe,
-                </span>
-              </div>
-            HTML
-            %(</div>).html_safe,
-          ]
-
-          @template.safe_join(parts)
+          @builder.select(attribute, choices, options, html_options, &block)
         end
 
         def submit(value = nil, options = {})
@@ -115,24 +159,60 @@ module Super
           @template.content_tag(:div, class: "super-field-group", &block)
         end
 
-        def check_box!(attribute, checked_value = "1", unchecked_value = "0", label: {}, field: {}, show_errors: true)
+        def check_box!(attribute, checked_value: "1", unchecked_value: "0", label_text: nil, label: {}, field: {}, show_errors: true)
           label[:super] ||= {}
           label[:super] = { class: "select-none ml-1" }.merge(label[:super])
           container do
             compact_join([
               "<div>".html_safe,
               public_send(:check_box, attribute, field, checked_value, unchecked_value),
-              public_send(:label, attribute, nil, label),
+              public_send(:label, attribute, label_text, label),
               "</div>".html_safe,
               show_errors && inline_errors(attribute),
             ])
           end
         end
 
-        def password_field!(attribute, label: {}, field: {}, show_errors: true)
+        def date_flatpickr!(attribute, label_text: nil, label: {}, field: {}, show_errors: true)
+          container do
+            compact_join([
+              public_send(:label, attribute, label_text, label),
+              %(<div class="mt-1">).html_safe,
+              public_send(:date_flatpickr, attribute, field),
+              show_errors && inline_errors(attribute),
+              %(</div>).html_safe,
+            ])
+          end
+        end
+
+        def datetime_flatpickr!(attribute, label_text: nil, label: {}, field: {}, show_errors: true)
+          container do
+            compact_join([
+              public_send(:label, attribute, label_text, label),
+              %(<div class="mt-1">).html_safe,
+              public_send(:datetime_flatpickr, attribute, field),
+              show_errors && inline_errors(attribute),
+              %(</div>).html_safe,
+            ])
+          end
+        end
+
+        def time_flatpickr!(attribute, label_text: nil, label: {}, field: {}, show_errors: true)
+          container do
+            compact_join([
+              public_send(:label, attribute, label_text, label),
+              %(<div class="mt-1">).html_safe,
+              public_send(:time_flatpickr, attribute, field),
+              show_errors && inline_errors(attribute),
+              %(</div>).html_safe,
+            ])
+          end
+        end
+
+        def password_field!(attribute, label_text: nil, label: {}, field: {}, show_errors: true)
           container do
             compact_join([
-              public_send(:label, attribute, label),
+              public_send(:label, attribute, label_text, label),
               %(<div class="mt-1">).html_safe,
               public_send(:password_field, attribute, field),
               show_errors && inline_errors(attribute),
@@ -141,10 +221,10 @@ module Super
           end
         end
 
-        def rich_text_area!(attribute, label: {}, field: {}, show_errors: true)
+        def rich_text_area!(attribute, label_text: nil, label: {}, field: {}, show_errors: true)
           container do
             compact_join([
-              public_send(:label, attribute, label),
+              public_send(:label, attribute, label_text, label),
               %(<div class="mt-1">).html_safe,
               public_send(:rich_text_area, attribute, field),
               show_errors && inline_errors(attribute),
@@ -153,10 +233,10 @@ module Super
           end
         end
 
-        def select!(attribute, collection, label: {}, field: {}, show_errors: true)
+        def select!(attribute, collection, label_text: nil, label: {}, field: {}, show_errors: true)
           container do
             compact_join([
-              public_send(:label, attribute, label),
+              public_send(:label, attribute, label_text, label),
               %(<div class="mt-1">).html_safe,
               public_send(:select, attribute, collection, field),
               show_errors && inline_errors(attribute),
@@ -165,10 +245,10 @@ module Super
           end
         end
 
-        def text_field!(attribute, label: {}, field: {}, show_errors: true)
+        def text_field!(attribute, label_text: nil, label: {}, field: {}, show_errors: true)
           container do
             compact_join([
-              public_send(:label, attribute, label),
+              public_send(:label, attribute, label_text, label),
               %(<div class="mt-1">).html_safe,
               public_send(:text_field, attribute, field),
               show_errors && inline_errors(attribute),