super 0.19.0.rc1 → 0.21.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-rc1"
+  "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/badge.rb

@@ -12,9 +12,18 @@ module Super
       purple: "bg-purple-800 text-white",
     }
 
-    def initialize(text, styles: nil)
+    def initialize(text, style: nil, styles: nil)
       @text = text
-      @requested_styles = Array(styles.presence).flatten
+      if styles.present?
+        Super::Useful::Deprecation["0.22"].deprecation_warning("styles:", "use `style:` with a single style")
+      end
+      @requested_styles = Array(styles.presence).flatten + Array(style.presence).flatten
+      if @requested_styles.any? { |s| s.is_a?(String) }
+        Super::Useful::Deprecation["0.22"].warn("Super::Badge.new(text, style:) accepts exactly one Symbol style from this list #{STYLES.keys.inspect}")
+      end
+      if @requested_styles.size != 1
+        Super::Useful::Deprecation["0.22"].warn("Super::Badge.new(text, style:) accepts exactly one style, but it received #{@requested_styles.size}")
+      end
     end
 
     def styles

data/lib/super/cheat.rb

@@ -3,7 +3,12 @@
 module Super
   class Cheat
     def controller
-      paths = %w[../../app/controllers/super/substructure_controller.rb]
+      paths = %w[
+        ../../app/controllers/super/application_controller.rb
+        ../../app/controllers/super/substructure_controller.rb
+        ../../app/controllers/super/view_controller.rb
+        ../../app/controllers/super/sitewide_controller.rb
+      ]
       methods =
         paths
         .map { |f| File.read(File.expand_path(f, __dir__)) }

data/lib/super/display/schema_types.rb

@@ -3,7 +3,7 @@
 module Super
   class Display
     class SchemaTypes
-      TYPES = Useful::Enum.new(:column, :record, :none)
+      TYPES = Useful::Enum.new(:attribute, :record, :none)
 
       class Builder
         extend Useful::Builder
@@ -15,37 +15,47 @@ module Super
         builder def real; @real = true; end
         builder def computed; @real = false; end
 
-        builder def column; @type = :column; end
+        # @deprecated Prefer {#attribute}
+        builder def column
+          Useful::Deprecation["0.22"].deprecation_warning(":column", "use :attribute instead")
+          @type = :attribute
+        end
+        builder def attribute; @type = :attribute; end
         builder def record; @type = :record; end
         builder def none; @type = :none; end
 
         builder def ignore_nil; @ignore_nil = true; end
 
+        builder def attribute_name(name); @attribute_name = name; end
+
         def build
           Built.new(
             real: @real,
             type: @type,
             ignore_nil: !!@ignore_nil,
+            attribute_name: @attribute_name,
             &@transform_block
           )
         end
       end
 
       class Built
-        def initialize(real:, type:, ignore_nil:, &transform_block)
+        def initialize(real:, type:, ignore_nil:, attribute_name:, &transform_block)
           @real = real
           @type = type
           @ignore_nil = ignore_nil
+          @attribute_name = attribute_name
           @transform_block = transform_block
         end
 
         def real?; @real; end
         attr_reader :type
+        attr_reader :attribute_name
 
         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}"
+              raise Error::ArgumentError, "Transformation block is not set for attribute: #{attribute_name}"
             else
               raise Error::ArgumentError, "Transformation block is not set!"
             end
@@ -61,6 +71,7 @@ module Super
         end
       end
 
+      # @deprecated
       class Badge
         extend Useful::Builder
 
@@ -107,26 +118,36 @@ module Super
         @fields = fields
       end
 
-      def real(type = :column, &transform_block)
+      def real(type = :attribute, &transform_block)
+        if type == :column
+          Useful::Deprecation["0.22"].deprecation_warning(":column", "use :attribute instead")
+          type = :attribute
+        end
+
         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) }
+          .when(:attribute) { Builder.new.real.ignore_nil.attribute.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
 
-      def computed(type = :column, &transform_block)
+      def computed(type = :attribute, &transform_block)
+        if type == :column
+          Useful::Deprecation["0.22"].deprecation_warning(":column", "use :attribute instead")
+          type = :attribute
+        end
+
         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) }
+          .when(:attribute) { Builder.new.computed.ignore_nil.attribute.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 manual(&transform_block)
-        real(:column, &transform_block)
+        real(:attribute, &transform_block)
       end
 
       def batch
@@ -146,8 +167,10 @@ module Super
         end
       end
 
+      # @deprecated Use {#real} or {#computed} instead, and return an instance of {Super::Badge}
       def badge(*builder_methods)
-        builder_methods = %i[real ignore_nil column] if builder_methods.empty?
+        Useful::Deprecation["0.22"].deprecation_warning("#badge", "use #real or #computed instead, and return an instance of Super::Badge")
+        builder_methods = %i[real ignore_nil attribute] if builder_methods.empty?
         builder = builder_methods.each_with_object(Builder.new) do |builder_method, builder|
           builder.public_send(builder_method)
         end

data/lib/super/display.rb

@@ -26,7 +26,9 @@ module Super
     include Schema::Common
 
     def initialize
-      @fields = Super::Schema::Fields.new
+      @fields = Super::Schema::Fields.new(
+        transform_value_on_set: -> (val) { if val.respond_to?(:build) then val.build else val end }
+      )
       @schema_types = SchemaTypes.new(fields: @fields)
 
       yield(@fields, @schema_types)
@@ -43,7 +45,7 @@ module Super
 
     def to_partial_path
       if @action_inquirer.nil?
-        raise Super::Error::Initalization,
+        raise Super::Error::Initialization,
           "You must call the `#apply` method after instantiating Super::Display"
       elsif @action_inquirer.index?
         "display_index"
@@ -57,7 +59,6 @@ module Super
     # @private
     def render_attribute(template:, record:, column:)
       formatter = @fields[column]
-      formatter = formatter.build if formatter.respond_to?(:build)
 
       formatted =
         SchemaTypes::TYPES
@@ -65,7 +66,7 @@ module Super
         .when(:record) do
           formatter.present(column, record)
         end
-        .when(:column) do
+        .when(:attribute) do
           value = record.public_send(column)
           formatter.present(column, value)
         end

data/lib/super/error.rb

@@ -24,13 +24,14 @@ module Super
         )
       end
     end
-    # Error raised when something wasn't initalized correctly, and if there isn't
+    # Error raised when something wasn't initialized correctly, and if there isn't
     # a more specific error
-    class Initalization < Error; end
+    class Initialization < Error; end
     class ArgumentError < Error; end
     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