super 0.0.4 → 0.0.9

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

@@ -1,5 +1,9 @@
+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
@@ -15,5 +19,29 @@ module Super
     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

@@ -2,7 +2,11 @@ module Super
   # Links have three required attributes that are passed directly into Rails'
   # `link_to` helper
   class Link
-    def self.resolve(link)
+    def self.find_all(*links)
+      links.map { |link| find(link) }
+    end
+
+    def self.find(link)
       if link.kind_of?(self)
         return link
       end
@@ -16,61 +20,61 @@ module Super
 
     def self.registry
       @registry ||= {
-        new: -> (params:) {
-          new(
-            "New",
+        new: new(
+          "New",
+          -> (params:) {
             Rails.application.routes.url_for(
               controller: params[:controller],
               action: :new,
               only_path: true
             )
-          )
-        },
-        index: -> (params:) {
-          new(
-            "Index",
+          }
+        ),
+        index: new(
+          "Index",
+          -> (params:) {
             Rails.application.routes.url_for(
               controller: params[:controller],
               action: :index,
               only_path: true
             )
-          )
-        },
-        show: -> (resource, params:) {
-          new(
-            "View",
+          }
+        ),
+        show: new(
+          "View",
+          -> (record:, params:) {
             Rails.application.routes.url_for(
               controller: params[:controller],
               action: :show,
-              id: resource,
+              id: record,
               only_path: true
             )
-          )
-        },
-        edit: -> (resource, params:) {
-          new(
-            "Edit",
+          }
+        ),
+        edit: new(
+          "Edit",
+          -> (record:, params:) {
             Rails.application.routes.url_for(
               controller: params[:controller],
               action: :edit,
-              id: resource,
+              id: record,
               only_path: true
             )
-          )
-        },
-        destroy: -> (resource, params:) {
-          new(
-            "Delete",
+          }
+        ),
+        destroy: new(
+          "Delete",
+          -> (record:, params:) {
             Rails.application.routes.url_for(
               controller: params[:controller],
               action: :destroy,
-              id: resource,
+              id: record,
               only_path: true
-            ),
-            method: :delete,
-            data: { confirm: "Really delete?" }
-          )
-        },
+            )
+          },
+          method: :delete,
+          data: { confirm: "Really delete?" }
+        ),
       }
     end
 
@@ -80,8 +84,27 @@ module Super
       @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

@@ -52,6 +52,10 @@ module Super
       end
     end
 
+    def to_partial_path
+      "super_pagination"
+    end
+
     private
 
     def pages
@@ -66,5 +70,56 @@ module Super
           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

data/lib/super/panel.rb

@@ -1,5 +1,9 @@
+require "super/partial/resolving"
+
 module Super
   class Panel
+    include Super::Partial::Resolving
+
     def initialize(*parts)
       if block_given?
         @parts = Array.new(yield)
@@ -10,6 +14,15 @@ module Super
 
     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

data/lib/super/partial.rb

@@ -1,5 +1,17 @@
 module Super
   class Partial
+    def self.render(partialish, template:)
+      if partialish.respond_to?(:to_partial_path)
+        if partialish.respond_to?(:locals)
+          template.render(partialish, partialish.locals)
+        else
+          template.render(partialish)
+        end
+      else
+        partialish
+      end
+    end
+
     def initialize(path, locals: {})
       @to_partial_path = path
       @locals = locals

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/plugin.rb

@@ -1,88 +1,59 @@
 module Super
-  class Pluggable < Module
-    def initialize(registry_name)
-      @registry_name = registry_name
-    end
-
-    def included(base)
-      super
-
-      PluginRegistry.base_set(@registry_name, base)
-
-      plugins = PluginRegistry.plugins_for(@registry_name)
-
-      plugins.each do |klass, method_name|
-        base.public_send(method_name, klass)
+  module Plugin
+    class Registry
+      class << self
+        def controller
+          @controller ||= Registry.new
+        end
       end
-    end
-  end
 
-  class PluginRegistry
-    class << self
-      def include_to(name, klass)
-        plugin_push(name.to_sym, :include, klass)
+      def initialize
+        @registry = {}
+        @ordering = Hash.new { |hash, key| hash[key] = [] }
       end
 
-      def prepend_to(name, klass)
-        plugin_push(name.to_sym, :prepend, klass)
+      def use(include: nil, prepend: nil)
+        register(include: include, prepend: prepend, before: [], after: [])
       end
 
-      def plugins_for(name)
-        name = name.to_sym
-
-        plugins.fetch(name) { {} }
+      def insert_before(*before, include: nil, prepend: nil)
+        register(include: include, prepend: prepend, before: before, after: [])
       end
 
-      def base_set(name, klass)
-        name = name.to_sym
-
-        if !klass.kind_of?(Class)
-          raise Error::InvalidPluginArgument,
-            "Received `#{klass}` which must be a class"
-        end
-
-        bases[name] = klass
-
-        true
+      def insert_after(*after, include: nil, prepend: nil)
+        register(include: include, prepend: prepend, before: [], after: after)
       end
 
-      def base_get(name)
-        name = name.to_sym
+      def classes_ordered
+        each_node = -> (&b) { @ordering.each_key(&b) }
+        each_child = -> (cb, &b) { @ordering[cb].each(&b) }
 
-        bases[name]
+        TSort.tsort(each_node, each_child)
       end
 
-      private
-
-      def plugin_push(name, method_name, klass)
-        if ![:include, :prepend].include?(method_name)
-          raise Error::InvalidPluginArgument,
-            "Received `#{method_name.inspect}`, must be either :include or :prepend"
+      def ordered
+        classes_ordered.each do |class_name|
+          yield class_name, @registry[class_name]
         end
+      end
 
-        if !klass.kind_of?(Module)
-          raise Error::InvalidPluginArgument,
-            "Received `#{klass}` which must be a module"
-        end
+      private
 
-        plugins[name] ||= {}
-        plugins[name][klass] = method_name
+      def register(include:, prepend:, before: [], after: [])
+        raise Error::InvalidPluginArgument, "only one of :include or :prepend can be filled out" if include && prepend
+        raise Error::InvalidPluginArgument, "at least one of :include or :prepend must be filled out" if include.nil? && prepend.nil?
 
-        base = base_get(name)
+        klass = include || prepend
+        @registry[klass] = :include if include
+        @registry[klass] = :prepend if prepend
 
-        if base
-          base.public_send(method_name, klass)
+        before.each do |b|
+          @ordering[b].push(klass)
         end
 
-        true
-      end
-
-      def plugins
-        @plugins ||= {}
-      end
+        @ordering[klass].push(*after)
 
-      def bases
-        @bases ||= {}
+        nil
       end
     end
   end