super 0.0.3 → 0.0.8

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,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/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/schema_types.rb

@@ -1,26 +1,5 @@
 module Super
   class Form
-    # This schema type is used on your +#edit+ and +#new+ forms
-    #
-    # ```ruby
-    # class MembersController::Controls
-    #   # ...
-    #
-    #   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:, nested:)
@@ -31,6 +10,16 @@ module Super
 
         attr_reader :nested_fields
 
+        def each_attribute
+          if block_given?
+            @nested_fields.each do |key, value|
+              yield(key, value)
+            end
+          end
+
+          enum_for(:each_attribute)
+        end
+
         # 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
@@ -63,13 +52,13 @@ module Super
           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) != @nested
+          return false if other.instance_variable_get(:@nested_fields) != @nested_fields
 
           true
         end
       end
 
-      def setup(fields:)
+      def initialize(fields:)
         @fields = fields
       end
 
@@ -77,6 +66,14 @@ module Super
         Generic.new(partial_path: partial_path, extras: extras, nested: {})
       end
 
+      def select(**extras)
+        Generic.new(partial_path: "form_field_select", extras: extras, nested: {})
+      end
+
+      def string(**extras)
+        Generic.new(partial_path: "form_field_text", extras: extras, nested: {})
+      end
+
       def has_many(reader, **extras)
         nested = @fields.nested do
           yield

data/lib/super/form/strong_params.rb

@@ -0,0 +1,29 @@
+module Super
+  class Form
+    class StrongParams
+      def initialize(form_schema)
+        @form_schema = form_schema
+      end
+
+      def require(model)
+        model.model_name.singular
+      end
+
+      def permit
+        unfurl(@form_schema)
+      end
+
+      private
+
+      def unfurl(responds_to_each_attribute)
+        responds_to_each_attribute.each_attribute.map do |name, type|
+          if type.nested_fields&.any?
+            { name => [:id, *unfurl(type)] }
+          else
+            name
+          end
+        end
+      end
+    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

data/lib/super/pagination.rb

@@ -29,19 +29,15 @@ module Super
         end
     end
 
+    def necessary?
+      pages > 1
+    end
+
     def each
       if !block_given?
         return enum_for(:each)
       end
 
-      quotient, remainder = @total_count.divmod(@limit)
-      pages =
-        if remainder.zero?
-          quotient
-        else
-          quotient + 1
-        end
-
       (1..pages).each do |pageno|
         is_current_page = pageno == current_pageno
         display = pageno.to_s
@@ -55,5 +51,75 @@ module Super
         yield(page_query_params, is_current_page, display)
       end
     end
+
+    def to_partial_path
+      "super_pagination"
+    end
+
+    private
+
+    def pages
+      @pages ||=
+        begin
+          quotient, remainder = @total_count.divmod(@limit)
+
+          if remainder.zero?
+            quotient
+          else
+            quotient + 1
+          end
+        end
+    end
+
+    module ControllerMethods
+      def index
+        super
+        @pagination = controls.initialize_pagination(action: action_inquirer, records: @records, query_params: request.GET)
+        @records = controls.paginate_records(action: action_inquirer, records: @records, pagination: @pagination)
+        @view.mains.first.parts.push(:@pagination)
+      end
+    end
+  end
+
+  class Controls
+    module Optional
+      # Specifies how many records to show per page
+      #
+      # @param action [ActionInquirer]
+      # @param query_params [Hash]
+      # @return [ActiveRecord::Relation]
+      def records_per_page(action:, query_params:)
+        Super.configuration.index_records_per_page
+      end
+    end
+
+    module Steps
+      # Sets up pagination
+      #
+      # @param action [ActionInquirer]
+      # @param records [ActiveRecord::Relation]
+      # @param query_params [Hash]
+      # @return [Pagination]
+      def initialize_pagination(action:, records:, query_params:)
+        Pagination.new(
+          total_count: records.size,
+          limit: records_per_page(action: action, query_params: query_params),
+          query_params: query_params,
+          page_query_param: :page
+        )
+      end
+
+      # Paginates
+      #
+      # @param action [ActionInquirer]
+      # @param records [ActiveRecord::Relation]
+      # @param pagination [Pagination]
+      # @return [ActiveRecord::Relation]
+      def paginate_records(action:, records:, pagination:)
+        records
+          .limit(pagination.limit)
+          .offset(pagination.offset)
+      end
+    end
   end
 end