super 0.0.2 → 0.0.7

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,81 @@ 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:)
+        default_for(:records_per_page, action: action, query_params: query_params) do
+          Super.configuration.index_records_per_page
+        end
+      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:)
+        default_for(:initialize_pagination, action: action, records: records, query_params: query_params) do
+          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
+      end
+
+      # Paginates
+      #
+      # @param action [ActionInquirer]
+      # @param records [ActiveRecord::Relation]
+      # @param pagination [Pagination]
+      # @return [ActiveRecord::Relation]
+      def paginate_records(action:, records:, pagination:)
+        default_for(:paginate_records, action: action, records: records, pagination: pagination) do
+          records
+            .limit(pagination.limit)
+            .offset(pagination.offset)
+        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,23 @@
+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
+    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/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

data/lib/super/schema.rb

@@ -8,17 +8,81 @@ 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
+    attr_reader :schema_type
 
     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

data/lib/super/version.rb

@@ -1,3 +1,3 @@
 module Super
-  VERSION = "0.0.2"
+  VERSION = "0.0.7"
 end

data/lib/super/view_helper.rb

@@ -0,0 +1,43 @@
+module Super
+  module ViewHelper
+    module_function
+
+    # For example, calling `classes("always", ["sometimes", condition])` would
+    # return the string "always sometimes" or "always"
+    def classes(*list)
+      result = list.map do |c|
+        case c
+        when String
+          c
+        when Array
+          if c.size != 2
+            raise %(Expected exactly two elements (["class", some_condition]), got: #{c.inspect})
+          end
+
+          c.first if c.last
+        end
+      end
+
+      result.compact.join(" ")
+    end
+
+    def errors_accounting_for_reflections(model_instance, column_or_association)
+      errable_fields(model_instance, column_or_association)
+        .flat_map { |field| Compatability.errable_fields(field) }
+        .flat_map { |field| model_instance.errors.full_messages_for(field) }
+        .uniq
+    end
+
+    def errable_fields(model_instance, column_or_association)
+      column_or_association = column_or_association.to_s
+      reflection = model_instance.class.reflect_on_association(column_or_association)
+      reflection ||= model_instance.class.reflections.values.find { |r| r.foreign_key == column_or_association }
+
+      if reflection
+        [reflection.name.to_s, reflection.foreign_key.to_s]
+      else
+        [column_or_association]
+      end
+    end
+  end
+end