super 0.0.6 → 0.0.11

data/lib/super/layout.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "super/partial/resolving"
 
 module Super

data/lib/super/link.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Super
   # Links have three required attributes that are passed directly into Rails'
   # `link_to` helper

data/lib/super/navigation/automatic.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Super
   class Navigation
     # Traverses the defined Rails Routes and attempts to build a list of links.

data/lib/super/pagination.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Super
   class Pagination
     include Enumerable
@@ -52,6 +54,10 @@ module Super
       end
     end
 
+    def to_partial_path
+      "super_pagination"
+    end
+
     private
 
     def pages
@@ -66,5 +72,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,3 +1,5 @@
+# frozen_string_literal: true
+
 require "super/partial/resolving"
 
 module Super

data/lib/super/partial.rb

@@ -1,5 +1,19 @@
+# frozen_string_literal: true
+
 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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Super
   class Partial
     module Resolving

data/lib/super/plugin.rb

@@ -1,88 +1,61 @@
-module Super
-  class Pluggable < Module
-    def initialize(registry_name)
-      @registry_name = registry_name
-    end
-
-    def included(base)
-      super
+# frozen_string_literal: true
 
-      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 Super
+  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/query/form_object.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Super
+  class Query
+    class FormObject
+      def initialize(model:, params:, namespace:, current_path:)
+        @model = model
+        @all_params = params.dup
+        @namespace = namespace
+        @params = params[namespace] || ActionController::Parameters.new
+        @path = current_path
+        @addons = {}
+      end
+
+      attr_reader :namespace
+      attr_reader :path
+      attr_reader :addons
+
+      def add(klass, namespace:, **additional_initialization_arguments)
+        instance = klass.new(
+          model: @model,
+          params: params_dig(namespace),
+          **additional_initialization_arguments
+        )
+
+        addons[namespace] = instance
+      end
+
+      def apply_changes(records)
+        addons.each_value do |addon|
+          records = addon.apply_changes(records)
+        end
+
+        records
+      end
+
+      def to_partial_path
+        "query"
+      end
+
+      private
+
+      def params_dig(*keys)
+        @params.dig(*keys) || ActionController::Parameters.new
+      end
+    end
+  end
+end

data/lib/super/schema.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Super
   # The Schema is a general purpose container for describing the "schema"
   # for various purposes. It primarily exists to provide a cohesive user-facing
@@ -5,30 +7,6 @@ module Super
   #
   # The various "schema types" are likely of more interest
   class Schema
-    # @param schema_type [Display::SchemaTypes, Form::SchemaTypes]
-    def initialize(schema_type)
-      @schema_type = schema_type
-      @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
-
-    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

data/lib/super/schema/common.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Super
+  class Schema
+    module Common
+      def each_attribute_name
+        if block_given?
+          @fields.keys.each do |key|
+            yield(key)
+          end
+        end
+
+        enum_for(:each_attribute_name)
+      end
+
+      def each_attribute
+        if block_given?
+          @fields.each do |key, value|
+            yield(key, value)
+          end
+        end
+
+        enum_for(:each_attribute)
+      end
+    end
+  end
+end

data/lib/super/schema/guesser.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Super
+  class Schema
+    class Guesser
+      def initialize(model:, fields:, type:)
+        @model = model
+        @fields = fields
+        @type = type
+        @rejects = []
+      end
+
+      def limit
+        @limit = yield
+        self
+      end
+
+      def reject(&block)
+        @rejects.push(block)
+        self
+      end
+
+      def ignore_foreign_keys
+        @rejects.push(-> (attribute_name) { is_foreign_key[attribute_name] })
+        self
+      end
+
+      def assign_type(&block)
+        @assign_type = block
+        self
+      end
+
+      def call
+        result = sorted_attribute_names
+        result = @rejects.reduce(result) do |intermediary_result, rejection_proc|
+          intermediary_result.reject(&rejection_proc)
+        end
+
+        result = result.first(@limit) if @limit && @limit != Float::INFINITY
+
+        result.each do |name|
+          @fields[name] = @assign_type.call(name)
+        end
+      end
+
+      private
+
+      def sorted_attribute_names
+        @model
+          .attribute_names
+          .sort_by { |name| sort_weight[name] }
+      end
+
+      def sort_weight
+        @sort_weight ||= Hash.new do |hash, name|
+          hash[name] =
+            case name
+            when "id" then 0
+            when "title" then 1000
+            when "name" then 1300
+            when "created_at" then 9500
+            when "updated_at" then 9750
+            else
+              2000 + hash.size
+            end
+        end
+      end
+
+      def is_foreign_key
+        @is_foreign_key ||=
+          @model
+          .reflect_on_all_associations
+          .select { |a| a.macro == :belongs_to }
+          .map { |a| [a.foreign_key, true] }
+          .to_h
+      end
+    end
+  end
+end