super 0.0.7 → 0.0.12

data/lib/super/engine.rb

@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 module Super
   # Configures the host Rails app to work with Super
   class Engine < ::Rails::Engine
+    isolate_namespace Super
+
     initializer "super.assets.precompile" do |app|
-      if Super::Assets.sprockets_available?
+      if Super::Assets::Handler.sprockets_available?
         app.config.assets.precompile << "config/super_manifest.js"
       end
     end

data/lib/super/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Super
   # A container class for all internal errors thrown by this library
   #
@@ -13,5 +15,24 @@ module Super
     class ActionInquirerError < Error; end
     # Error raised when a `Super::Link` couldn't be found
     class LinkNotRegistered < Error; end
+    # Error raised when rendering if `@view` wasn't set by the controller
+    class NothingToRender < Error
+      def initialize(basename)
+        super(
+          "Super's built-in `#{basename}.html.erb` requires `@view` to be set " \
+          "by the controller, but it wasn't set"
+        )
+      end
+    end
+    # Error raised when something wasn't initalized correctly, and if there isn't
+    # a more specific error
+    class Initalization < Error; end
+    class ArgumentError < Error; end
+
+    class Enum < Error
+      class ImpossibleValue < Enum; end
+      class ArgumentError < Enum; end
+      class UndefinedCase < Enum; end
+    end
   end
 end

data/lib/super/filter.rb

@@ -1,137 +1,14 @@
+# frozen_string_literal: true
+
 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
-
-    class FilterFormField
-      def initialize(humanized_field_name:, field_name:, type:, params:)
-        @humanized_field_name = humanized_field_name
-        @field_name = field_name
-        @field_type = type
-        @params = params
-        @specified_values =
-          type.q
-            .map do |query_field_name|
-              [
-                query_field_name,
-                (params || {})[query_field_name],
-              ]
-            end
-            .to_h
-
-        @specified_values.each do |key, value|
-          define_singleton_method(key) { value }
-        end
-      end
-
-      attr_reader :humanized_field_name
-      attr_reader :field_name
-      attr_reader :field_type
-      attr_reader :specified_values
-
-      def op
-        (@params || {})[:op]
-      end
-
-      def operators
-        @field_type.operators
-          .map { |o| [o.name, o.identifier] }
-          .to_h
-      end
-
-      def to_partial_path
-        @field_type.to_partial_path
-      end
-    end
-
-    def initialize(model:, url:, schema:, params:)
-      @model = model
-      @url = url
-      @schema = schema
-      @params = params
-
-      @form_fields = {}
-    end
-
-    def each_field
-      @schema.fields.each do |field_name, _field_type|
-        yield(form_field_for(field_name))
-      end
-    end
-
-    def url
-      @url
-    end
-
-    def to_partial_path
-      "filter"
-    end
-
-    def to_search_query(relation)
-      each_field do |form_field|
-        next if form_field.specified_values.values.map(&:to_s).map(&:strip).all? { |specified_value| specified_value == "" }
-        next if !Super::Filter::Operator.registry.key?(form_field.op)
+    def initialize
+      @schema_type = Filter::SchemaTypes.new
+      @fields = Schema::Fields.new
 
-        operator = Super::Filter::Operator.registry[form_field.op]
-        updated_relation = operator.filter(relation, form_field.field_name, *form_field.specified_values.values)
-
-        if updated_relation.is_a?(ActiveRecord::Relation)
-          relation = updated_relation
-        end
-      end
-
-      relation
+      yield(@fields, @schema_type)
     end
 
-    private
-
-    def form_field_for(field_name)
-      @form_fields[field_name] ||=
-        FilterFormField.new(
-          humanized_field_name: @model.human_attribute_name(field_name),
-          field_name: field_name,
-          type: @schema.fields[field_name],
-          params: (@params || {})[field_name]
-        )
-    end
-  end
-
-  class Controls
-    module Optional
-      def filters_enabled?
-        actual.respond_to?(:filter_schema)
-      end
-
-      def filter_schema
-        actual.filter_schema
-      end
-    end
-
-    module Steps
-      def initialize_filtering(params:, query_params:)
-        if filters_enabled?
-          Super::Filter.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
+    attr_reader :fields
   end
 end

data/lib/super/filter/form_object.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Super
+  class Filter
+    class FormObject
+      class FilterFormField
+        def initialize(humanized_field_name:, field_name:, type:, params:)
+          @humanized_field_name = humanized_field_name
+          @field_name = field_name
+          @field_type = type
+          @params = params
+          @specified_values =
+            type.q
+              .map do |query_field_name|
+                [
+                  query_field_name,
+                  (params || {})[query_field_name],
+                ]
+              end
+              .to_h
+
+          @specified_values.each do |key, value|
+            define_singleton_method(key) { value }
+          end
+        end
+
+        attr_reader :humanized_field_name
+        attr_reader :field_name
+        attr_reader :field_type
+        attr_reader :specified_values
+
+        def op
+          (@params || {})[:op]
+        end
+
+        def operators
+          @field_type.operators
+            .map { |o| [o.name, o.identifier] }
+            .to_h
+        end
+
+        def to_partial_path
+          @field_type.to_partial_path
+        end
+      end
+
+      def initialize(model:, params:, schema:)
+        @model = model
+        @params = params
+        @schema = schema
+
+        @form_fields = {}
+      end
+
+      def each_field
+        @schema.fields.each do |field_name, _field_type|
+          yield(form_field_for(field_name))
+        end
+      end
+
+      def to_partial_path
+        "filter"
+      end
+
+      def apply_changes(relation)
+        each_field do |form_field|
+          next if form_field.specified_values.values.map(&:to_s).map(&:strip).all? { |specified_value| specified_value == "" }
+          next if !Super::Filter::Operator.registry.key?(form_field.op)
+
+          operator = Super::Filter::Operator.registry[form_field.op]
+          updated_relation = operator.filter(relation, form_field.field_name, *form_field.specified_values.values)
+
+          if updated_relation.is_a?(ActiveRecord::Relation)
+            relation = updated_relation
+          end
+        end
+
+        relation
+      end
+
+      private
+
+      def form_field_for(field_name)
+        @form_fields[field_name] ||=
+          FilterFormField.new(
+            humanized_field_name: @model.human_attribute_name(field_name),
+            field_name: field_name,
+            type: @schema.fields[field_name],
+            params: (@params || {})[field_name]
+          )
+      end
+    end
+  end
+end

data/lib/super/filter/guesser.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Super
+  class Filter
+    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) }
+          .call
+      end
+
+      private
+
+      def attribute_type_for(attribute_name)
+        type = @model.type_for_attribute(attribute_name).type
+        case type
+        when :datetime
+          @type.timestamp
+        else
+          @type.text
+        end
+      end
+    end
+  end
+end

data/lib/super/filter/operator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Super
   class Filter
     module Operator

data/lib/super/filter/schema_types.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Super
   class Filter
     # This schema type is used to configure the filtering form on your +#index+
@@ -13,7 +15,7 @@ module Super
     #     # ...
     #
     #     def filter_schema
-    #       Super::Schema.new(Super::Filter::SchemaTypes.new) do |fields, type|
+    #       Super::Filter.new do |fields, type|
     #         fields[:name] = type.text(operators: [
     #           Super::Filter::Operator.eq,
     #           Super::Filter::Operator.contain,
@@ -90,12 +92,6 @@ module Super
         end
       end
 
-      def before_yield(fields:)
-      end
-
-      def after_yield
-      end
-
       def select(collection:, operators: Filter::Operator.select_defaults)
         Select.new(
           collection: collection,

data/lib/super/form.rb

@@ -1,48 +1,37 @@
+# frozen_string_literal: true
+
 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
-    module FieldErrorProc
-      def error_wrapping(html_tag)
-        if Thread.current[:super_form_builder]
-          return html_tag
-        end
+    include Schema::Common
 
-        super
-      end
+    def initialize
+      @fields = Schema::Fields.new
+      @schema_types = SchemaTypes.new(fields: @fields)
+      yield(@fields, @schema_types)
     end
 
-    class Builder < ActionView::Helpers::FormBuilder
-      # These methods were originally defined in the following files
-      #
-      # * actionview/lib/action_view/helpers/form_helper.rb
-      # * actionview/lib/action_view/helpers/form_options_helper.rb
-      # * actionview/lib/action_view/helpers/date_helper.rb
-      %w[
-        label text_field password_field hidden_field file_field text_area
-        check_box radio_button color_field search_field telephone_field
-        date_field time_field datetime_field month_field week_field url_field
-        email_field number_field range_field
-
-        select collection_select grouped_collection_select time_zone_select
-        collection_radio_buttons collection_check_boxes
-
-        time_select datetime_select date_select
-      ].each do |field_type_method|
-        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-          def #{field_type_method}(*)
-            Thread.current[:super_form_builder] = true
-            super
-          ensure
-            Thread.current[:super_form_builder] = nil
-          end
-        RUBY
-      end
-
-      alias datetime_local_field datetime_field
-      alias phone_field telephone_field
+    def to_partial_path
+      "form"
     end
   end
 end
-
-ActionView::Helpers::Tags::Base.class_eval do
-  prepend Super::Form::FieldErrorProc
-end

data/lib/super/form/builder.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+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