super 0.0.5 → 0.0.10

data/lib/super/filter/plugin.rb

@@ -0,0 +1,47 @@
+module Super
+  class Filter
+    module ControllerMethods
+      def index
+        super
+        @filter_form = controls.initialize_filtering(params: params, query_params: request.GET)
+        @records = controls.filter_records(filter_form: @filter_form, records: @records)
+        @view.asides.push(:@filter_form)
+      end
+    end
+  end
+
+  class Controls
+    module Optional
+      def filters_enabled?
+        true
+      end
+
+      def filter_schema
+        Filter.new do |fields, type|
+          Filter::Guesser.new(model: model, fields: fields, type: type).call
+        end
+      end
+    end
+
+    module Steps
+      def initialize_filtering(params:, query_params:)
+        if filters_enabled?
+          Super::Filter::FormObject.new(
+            model: model,
+            schema: filter_schema,
+            params: params[:q],
+            url: query_params
+          )
+        end
+      end
+
+      def filter_records(filter_form:, records:)
+        if filters_enabled? && records
+          filter_form.to_search_query(records)
+        else
+          records
+        end
+      end
+    end
+  end
+end

data/lib/super/filter/schema_types.rb

@@ -0,0 +1,112 @@
+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
+
+        attr_reader :operators
+
+        def to_partial_path
+          @partial_path
+        end
+
+        def q
+          [:q]
+        end
+      end
+
+      class Select
+        def initialize(collection:, operators:)
+          @collection = collection
+          @operators = operators
+        end
+
+        attr_reader :collection
+        attr_reader :operators
+
+        def to_partial_path
+          "filter_type_select"
+        end
+
+        def q
+          [:q]
+        end
+      end
+
+      class Timestamp
+        def initialize(operators:)
+          @operators = operators
+        end
+
+        attr_reader :operators
+
+        def to_partial_path
+          "filter_type_timestamp"
+        end
+
+        def q
+          [:q0, :q1]
+        end
+      end
+
+      def select(collection:, operators: Filter::Operator.select_defaults)
+        Select.new(
+          collection: collection,
+          operators: operators
+        )
+      end
+
+      def text(operators: Filter::Operator.text_defaults)
+        Text.new(
+          partial_path: "filter_type_text",
+          operators: operators
+        )
+      end
+
+      def timestamp(operators: Filter::Operator.range_defaults)
+        Timestamp.new(operators: operators)
+      end
+    end
+  end
+end

data/lib/super/form.rb

@@ -0,0 +1,35 @@
+module Super
+  # This schema type is used on your +#edit+ and +#new+ forms
+  #
+  # ```ruby
+  # class MembersController::Controls
+  #   # ...
+  #
+  #   def new_schema
+  #     Super::Form.new do |fields, type|
+  #       fields[:name] = type.string
+  #       fields[:rank] = type.select
+  #       fields[:position] = type.string
+  #       fields[:ship_id] = type.select(
+  #         collection: Ship.all.map { |s| ["#{s.name} (Ship ##{s.id})", s.id] },
+  #       )
+  #     end
+  #   end
+  #
+  #   # ...
+  # end
+  # ```
+  class Form
+    include Schema::Common
+
+    def initialize
+      @fields = Schema::Fields.new
+      @schema_types = SchemaTypes.new(fields: @fields)
+      yield(@fields, @schema_types)
+    end
+
+    def to_partial_path
+      "super_schema_form"
+    end
+  end
+end

data/lib/super/form/builder.rb

@@ -0,0 +1,204 @@
+module Super
+  class Form
+    # 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 Builder < 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 = 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 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 password_field(attribute, options = {})
+          options, defaults = split_defaults(options, class: "super-input w-full")
+          options[:class] = join_classes(defaults[:class], options[:class])
+
+          @builder.password_field(attribute, options)
+        end
+
+        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
+
+        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[: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)
+        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
+
+        def text_field(attribute, options = {})
+          options, defaults = split_defaults(options, class: "super-input w-full")
+          options[:class] = join_classes(defaults[:class], options[:class])
+
+          @builder.text_field(attribute, options)
+        end
+
+        def container(&block)
+          @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)
+          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),
+              "</div>".html_safe,
+              show_errors && inline_errors(attribute),
+            ])
+          end
+        end
+
+        def password_field!(attribute, label: {}, field: {}, show_errors: true)
+          container do
+            compact_join([
+              public_send(:label, attribute, label),
+              %(<div class="mt-1">).html_safe,
+              public_send(:password_field, attribute, field),
+              show_errors && inline_errors(attribute),
+              %(</div>).html_safe,
+            ])
+          end
+        end
+
+        def rich_text_area!(attribute, label: {}, field: {}, show_errors: true)
+          container do
+            compact_join([
+              public_send(:label, attribute, label),
+              %(<div class="mt-1">).html_safe,
+              public_send(:rich_text_area, attribute, field),
+              show_errors && inline_errors(attribute),
+              %(</div>).html_safe,
+            ])
+          end
+        end
+
+        def select!(attribute, collection, label: {}, field: {}, show_errors: true)
+          container do
+            compact_join([
+              public_send(:label, attribute, label),
+              %(<div class="mt-1">).html_safe,
+              public_send(:select, attribute, collection, field),
+              show_errors && inline_errors(attribute),
+              %(</div>).html_safe,
+            ])
+          end
+        end
+
+        def text_field!(attribute, label: {}, field: {}, show_errors: true)
+          container do
+            compact_join([
+              public_send(:label, attribute, label),
+              %(<div class="mt-1">).html_safe,
+              public_send(:text_field, attribute, field),
+              show_errors && inline_errors(attribute),
+              %(</div>).html_safe,
+            ])
+          end
+        end
+
+        private
+
+        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
+end

data/lib/super/form/guesser.rb

@@ -0,0 +1,27 @@
+module Super
+  class Form
+    class Guesser
+      def initialize(model:, fields:, type:)
+        @model = model
+        @fields = fields
+        @type = type
+      end
+
+      def call
+        Schema::Guesser
+          .new(model: @model, fields: @fields, type: @type)
+          .assign_type { |attribute_name| attribute_type_for(attribute_name) }
+          .reject { |attribute_name| attribute_name == "id" }
+          .reject { |attribute_name| attribute_name == "created_at" }
+          .reject { |attribute_name| attribute_name == "updated_at" }
+          .call
+      end
+
+      private
+
+      def attribute_type_for(attribute_name)
+        @type.string
+      end
+    end
+  end
+end

data/lib/super/form/inline_errors.rb

@@ -0,0 +1,26 @@
+module Super
+  class Form
+    module InlineErrors
+      module_function
+
+      def error_messages(model_instance, column_or_association)
+        errable_fields(model_instance, column_or_association)
+          .flat_map { |field| Compatability.errable_fields(field) }
+          .flat_map { |field| model_instance.errors.full_messages_for(field) }
+          .uniq
+      end
+
+      def errable_fields(model_instance, column_or_association)
+        column_or_association = column_or_association.to_s
+        reflection = model_instance.class.reflect_on_association(column_or_association)
+        reflection ||= model_instance.class.reflections.values.find { |r| r.foreign_key == column_or_association }
+
+        if reflection
+          [reflection.name.to_s, reflection.foreign_key.to_s]
+        else
+          [column_or_association]
+        end
+      end
+    end
+  end
+end