super 0.19.0 → 0.20.0

data/frontend/super-frontend/dist/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@superadministration/super",
   "description": "The frontend code for Super, a Rails admin framework",
-  "homepage": "https://github.com/zachahn/super",
+  "homepage": "https://github.com/superadministration/super",
   "license": "LGPL-3.0-only",
   "main": "application.js",
   "files": [
@@ -9,5 +9,5 @@
     "application.css",
     "package.json"
   ],
-  "version": "0.19.0"
+  "version": "0.20.0"
 }

data/lib/super/action_inquirer.rb

@@ -22,6 +22,9 @@ module Super
         "read" => %w[index show new edit],
         "write" => %w[create update destroy],
         "delete" => %w[destroy],
+
+        "collection" => %w[index new create],
+        "member" => %w[show edit update destroy],
       }
     end
 

data/lib/super/error.rb

@@ -31,6 +31,7 @@ module Super
     class AlreadyRegistered < Error; end
     class AlreadyTranscribed < Error; end
     class NotImplementedError < Error; end
+    class IncompleteBuilder < Error; end
 
     class Enum < Error
       class ImpossibleValue < Enum; end

data/lib/super/form/schema_types.rb

@@ -105,42 +105,6 @@ module Super
         Direct.new(super_builder: super_builder, method_name: method_name, args: args, kwargs: kwargs)
       end
 
-      def select(*args, **kwargs)
-        Direct.new(super_builder: true, method_name: :select!, args: args, kwargs: kwargs)
-      end
-
-      def text_field(*args, **kwargs)
-        Direct.new(super_builder: true, method_name: :text_field!, args: args, kwargs: kwargs)
-      end
-
-      def rich_text_area(*args, **kwargs)
-        Direct.new(super_builder: true, method_name: :rich_text_area!, args: args, kwargs: kwargs)
-      end
-
-      def check_box(*args, **kwargs)
-        Direct.new(super_builder: true, method_name: :check_box!, args: args, kwargs: kwargs)
-      end
-
-      def date_flatpickr(*args, **kwargs)
-        Direct.new(super_builder: true, method_name: :date_flatpickr!, args: args, kwargs: kwargs)
-      end
-
-      def datetime_flatpickr(*args, **kwargs)
-        Direct.new(super_builder: true, method_name: :datetime_flatpickr!, args: args, kwargs: kwargs)
-      end
-
-      def hidden_field(*args, **kwargs)
-        Direct.new(super_builder: false, method_name: :hidden_field, args: args, kwargs: kwargs)
-      end
-
-      def password_field(*args, **kwargs)
-        Direct.new(super_builder: true, method_name: :password_field!, args: args, kwargs: kwargs)
-      end
-
-      def time_flatpickr(*args, **kwargs)
-        Direct.new(super_builder: true, method_name: :time_flatpickr!, args: args, kwargs: kwargs)
-      end
-
       def has_many(reader, **extras)
         subfields = Schema::Fields.new
         @fields.nested do
@@ -176,6 +140,14 @@ module Super
           nested: {}
         )
       end
+
+      def self.define_schema_type_for(method_name)
+        class_eval(<<~RUBY)
+          def #{method_name}(*args, **kwargs)
+            Direct.new(super_builder: true, method_name: :#{method_name}!, args: args, kwargs: kwargs)
+          end
+        RUBY
+      end
     end
   end
 end

data/lib/super/form_builder/action_text_methods.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Super
+  class FormBuilder
+    class Wrappers
+      def rich_text_area(attribute, options = {})
+        options, defaults = split_defaults(options, class: "trix-content super-input w-full")
+        options[:class] = join_classes(defaults[:class], options[:class])
+
+        @builder.rich_text_area(attribute, options)
+      end
+
+      define_convenience :rich_text_area
+    end
+  end
+end

data/lib/super/form_builder/base_methods.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Super
+  class FormBuilder
+    class Wrappers
+      skipped_field_helpers = [:label, :check_box, :radio_button, :fields_for, :fields, :hidden_field, :file_field]
+      (ActionView::Helpers::FormBuilder.field_helpers - skipped_field_helpers).each do |builder_method_name|
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          def #{builder_method_name}(attribute, options = {})
+            options, defaults = split_defaults(options, class: "super-input w-full")
+            options[:class] = join_classes(defaults[:class], options[:class])
+
+            @builder.#{builder_method_name}(attribute, options)
+          end
+
+          define_convenience :#{builder_method_name}
+        RUBY
+      end
+
+      def label(attribute, text = nil, options = {}, &block)
+        options, defaults = split_defaults(options, class: "block")
+        options[:class] = join_classes(defaults[:class], options[:class])
+
+        @builder.label(attribute, text, options, &block)
+      end
+
+      def check_box(attribute, options = {}, checked_value = "1", unchecked_value = "0")
+        @builder.check_box(attribute, options, checked_value, unchecked_value)
+      end
+
+      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, label_text, label),
+            "</div>".html_safe,
+            show_errors && inline_errors(attribute),
+          ])
+        end
+      end
+
+      ::Super::Form::SchemaTypes.define_schema_type_for(:check_box)
+
+      # def file_field(attribute, options = {})
+      # end
+
+      # def file_field!(attribute, label_text: nil, label: {}, field: {}, show_errors: true)
+      # end
+
+      def hidden_field(attribute, options = {})
+        @builder.hidden_field(attribute, options)
+      end
+
+      # def radio_button(attribute, tag_value, options = {})
+      #   @builder.radio_button(attribute, tag_value, options)
+      # end
+
+      # def radio_button(attribute, tag_value, label_text: nil, label: {}, field: {}, show_errors: true)
+      # end
+
+      def submit(value = nil, options = {})
+        value, options = nil, value if value.is_a?(Hash)
+        options, defaults = split_defaults(options, class: "super-button")
+        options[:class] = join_classes(defaults[:class], options[:class])
+
+        @builder.submit(value, options)
+      end
+    end
+  end
+end

data/lib/super/form_builder/flatpickr_methods.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Super
+  class FormBuilder
+    class Wrappers
+      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
+        options[:value] = options[:value].iso8601 if options[:value].respond_to?(:iso8601)
+
+        @builder.text_field(attribute, options)
+      end
+
+      define_convenience :date_flatpickr
+
+      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
+        options[:value] = options[:value].iso8601 if options[:value].respond_to?(:iso8601)
+
+        @builder.text_field(attribute, options)
+      end
+
+      define_convenience :datetime_flatpickr
+
+      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
+        options[:value] = options[:value].strftime("%H:%M:%S") if options[:value].respond_to?(:strftime)
+
+        @builder.text_field(attribute, options)
+      end
+
+      define_convenience :time_flatpickr
+    end
+  end
+end

data/lib/super/form_builder/option_methods.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Super
+  class FormBuilder
+    class Wrappers
+      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")
+        html_options[:class] = join_classes(html_defaults[:class], html_options[:class])
+
+        @builder.select(attribute, choices, options, html_options, &block)
+      end
+
+      define_convenience :select
+
+      def collection_select(attribute, collection, value_method, text_method, options = {}, html_options = {})
+        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")
+        html_options[:class] = join_classes(html_defaults[:class], html_options[:class])
+
+        @builder.collection_select(attribute, collection, value_method, text_method, options, html_options)
+      end
+
+      define_convenience :collection_select
+
+      def grouped_collection_select(attribute, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})
+        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")
+        html_options[:class] = join_classes(html_defaults[:class], html_options[:class])
+
+        @builder.grouped_collection_select(attribute, collection, group_method, group_label_method, option_key_method, option_value_method, options, html_options)
+      end
+
+      define_convenience :grouped_collection_select
+
+      def time_zone_select(attribute, priority_zones = nil, options = {}, html_options = {})
+        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")
+        html_options[:class] = join_classes(html_defaults[:class], html_options[:class])
+
+        @builder.time_zone_select(attribute, priority_zones, options, html_options)
+      end
+
+      define_convenience :time_zone_select, priority_zones: "nil"
+
+      def collection_check_boxes(attribute, collection, value_method, text_method, 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")
+        html_options[:class] = join_classes(html_defaults[:class], html_options[:class])
+
+        @builder.collection_check_boxes(attribute, collection, value_method, text_method, options, html_options, &block)
+      end
+
+      define_convenience :collection_check_boxes
+
+      def collection_radio_buttons(attribute, collection, value_method, text_method, 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")
+        html_options[:class] = join_classes(html_defaults[:class], html_options[:class])
+
+        @builder.collection_radio_buttons(attribute, collection, value_method, text_method, options, html_options, &block)
+      end
+
+      define_convenience :collection_radio_buttons
+    end
+  end
+end

data/lib/super/form_builder.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Super
+  # Example
+  #
+  # ```ruby
+  # super_form_for([:admin, @member]) do |f|
+  #   # the long way
+  #   f.super.label :name
+  #   f.super.text_field :name
+  #   f.super.inline_errors :name
+  #
+  #   # the short way (slightly different from the long way, for alignment)
+  #   f.super.text_field! :position
+  # end
+  # ```
+  #
+  # Refer to the Rails docs:
+  # https://api.rubyonrails.org/classes/ActionView/Helpers/FormBuilder.html
+  class FormBuilder < ActionView::Helpers::FormBuilder
+    FIELD_ERROR_PROC = proc { |html_tag, instance| html_tag }
+    FORM_BUILDER_DEFAULTS = { builder: self }.freeze
+
+    def super(**options)
+      @super_wrappers ||= Wrappers.new(self, @template)
+    end
+
+    class Wrappers
+      def initialize(builder, template)
+        @builder = builder
+        @template = template
+      end
+
+      def inline_errors(attribute)
+        if @builder.object
+          messages = Form::InlineErrors.error_messages(@builder.object, attribute).map do |msg|
+            error_content_tag(msg)
+          end
+
+          @template.safe_join(messages)
+        else
+          error_content_tag(<<~MSG.html_safe)
+            This form doesn't have an object, so something is probably wrong.
+            Maybe <code>accepts_nested_attributes_for</code> isn't set up?
+          MSG
+        end
+      end
+
+      def container(&block)
+        @template.content_tag(:div, class: "super-field-group", &block)
+      end
+
+      private
+
+      private_class_method def self.define_with_label_tag(method_name, **optionals)
+        parameters = instance_method(method_name).parameters
+        definition = []
+        call = []
+        definition_last = ["label_text: nil", "label: {}", "show_errors: true"]
+        call_last = []
+        parameters.each do |type, name|
+          if name == :options && type == :opt
+            definition.push("field: {}")
+            call.push("field")
+          elsif name == :html_options && type == :opt
+            definition.push("field_html: {}")
+            call.push("field_html")
+          elsif type == :block
+            definition_last.push("&#{name}")
+            call_last.push("&#{name}")
+          else
+            if type == :req
+              definition.push(name.to_s)
+              call.push(name.to_s)
+            elsif type == :opt || type == :key
+              if !optionals.key?(name)
+                raise Super::Error::ArgumentError, "Form bang method has optional argument, but doesn't know the default value: #{name}"
+              end
+
+              default_value = optionals[name]
+
+              if type == :opt
+                definition.push("#{name} = #{default_value}")
+                call.push(name.to_s)
+              elsif type == :key
+                definition.push("#{name}: #{default_value}")
+                call.push("#{name}: #{name}")
+              else
+                raise Super::Error::ArgumentError, "Form bang method has a unprocessable argument with name #{name}"
+              end
+            else
+              raise Super::Error::ArgumentError, "Form bang method has keyword argument type #{type} and name #{name}"
+            end
+          end
+        end
+
+        definition += definition_last
+        call += call_last
+
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          def #{method_name}!(#{definition.join(", ")})
+            container do
+              compact_join([
+                public_send(:label, attribute, label_text, label),
+                %(<div class="mt-1">).html_safe,
+                #{method_name}(#{call.join(", ")}),
+                show_errors && inline_errors(attribute),
+                %(</div>).html_safe,
+              ])
+            end
+          end
+        RUBY
+      end
+
+      private_class_method def self.define_convenience(method_name, *args, **kwargs)
+        define_with_label_tag(method_name, *args, **kwargs)
+        ::Super::Form::SchemaTypes.define_schema_type_for(method_name)
+      end
+
+      def split_defaults(options, **internal_defaults)
+        defaults = options.delete(:super) || {}
+        # prefer options set in `defaults`, since they are user overrides
+        defaults = internal_defaults.merge(defaults)
+
+        [options, defaults]
+      end
+
+      def join_classes(*class_lists)
+        class_lists.flatten.map(&:presence).compact
+      end
+
+      def error_content_tag(content)
+        @template.content_tag(:p, content, class: "text-red-400 text-xs italic pt-1")
+      end
+
+      def compact_join(*parts)
+        @template.safe_join(
+          parts.flatten.map(&:presence).compact
+        )
+      end
+    end
+  end
+end

data/lib/super/link.rb

@@ -9,75 +9,43 @@ module Super
     end
 
     def self.find(link)
-      if link.kind_of?(self)
-        return link
-      end
-
       if registry.key?(link)
-        return registry[link]
+        found = registry[link]
+
+        if found.is_a?(LinkBuilder)
+          return found.dup
+        else
+          return found
+        end
       end
 
       raise Error::LinkNotRegistered, "Unknown link `#{link}`"
     end
 
     def self.registry
-      @registry ||= {
-        new: LinkBuilder.new(
-          "New",
-          -> (params:) {
-            {
-              controller: params[:controller],
-              action: :new,
-              only_path: true
-            }
-          }
-        ),
-        index: LinkBuilder.new(
-          "Index",
-          -> (params:) {
-            {
-              controller: params[:controller],
-              action: :index,
-              only_path: true
-            }
-          }
-        ),
-        show: LinkBuilder.new(
-          "View",
-          -> (record:, params:) {
-            {
-              controller: params[:controller],
-              action: :show,
-              id: record,
-              only_path: true
-            }
-          }
-        ),
-        edit: LinkBuilder.new(
-          "Edit",
-          -> (record:, params:) {
-            {
-              controller: params[:controller],
-              action: :edit,
-              id: record,
-              only_path: true
-            }
-          }
-        ),
-        destroy: LinkBuilder.new(
-          "Delete",
-          -> (record:, params:) {
-            {
-              controller: params[:controller],
-              action: :destroy,
-              id: record,
-              only_path: true
-            }
-          },
-          method: :delete,
-          data: { confirm: "Really delete?" }
-        ),
-      }
+      @registry ||= {}.tap do |reg|
+        reg[:new] = LinkBuilder.new
+          .text { |params:| Super::Useful::I19.i18n_with_fallback("super", params[:controller].split("/"), "actions.new") }
+          .href { |params:| { controller: params[:controller], action: :new, only_path: true } }
+          .freeze
+        reg[:index] = LinkBuilder.new
+          .text { |params:| Super::Useful::I19.i18n_with_fallback("super", params[:controller].split("/"), "actions.index") }
+          .href { |params:| { controller: params[:controller], action: :index, only_path: true } }
+          .freeze
+        reg[:show] = LinkBuilder.new
+          .text { |params:, **| Super::Useful::I19.i18n_with_fallback("super", params[:controller].split("/"), "actions.show") }
+          .href { |params:, record:| { controller: params[:controller], action: :show, id: record, only_path: true } }
+          .freeze
+        reg[:edit] = LinkBuilder.new
+          .text { |params:, **| Super::Useful::I19.i18n_with_fallback("super", params[:controller].split("/"), "actions.edit") }
+          .href { |params:, record:| { controller: params[:controller], action: :edit, id: record, only_path: true } }
+          .freeze
+        reg[:destroy] = LinkBuilder.new
+          .text { |params:, **| Super::Useful::I19.i18n_with_fallback("super", params[:controller].split("/"), "actions.destroy") }
+          .href { |params:, record:| { controller: params[:controller], action: :destroy, id: record, only_path: true } }
+          .options { |**| { method: :delete, data: { confirm: "Really delete?" } } }
+          .freeze
+      end
     end
 
     def self.polymorphic_parts(*parts_tail)
@@ -85,15 +53,31 @@ module Super
       parts_head.map { |part| part.is_a?(String) ? part.to_sym : part } + parts_tail
     end
 
+    # The first argument should be the text of the link. If it's an array,
+    # it'll send it directly into `I18n.t`
     def initialize(text, href, **options)
       @text = text
       @href = href
       @options = options
     end
 
-    attr_reader :text
     attr_reader :options
 
+    def text
+      if @text.is_a?(Array)
+        *head, tail = @text
+        if !tail.is_a?(Hash)
+          head.push(tail)
+          tail = {}
+        end
+
+        @text = I18n.t(*head, **tail)
+        return @text
+      end
+
+      @text
+    end
+
     def href
       if @href.is_a?(String)
         return @href