super 0.0.2 → 0.0.7

data/lib/super/filter/schema_types.rb

@@ -0,0 +1,118 @@
+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::Schema.new(Super::Filter::SchemaTypes.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 before_yield(fields:)
+      end
+
+      def after_yield
+      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,48 @@
+module Super
+  class Form
+    module FieldErrorProc
+      def error_wrapping(html_tag)
+        if Thread.current[:super_form_builder]
+          return html_tag
+        end
+
+        super
+      end
+    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
+    end
+  end
+end
+
+ActionView::Helpers::Tags::Base.class_eval do
+  prepend Super::Form::FieldErrorProc
+end

data/lib/super/form/schema_types.rb

@@ -2,33 +2,41 @@ module Super
   class Form
     # This schema type is used on your +#edit+ and +#new+ forms
     #
-    # Note: The constants under "Defined Under Namespace" are considered
-    # private.
+    # ```ruby
+    # class MembersController::Controls
+    #   # ...
     #
-    #   class MemberDashboard
-    #     # ...
-    #
-    #     def new_schema
-    #       Super::Schema.new(Super::Form::SchemaTypes.new) do |fields, type|
-    #         fields[:name] = type.generic("write_type_text")
-    #         fields[:rank] = type.generic("write_type_select", collection: Member.ranks.keys)
-    #         fields[:position] = type.generic("write_type_text")
-    #         fields[:ship_id] = type.generic(
-    #           "write_type_select",
-    #           collection: Ship.all.map { |s| ["#{s.name} (Ship ##{s.id})", s.id] },
-    #         )
-    #       end
+    #   def new_schema
+    #     Super::Schema.new(Super::Form::SchemaTypes.new) do |fields, type|
+    #       fields[:name] = type.generic("form_field_text")
+    #       fields[:rank] = type.generic("form_field_select", collection: Member.ranks.keys)
+    #       fields[:position] = type.generic("form_field_text")
+    #       fields[:ship_id] = type.generic(
+    #         "form_field_select",
+    #         collection: Ship.all.map { |s| ["#{s.name} (Ship ##{s.id})", s.id] },
+    #       )
     #     end
-    #
-    #     # ...
     #   end
+    #
+    #   # ...
+    # end
+    # ```
     class SchemaTypes
       class Generic
-        def initialize(partial_path:, extras:)
+        def initialize(partial_path:, extras:, nested:)
           @partial_path = partial_path
           @extras = extras
+          @nested_fields = nested
         end
 
+        attr_reader :nested_fields
+
+        # This takes advantage of a feature of Rails. If the value of
+        # `#to_partial_path` is `my_form_field`, Rails renders
+        # `app/views/super/application/_my_form_field.html.erb`, and this
+        # instance of Generic is accessible via `my_form_field`
+        #
+        # @return [String] the filename of the partial that will be rendered.
         def to_partial_path
           @partial_path
         end
@@ -36,11 +44,78 @@ module Super
         def [](key)
           @extras[key]
         end
+
+        def reader
+          @extras[:reader]
+        end
+
+        def label
+          if @extras.key?(:label)
+            return @extras[:label]
+          end
+
+          if @extras.key?(:reader)
+            return @extras[:reader].to_s.singularize.humanize
+          end
+        end
+
+        def ==(other)
+          return false if other.class != self.class
+          return false if other.instance_variable_get(:@partial_path) != @partial_path
+          return false if other.instance_variable_get(:@extras) != @extras
+          return false if other.instance_variable_get(:@nested_fields) != @nested_fields
+
+          true
+        end
+      end
+
+      def before_yield(fields:)
+        @fields = fields
+      end
+
+      def after_yield
+      end
+
+      def generic(partial_path, **extras)
+        Generic.new(partial_path: partial_path, extras: extras, nested: {})
+      end
+
+      def has_many(reader, **extras)
+        nested = @fields.nested do
+          yield
+        end
+
+        Generic.new(
+          partial_path: "form_has_many",
+          extras: extras.merge(reader: reader),
+          nested: nested
+        )
+      end
+
+      def has_one(reader, **extras)
+        nested = @fields.nested do
+          yield
+        end
+
+        Generic.new(
+          partial_path: "form_has_one",
+          extras: extras.merge(reader: reader),
+          nested: nested
+        )
+      end
+
+      alias_method :belongs_to, :has_one
+
+      def _destroy(**extras)
+        Generic.new(
+          partial_path: "form_field__destroy",
+          extras: extras,
+          nested: {}
+        )
       end
 
-      def generic(partial_path, extras = nil)
-        extras ||= {}
-        Generic.new(partial_path: partial_path, extras: extras)
+      def to_partial_path
+        "super_schema_form"
       end
     end
   end

data/lib/super/layout.rb

@@ -0,0 +1,47 @@
+require "super/partial/resolving"
+
+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
+    end
+
+    attr_reader :headers
+    attr_reader :asides
+    attr_reader :mains
+    attr_reader :footers
+
+    def to_partial_path
+      "super_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

data/lib/super/link.rb

@@ -0,0 +1,110 @@
+module Super
+  # Links have three required attributes that are passed directly into Rails'
+  # `link_to` helper
+  class Link
+    def self.find_all(*links)
+      links.map { |link| find(link) }
+    end
+
+    def self.find(link)
+      if link.kind_of?(self)
+        return link
+      end
+
+      if registry.key?(link)
+        return registry[link]
+      end
+
+      raise Error::LinkNotRegistered, "Unknown link `#{link}`"
+    end
+
+    def self.registry
+      @registry ||= {
+        new: new(
+          "New",
+          -> (params:) {
+            Rails.application.routes.url_for(
+              controller: params[:controller],
+              action: :new,
+              only_path: true
+            )
+          }
+        ),
+        index: new(
+          "Index",
+          -> (params:) {
+            Rails.application.routes.url_for(
+              controller: params[:controller],
+              action: :index,
+              only_path: true
+            )
+          }
+        ),
+        show: new(
+          "View",
+          -> (record:, params:) {
+            Rails.application.routes.url_for(
+              controller: params[:controller],
+              action: :show,
+              id: record,
+              only_path: true
+            )
+          }
+        ),
+        edit: new(
+          "Edit",
+          -> (record:, params:) {
+            Rails.application.routes.url_for(
+              controller: params[:controller],
+              action: :edit,
+              id: record,
+              only_path: true
+            )
+          }
+        ),
+        destroy: new(
+          "Delete",
+          -> (record:, params:) {
+            Rails.application.routes.url_for(
+              controller: params[:controller],
+              action: :destroy,
+              id: record,
+              only_path: true
+            )
+          },
+          method: :delete,
+          data: { confirm: "Really delete?" }
+        ),
+      }
+    end
+
+    def initialize(text, href, **options)
+      @text = text
+      @href = href
+      @options = options
+    end
+
+    def to_s(default_options: nil, **proc_arguments)
+      default_options ||= {}
+      ActionController::Base.helpers.link_to(
+        value(text, proc_arguments),
+        value(href, proc_arguments),
+        default_options.deep_merge(value(options, proc_arguments))
+      )
+    end
+
+    private
+
+    attr_reader :text
+    attr_reader :href
+    attr_reader :options
+
+    def value(proc_or_value, proc_arguments)
+      if proc_or_value.kind_of?(Proc)
+        proc_or_value.call(**proc_arguments)
+      else
+        proc_or_value
+      end
+    end
+  end
+end