super 0.0.1 → 0.0.6

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

data/lib/super/navigation/automatic.rb

@@ -1,5 +1,7 @@
 module Super
   class Navigation
+    # Traverses the defined Rails Routes and attempts to build a list of links.
+    # This is used for building the nav bar on each admin page.
     class Automatic
       def initialize(route_namespace:)
         route_namespace = route_namespace.to_s

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,20 @@ module Super
         yield(page_query_params, is_current_page, display)
       end
     end
+
+    private
+
+    def pages
+      @pages ||=
+        begin
+          quotient, remainder = @total_count.divmod(@limit)
+
+          if remainder.zero?
+            quotient
+          else
+            quotient + 1
+          end
+        end
+    end
   end
 end

data/lib/super/panel.rb

@@ -0,0 +1,30 @@
+require "super/partial/resolving"
+
+module Super
+  class Panel
+    include Super::Partial::Resolving
+
+    def initialize(*parts)
+      if block_given?
+        @parts = Array.new(yield)
+      end
+
+      @parts = parts
+    end
+
+    attr_reader :parts
+
+    def resolve(template, block)
+      @resolved_parts ||= resolve_for_rendering(template, parts, block)
+      self
+    end
+
+    def resolved_parts
+      @resolved_parts || []
+    end
+
+    def to_partial_path
+      "super_panel"
+    end
+  end
+end

data/lib/super/partial.rb

@@ -0,0 +1,11 @@
+module Super
+  class Partial
+    def initialize(path, locals: {})
+      @to_partial_path = path
+      @locals = locals
+    end
+
+    attr_reader :to_partial_path
+    attr_reader :locals
+  end
+end

data/lib/super/partial/resolving.rb

@@ -0,0 +1,24 @@
+module Super
+  class Partial
+    module Resolving
+      module_function
+
+      def resolve_for_rendering(template, partials, block)
+        if block
+          partials = [block.call, *parts]
+        end
+
+        partials =
+          partials.map do |partial|
+            if partial.is_a?(Symbol)
+              template.instance_variable_get(partial)
+            else
+              partial
+            end
+          end
+
+        partials.compact
+      end
+    end
+  end
+end

data/lib/super/schema.rb

@@ -8,11 +8,15 @@ module Super
     # @param schema_type [Display::SchemaTypes, Form::SchemaTypes]
     def initialize(schema_type)
       @schema_type = schema_type
-      @fields = {}
+      @fields = Fields.new
+
+      @schema_type.before_yield(fields: @fields)
 
       if block_given?
         yield(@fields, @schema_type)
       end
+
+      @schema_type.after_yield
     end
 
     attr_reader :fields
@@ -20,5 +24,64 @@ module Super
     def field_keys
       fields.keys
     end
+
+    def to_partial_path
+      @schema_type.to_partial_path
+    end
+
+    # This class can be thought of as a Hash, where the keys usually refer to
+    # the model's column name and the value refers to the column type. Note
+    # though that this isn't always the case—different `SchemaTypes` can do
+    # whatever makes sense in their context
+    class Fields
+      include Enumerable
+
+      def initialize
+        @backing = {}
+      end
+
+      def [](key)
+        @backing[key]
+      end
+
+      def []=(key, value)
+        @backing[key] = value
+      end
+
+      def keys
+        @backing.keys
+      end
+
+      def values
+        @backing.values
+      end
+
+      def each(&block)
+        if block_given?
+          return @backing.each(&block)
+        end
+
+        enum_for(:each)
+      end
+
+      def replace(other)
+        @backing = other
+      end
+
+      def to_h
+        @backing
+      end
+
+      def nested
+        outside = @backing
+        inside = {}
+        @backing = inside
+        yield
+        return inside
+      ensure
+        @backing = outside
+        inside
+      end
+    end
   end
 end