super 0.17.0 → 0.20.0

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

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

data/lib/generators/super/webpacker/USAGE

@@ -1,15 +1,9 @@
 Description:
     Creates the necessary files for assets to be served under Webpacker
 
-    Webpacker support requires that you install ERB support for Webpacker.
-
-    Installing ERB on webpacker is usually done by running the command:
-    `rails webpacker:install:erb`
-
 Example:
-    rails webpacker:install:erb             # if you hadn't set up ERB already
     rails generate super:webpacker
 
     This will:
-        Create app/javascript/packs/super/application.js.erb
+        Create app/javascript/packs/super/application.js
         Modify config/initializers/super.rb

data/lib/generators/super/webpacker/templates/pack_super_application.js.tt

@@ -0,0 +1,2 @@
+import Super from "@superadministration/super";
+import "@superadministration/super/application.css";

data/lib/generators/super/webpacker/webpacker_generator.rb

@@ -7,12 +7,12 @@ module Super
     def copy_the_pack_file
       path =
         if Gem::Dependency.new("webpacker", ">= 6.0.0.beta2", "!= 6.0.0.pre1", "!= 6.0.0.pre2").matching_specs.any?
-          "app/packs/entrypoints/super/application.js.erb"
+          "app/packs/entrypoints/super/application.js"
         else
-          "app/javascript/packs/super/application.js.erb"
+          "app/javascript/packs/super/application.js"
         end
 
-      template("pack_super_application.js.erb", path)
+      template("pack_super_application.js", path)
     end
 
     def set_asset_handler_to_webpacker
@@ -24,9 +24,13 @@ module Super
       )
     end
 
-    def remind_about_erb
-      say "Make sure ERB is set up for Webpacker!", :bold
-      say "Run if needed: bundle exec rails webpacker:install:erb"
+    def install_via_yarn
+      super_root = Pathname.new(__dir__).join("../../../..")
+      if super_root.join("dummy_path.rb").file?
+        run "yarn add file:#{super_root.join("frontend/super-frontend/dist")}"
+      else
+        run "yarn add @superadministration/super@#{Super::VERSION} --exact"
+      end
     end
   end
 end

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/cheat.rb

@@ -8,6 +8,7 @@ module Super
         paths
         .map { |f| File.read(File.expand_path(f, __dir__)) }
         .flat_map { |content| content.scan(/^\s+(?:helper_method )?def .*$/) }
+        .reject { |method| method =~ /\bdef self\./ }
         .map { |method| method.strip.sub(/^(?:helper_method )?def /, "#") }
 
       puts "== Super::ApplicationController"

data/lib/super/display/schema_types.rb

@@ -129,6 +129,12 @@ module Super
         real(:column, &transform_block)
       end
 
+      def batch
+        real do |value|
+          Partial.new("batch_checkbox", locals: { value: value })
+        end
+      end
+
       def string; real(&:to_s); end
 
       def timestamp; real(&:to_s); end

data/lib/super/display.rb

@@ -32,10 +32,11 @@ module Super
       yield(@fields, @schema_types)
     end
 
-    def apply(action:)
+    def apply(action:, format:)
       @action_inquirer = action
       return self if !@action_inquirer.index?
       return self if @schema_types.actions_called?
+      return self if !format.html?
       @fields[:actions] = @schema_types.actions
       self
     end

data/lib/super/engine.rb

@@ -15,6 +15,11 @@ module Super
       Super::Plugin::Registry.controller.ordered do |klass, method_name|
         Super::ApplicationController.public_send(method_name, klass)
       end
+
+      Super::PackagedAsset.warning_message =
+        if !Super::PackagedAsset.version_matches_gem?(Rails.root.join("package.json"))
+          I18n.t("super.mismatching_package_json_gemfile_versions")
+        end
     end
   end
 end

data/lib/super/error.rb

@@ -30,11 +30,22 @@ module Super
     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
       class ArgumentError < Enum; end
       class UndefinedCase < Enum; end
     end
+
+    class ReorderableHash < Error
+      class DuplicateKey < ReorderableHash; end
+      class KeyError < ReorderableHash; end
+    end
+
+    class ViewChain < Error
+      class ChainAlreadyStarted < ViewChain; end
+    end
   end
 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/layout.rb

@@ -6,44 +6,20 @@ module Super
   class Layout
     include Super::Partial::Resolving
 
-    def initialize(headers: nil, asides: nil, mains: nil, footers: nil)
-      @headers = Array(headers).compact
-      @asides = Array(asides).compact
-      @mains = Array(mains).compact
-      @footers = Array(footers).compact
+    def initialize(header: nil, aside: nil, main: nil, footer: nil)
+      @header = header
+      @aside = aside
+      @main = main
+      @footer = footer
     end
 
-    attr_reader :headers
-    attr_reader :asides
-    attr_reader :mains
-    attr_reader :footers
+    attr_reader :header
+    attr_reader :aside
+    attr_reader :main
+    attr_reader :footer
 
     def to_partial_path
       "layout"
     end
-
-    def resolve(template)
-      @resolved_headers = resolve_for_rendering(template, headers, nil)
-      @resolved_asides = resolve_for_rendering(template, asides, nil)
-      @resolved_mains = resolve_for_rendering(template, mains, nil)
-      @resolved_footers = resolve_for_rendering(template, footers, nil)
-      self
-    end
-
-    def resolved_headers
-      @resolved_headers || []
-    end
-
-    def resolved_asides
-      @resolved_asides || []
-    end
-
-    def resolved_mains
-      @resolved_mains || []
-    end
-
-    def resolved_footers
-      @resolved_footers || []
-    end
   end
 end