super 0.0.14 → 0.18.0

data/lib/super/filter/schema_types.rb

@@ -2,112 +2,95 @@
 
 module Super
   class Filter
-    # This schema type is used to configure the filtering form on your +#index+
-    # action.
-    #
-    # The +operators:+ keyword argument can be left out in each case. There is
-    # a default set of operators that are provided.
-    #
     # Note: The constants under "Defined Under Namespace" are considered
     # private.
-    #
-    #   class MemberDashboard
-    #     # ...
-    #
-    #     def filter_schema
-    #       Super::Filter.new do |fields, type|
-    #         fields[:name] = type.text(operators: [
-    #           Super::Filter::Operator.eq,
-    #           Super::Filter::Operator.contain,
-    #           Super::Filter::Operator.ncontain,
-    #           Super::Filter::Operator.start,
-    #           Super::Filter::Operator.end,
-    #         ])
-    #         fields[:rank] = type.select(collection: Member.ranks.values)
-    #         fields[:position] = type.text(operators: [
-    #           Super::Filter::Operator.eq,
-    #           Super::Filter::Operator.neq,
-    #           Super::Filter::Operator.contain,
-    #           Super::Filter::Operator.ncontain,
-    #         ])
-    #         fields[:ship_id] = type.select(
-    #           collection: Ship.all.map { |s| ["#{s.name} (Ship ##{s.id})", s.id] },
-    #         )
-    #         fields[:created_at] = type.timestamp
-    #         fields[:updated_at] = type.timestamp
-    #       end
-    #     end
-    #
-    #     # ...
-    #   end
     class SchemaTypes
-      class Text
-        def initialize(partial_path:, operators:)
-          @partial_path = partial_path
-          @operators = operators
-        end
+      class OperatorList
+        include Enumerable
 
-        attr_reader :operators
+        def initialize(*new_operators)
+          @operators = {}
+          @operator_transcript = {}
+          @fallback_transcript = nil
 
-        def to_partial_path
-          @partial_path
+          push(*new_operators)
         end
 
-        def q
-          [:q]
-        end
-      end
+        def push(*new_operators)
+          new_operators.flatten.map(&:dup).each do |new_operator|
+            new_identifier = new_operator.identifier.to_s
+
+            raise Error::AlreadyRegistered if @operators.key?(new_identifier)
 
-      class Select
-        def initialize(collection:, operators:)
-          @collection = collection
-          @operators = operators
+            @operators[new_identifier] = new_operator
+          end
+
+          nil
         end
 
-        attr_reader :collection
-        attr_reader :operators
+        alias add push
+
+        def each
+          return enum_for(:each) if !block_given?
 
-        def to_partial_path
-          "filter_type_select"
+          @operators.each do |identifier, operator|
+            yield(
+              OperatorWithFieldTranscript.new(
+                operator,
+                @operator_transcript[identifier] || @fallback_transcript
+              )
+            )
+          end
         end
 
-        def q
-          [:q]
+        def transcribe(operator_identifier = nil)
+          transcript = Form::FieldTranscript.new
+          yield transcript
+
+          if operator_identifier.nil?
+            @fallback_transcript = transcript
+          else
+            @operator_transcript[operator_identifier.to_s] = transcript
+          end
+
+          self
         end
       end
 
-      class Timestamp
-        def initialize(operators:)
-          @operators = operators
+      class OperatorWithFieldTranscript
+        def initialize(operator, field_transcript)
+          @operator = operator
+          @field_transcript = field_transcript
         end
 
-        attr_reader :operators
-
-        def to_partial_path
-          "filter_type_timestamp"
+        Super::Filter::Operator.instance_methods(false).each do |name|
+          delegate name, to: :@operator
         end
 
-        def q
-          [:q0, :q1]
-        end
+        attr_reader :field_transcript
+      end
+
+      def use(*identifiers)
+        found_operators = identifiers.flatten.map { |id| Operator[id] }
+        OperatorList.new(*found_operators)
+      end
+
+      def select(collection)
+        use("eq", "null", "nnull")
+          .transcribe { |f| f.super.select(collection) }
       end
 
-      def select(collection:, operators: Filter::Operator.select_defaults)
-        Select.new(
-          collection: collection,
-          operators: operators
-        )
+      def text
+        use("contain", "ncontain", "blank", "nblank")
       end
 
-      def text(operators: Filter::Operator.text_defaults)
-        Text.new(
-          partial_path: "filter_type_text",
-          operators: operators
-        )
+      def timestamp
+        use("between", "null", "nnull")
+          .transcribe { |f| f.super.datetime_flatpickr }
       end
 
-      def timestamp(operators: Filter::Operator.range_defaults)
-        Timestamp.new(operators: operators)
+      def boolean
+        use("true", "false", "null", "nnull")
       end
     end
   end

data/lib/super/filter.rb

@@ -3,7 +3,7 @@
 module Super
   class Filter
     def initialize
-      @schema_type = Filter::SchemaTypes.new
+      @schema_type = SchemaTypes.new
       @fields = Schema::Fields.new
 
       yield(@fields, @schema_type)

data/lib/super/form/builder.rb

@@ -58,7 +58,7 @@ module Super
           @builder.check_box(attribute, options, checked_value, unchecked_value)
         end
 
-        def flatpickr_date(attribute, options = {})
+        def date_flatpickr(attribute, options = {})
           options, defaults = split_defaults(
             options,
             class: "super-input w-full",
@@ -71,11 +71,13 @@ module Super
           )
           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
 
-        def flatpickr_datetime(attribute, options = {})
+        def datetime_flatpickr(attribute, options = {})
           options, defaults = split_defaults(
             options,
             class: "super-input w-full",
@@ -90,11 +92,13 @@ module Super
           )
           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
 
-        def flatpickr_time(attribute, options = {})
+        def time_flatpickr(attribute, options = {})
           options, defaults = split_defaults(
             options,
             class: "super-input w-full",
@@ -110,6 +114,8 @@ module Super
           )
           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
@@ -131,25 +137,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 = {})
@@ -171,60 +162,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 flatpickr_date!(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),
+              public_send(:label, attribute, label_text, label),
               %(<div class="mt-1">).html_safe,
-              public_send(:flatpickr_date, attribute, field),
+              public_send(:date_flatpickr, attribute, field),
               show_errors && inline_errors(attribute),
               %(</div>).html_safe,
             ])
           end
         end
 
-        def flatpickr_datetime!(attribute, label: {}, field: {}, show_errors: true)
+        def datetime_flatpickr!(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(:flatpickr_datetime, attribute, field),
+              public_send(:datetime_flatpickr, attribute, field),
               show_errors && inline_errors(attribute),
               %(</div>).html_safe,
             ])
           end
         end
 
-        def flatpickr_time!(attribute, label: {}, field: {}, show_errors: true)
+        def time_flatpickr!(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(:flatpickr_time, attribute, field),
+              public_send(:time_flatpickr, attribute, field),
               show_errors && inline_errors(attribute),
               %(</div>).html_safe,
             ])
           end
         end
 
-        def password_field!(attribute, label: {}, field: {}, show_errors: true)
+        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),
@@ -233,10 +224,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),
@@ -245,10 +236,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),
@@ -257,10 +248,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),

data/lib/super/form/field_transcript.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Super
+  class Form
+    # Holds a recording of a form field definition
+    class FieldTranscript
+      def initialize
+        @super = false
+      end
+
+      attr_reader :method_name
+      attr_reader :args
+      attr_reader :kwargs
+
+      def super
+        @super = true
+        self
+      end
+
+      def super?
+        @super
+      end
+
+      def method_missing(new_method_name, *args, **kwargs)
+        if @method_name.present?
+          method_chain =
+            if super?
+              "super.#{@method_name}"
+            else
+              @method_name.to_s
+            end
+
+          raise Error::AlreadyTranscribed, "This instance already holds a transcription for: #{method_chain}"
+        end
+
+        @method_name = new_method_name
+        @args = args
+        @kwargs = kwargs
+        @method_name
+      end
+    end
+  end
+end

data/lib/super/form/guesser.rb

@@ -24,13 +24,13 @@ module Super
       def attribute_type_for(attribute_name)
         case @model.type_for_attribute(attribute_name).type
         when :datetime
-          @type.flatpickr_datetime
+          @type.datetime_flatpickr
         when :time
-          @type.flatpickr_time
+          @type.time_flatpickr
         when :date
-          @type.flatpickr_date
+          @type.date_flatpickr
         else
-          @type.string
+          @type.text_field
         end
       end
     end

data/lib/super/form/schema_types.rb

@@ -3,6 +3,38 @@
 module Super
   class Form
     class SchemaTypes
+      class Direct
+        def initialize(super_builder:, method_name:, args:, kwargs:)
+          @super_builder = super_builder
+          @method_name = method_name
+          @args = args
+          @kwargs = kwargs
+        end
+
+        attr_reader :super_builder
+        attr_reader :method_name
+        attr_reader :args
+        attr_reader :kwargs
+
+        def nested_fields
+          {}
+        end
+
+        def to_partial_path
+          "form_field"
+        end
+
+        def ==(other)
+          return false if other.class != self.class
+          return false if other.super_builder != super_builder
+          return false if other.method_name != method_name
+          return false if other.args != args
+          return false if other.kwargs != kwargs
+
+          true
+        end
+      end
+
       class Generic
         def initialize(partial_path:, extras:, nested:)
           @partial_path = partial_path
@@ -65,61 +97,73 @@ module Super
         @fields = fields
       end
 
-      def generic(partial_path, **extras)
+      def partial(partial_path, **extras)
         Generic.new(partial_path: partial_path, extras: extras, nested: {})
       end
 
-      def select(**extras)
-        Generic.new(partial_path: "form_field_select", extras: extras, nested: {})
+      def direct(method_name, *args, super_builder: true, **kwargs)
+        Direct.new(super_builder: super_builder, method_name: method_name, args: args, kwargs: kwargs)
       end
 
-      def string(**extras)
-        Generic.new(partial_path: "form_field_text", extras: extras, nested: {})
+      def select(*args, **kwargs)
+        Direct.new(super_builder: true, method_name: :select!, args: args, kwargs: kwargs)
       end
 
-      alias text string
+      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 rich_text_area(**extras)
-        Generic.new(partial_path: "form_field_rich_text_area", extras: extras, nested: {})
+      def date_flatpickr(*args, **kwargs)
+        Direct.new(super_builder: true, method_name: :date_flatpickr!, args: args, kwargs: kwargs)
       end
 
-      def checkbox(**extras)
-        Generic.new(partial_path: "form_field_checkbox", extras: extras, nested: {})
+      def datetime_flatpickr(*args, **kwargs)
+        Direct.new(super_builder: true, method_name: :datetime_flatpickr!, args: args, kwargs: kwargs)
       end
 
-      def flatpickr_date(**extras)
-        Generic.new(partial_path: "form_field_flatpickr_date", extras: extras, nested: {})
+      def hidden_field(*args, **kwargs)
+        Direct.new(super_builder: false, method_name: :hidden_field, args: args, kwargs: kwargs)
       end
 
-      def flatpickr_datetime(**extras)
-        Generic.new(partial_path: "form_field_flatpickr_datetime", extras: extras, nested: {})
+      def password_field(*args, **kwargs)
+        Direct.new(super_builder: true, method_name: :password_field!, args: args, kwargs: kwargs)
       end
 
-      def flatpickr_time(**extras)
-        Generic.new(partial_path: "form_field_flatpickr_time", extras: extras, nested: {})
+      def time_flatpickr(*args, **kwargs)
+        Direct.new(super_builder: true, method_name: :time_flatpickr!, args: args, kwargs: kwargs)
       end
 
       def has_many(reader, **extras)
-        nested = @fields.nested do
-          yield
+        subfields = Schema::Fields.new
+        @fields.nested do
+          yield subfields
         end
 
         Generic.new(
           partial_path: "form_has_many",
           extras: extras.merge(reader: reader),
-          nested: nested
+          nested: subfields.to_h
         )
       end
 
       def has_one(reader, **extras)
-        nested = @fields.nested do
-          yield
+        subfields = Schema::Fields.new
+        @fields.nested do
+          yield subfields
         end
 
         Generic.new(
           partial_path: "form_has_one",
           extras: extras.merge(reader: reader),
-          nested: nested
+          nested: subfields.to_h
         )
       end