super 0.0.3 → 0.0.8

data/lib/super/controls.rb

@@ -1,41 +1,13 @@
+require "super/controls/optional"
+require "super/controls/required"
+require "super/controls/steps"
+
 module Super
-  # A wrapper around the per-controller Controls classes. This class often
-  # directly delegates to the per-controller classes, but it can also provide
-  # some default implementation.
+  # The base Controls class. Most parts of Super can be configured by
+  # customizing its methods.
   class Controls
-    def initialize(actual)
-      @actual = actual
-    end
-
-    attr_reader :actual
-
-    def title
-      @actual.title
-    end
-
-    def model
-      @actual.model
-    end
-
-    # @param action [ActionInquirer]
-    def scope(action:)
-      @actual.scope(action: action)
-    end
-
-    # @param params [ActionController::Parameters]
-    # @param action [ActionInquirer]
-    def permitted_params(params, action:)
-      @actual.permitted_params(params, action: action)
-    end
-
-    # @param action [ActionInquirer]
-    def display_schema(action:)
-      @actual.display_schema(action: action)
-    end
-
-    # @param action [ActionInquirer]
-    def form_schema(action:)
-      @actual.form_schema(action: action)
-    end
+    include Required
+    include Optional
+    include Steps
   end
 end

data/lib/super/controls/optional.rb

@@ -0,0 +1,79 @@
+module Super
+  class Controls
+    # Methods for `Controls` that have a sane default implementation
+    module Optional
+      # This is an optional method
+      #
+      # @return [String]
+      def title
+        model.name.pluralize
+      end
+
+      # Configures what database records are visible on load. This is an optional
+      # method, it defaults to "`all`" methods
+      #
+      # @param action [ActionInquirer]
+      # @return [ActiveRecord::Relation]
+      def scope(action:)
+        model.all
+      end
+
+      # Configures the fields that are displayed on the index and show actions.
+      # This is a required method
+      #
+      # @param action [ActionInquirer]
+      # @return [Display]
+      def display_schema(action:)
+        Display.new(action: action) do |fields, type|
+          Display::Guesser.new(model: model, action: action, fields: fields, type: type).call
+        end
+      end
+
+      # Configures the editable fields on the new and edit actions. This is a
+      # required method
+      #
+      # @param action [ActionInquirer]
+      # @return [Form]
+      def form_schema(action:)
+        Form.new do |fields, type|
+          Form::Guesser.new(model: model, fields: fields, type: type).call
+        end
+      end
+
+      # Configures which parameters could be written to the database. This is a
+      # required method
+      #
+      # @param params [ActionController::Parameters]
+      # @param action [ActionInquirer]
+      # @return [ActionController::Parameters]
+      def permitted_params(params, action:)
+        strong_params = Super::Form::StrongParams.new(form_schema(action: action))
+        params.require(strong_params.require(model)).permit(strong_params.permit)
+      end
+
+      # Configures the actions linked to on the index page. This is an optional
+      # method
+      #
+      # @param action [ActionInquirer]
+      # @return [Array<Link>]
+      def collection_actions(action:)
+        Super::Link.find_all(:new)
+      end
+
+      # Configures the actions linked to on the show page as well as each row of
+      # the table on the index page. This is an optional method
+      #
+      # @param action [ActionInquirer]
+      # @return [Array<Link>]
+      def member_actions(action:)
+        if action.show?
+          Super::Link.find_all(:edit, :destroy)
+        elsif action.edit?
+          Super::Link.find_all(:show, :destroy)
+        else
+          Super::Link.find_all(:show, :edit, :destroy)
+        end
+      end
+    end
+  end
+end

data/lib/super/controls/required.rb

@@ -0,0 +1,13 @@
+module Super
+  class Controls
+    # Methods for `Controls` that must be defined for Super to work properly
+    module Required
+      # Specifies the model. This is a required method
+      #
+      # @return [ActiveRecord::Base]
+      def model
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/super/controls/steps.rb

@@ -0,0 +1,114 @@
+module Super
+  class Controls
+    # Methods that are called by controller actions. All of these methods have
+    # a default implementation, but feel free to override as needed.
+    module Steps
+      # Tells the controller how to load records in the index action using
+      # `#scope`
+      #
+      # @param action [ActionInquirer]
+      # @param params [ActionController::Parameters]
+      # @return [ActiveRecord::Relation]
+      def load_records(action:, params:)
+        scope(action: action)
+      end
+
+      # Loads a record using `#scope`
+      #
+      # @param action [ActionInquirer]
+      # @param params [ActionController::Parameters]
+      # @return [ActiveRecord::Base]
+      def load_record(action:, params:)
+        scope(action: action).find(params[:id])
+      end
+
+      # Builds a record using `#scope`
+      #
+      # @param action [ActionInquirer]
+      # @return [ActiveRecord::Base]
+      def build_record(action:)
+        scope(action: action).build
+      end
+
+      # Builds and populates a record using `#scope`
+      #
+      # @param action [ActionInquirer]
+      # @param params [ActionController::Parameters]
+      # @return [ActiveRecord::Base]
+      def build_record_with_params(action:, params:)
+        scope(action: action).build(permitted_params(params, action: action))
+      end
+
+      # Saves a record
+      #
+      # @param action [ActionInquirer]
+      # @param params [ActionController::Parameters]
+      # @return [true, false]
+      def save_record(action:, record:, params:)
+        record.save
+      end
+
+      # Saves a record
+      #
+      # @param action [ActionInquirer]
+      # @param params [ActionController::Parameters]
+      # @return [true, false]
+      def update_record(action:, record:, params:)
+        record.update(permitted_params(params, action: action))
+      end
+
+      # Destroys a record
+      #
+      # @param action [ActionInquirer]
+      # @param params [ActionController::Parameters]
+      # @return [ActiveRecord::Base, false]
+      def destroy_record(action:, record:, params:)
+        record.destroy
+      end
+
+      def build_index_view
+        Super::Layout.new(
+          mains: [
+            Super::Panel.new(
+              Super::Partial.new("collection_header"),
+              :@display
+            ),
+          ]
+        )
+      end
+
+      def build_show_view
+        Super::Layout.new(
+          mains: [
+            Super::Panel.new(
+              Super::Partial.new("member_header"),
+              :@display
+            ),
+          ]
+        )
+      end
+
+      def build_new_view
+        Super::Layout.new(
+          mains: [
+            Super::Panel.new(
+              Super::Partial.new("collection_header"),
+              :@form
+            ),
+          ]
+        )
+      end
+
+      def build_edit_view
+        Super::Layout.new(
+          mains: [
+            Super::Panel.new(
+              Super::Partial.new("member_header"),
+              :@form
+            ),
+          ]
+        )
+      end
+    end
+  end
+end

data/lib/super/display.rb

@@ -1,9 +1,72 @@
 module Super
+  # This schema type is meant to be used for +#index+ or +#show+ actions to
+  # transform database fields into something that is human friendly.
+  #
+  # ```
+  # class MembersController::Controls
+  #   # ...
+  #
+  #   def show_schema
+  #     Super::Display.new do |fields, type|
+  #       fields[:name] = type.manual { |name| name }
+  #       fields[:rank] = type.manual { |rank| rank }
+  #       fields[:position] = type.manual { |position| position }
+  #       fields[:ship] = type.manual { |ship| "#{ship.name} (Ship ##{ship.id})" }
+  #       fields[:created_at] = type.manual { |created_at| created_at.iso8601 }
+  #       fields[:updated_at] = type.manual { |updated_at| updated_at.iso8601 }
+  #     end
+  #   end
+  #
+  #   # ...
+  # end
+  # ```
   class Display
-    def self.format(schema, resource, column)
-      value = resource.public_send(column)
+    include Schema::Common
 
-      schema.fields[column].present(value)
+    def initialize(action:)
+      @action_inquirer = action
+      @fields = Super::Schema::Fields.new
+      @schema_types = SchemaTypes.new(fields: @fields)
+
+      yield(@fields, @schema_types)
+
+      return if !@action_inquirer.index?
+      return if @schema_types.actions_called?
+      @fields[:actions] = @schema_types.actions
+    end
+
+    def to_partial_path
+      if @action_inquirer.index?
+        "super_schema_display_index"
+      elsif @action_inquirer.show?
+        "super_schema_display_show"
+      else
+        "super_schema_display_#{@action_inquirer.action}"
+      end
+    end
+
+    # @private
+    def render_field(template:, record:, column:)
+      formatter = @fields[column]
+
+      formatted =
+        if formatter.real?
+          value = record.public_send(column)
+          formatter.present(value)
+        else
+          formatter.present
+        end
+
+      if formatted.respond_to?(:to_partial_path)
+        if formatted.respond_to?(:locals)
+          formatted.locals[:record] ||= record
+          template.render(formatted, formatted.locals)
+        else
+          template.render(formatted)
+        end
+      else
+        formatted
+      end
     end
   end
 end

data/lib/super/display/guesser.rb

@@ -0,0 +1,34 @@
+module Super
+  class Display
+    class Guesser
+      def initialize(model:, action:, fields:, type:)
+        @model = model
+        @action_inquirer = action
+        @fields = fields
+        @type = type
+      end
+
+      def call
+        Schema::Guesser
+          .new(model: @model, fields: @fields, type: @type)
+          .ignore_foreign_keys
+          .limit { 5 if @action_inquirer.index? }
+          .assign_type { |attribute_name| attribute_type_for(attribute_name) }
+          .call
+      end
+
+      private
+
+      def attribute_type_for(attribute_name)
+        type = @model.type_for_attribute(attribute_name).type
+
+        case type
+        when :datetime
+          @type.timestamp
+        else
+          @type.text
+        end
+      end
+    end
+  end
+end

data/lib/super/display/schema_types.rb

@@ -1,39 +1,69 @@
 module Super
   class Display
-    # This schema type is meant to be used for +#index+ or +#show+ actions to
-    # transform database fields into something that is human friendly.
-    #
-    # ```
-    # class MembersController::Controls
-    #   # ...
-    #
-    #   def show_schema
-    #     Super::Schema.new(Super::Display::SchemaTypes.new) do |fields, type|
-    #       fields[:name] = type.dynamic { |name| name }
-    #       fields[:rank] = type.dynamic { |rank| rank }
-    #       fields[:position] = type.dynamic { |position| position }
-    #       fields[:ship] = type.dynamic { |ship| "#{ship.name} (Ship ##{ship.id})" }
-    #       fields[:created_at] = type.dynamic { |created_at| created_at.iso8601 }
-    #       fields[:updated_at] = type.dynamic { |updated_at| updated_at.iso8601 }
-    #     end
-    #   end
-    #
-    #   # ...
-    # end
-    # ```
     class SchemaTypes
       class Dynamic
-        def initialize(transform_block)
+        def initialize(ignore_nil: true, &transform_block)
           @transform_block = transform_block
+          @ignore_nil = ignore_nil
         end
 
-        def present(field)
-          @transform_block.call(field)
+        def present(value)
+          return nil if value.nil? && @ignore_nil
+
+          @transform_block.call(value)
+        end
+
+        def real?
+          true
+        end
+      end
+
+      class Bypass
+        def initialize(partial:, real:)
+          @partial = partial
+          @real = real
         end
+
+        def present
+          Partial.new(@partial)
+        end
+
+        def real?
+          @real
+        end
+      end
+
+      def initialize(fields:)
+        @actions_called = false
+        @fields = fields
+      end
+
+      def string
+        Dynamic.new(&:to_s)
+      end
+
+      alias text string
+
+      def timestamp
+        Dynamic.new(&:iso8601)
+      end
+
+      def manual(&transform_block)
+        Dynamic.new(&transform_block)
       end
 
       def dynamic(&transform_block)
-        Dynamic.new(transform_block)
+        Dynamic.new(&transform_block)
+      end
+
+      def actions
+        @actions_called = true
+        Bypass.new(partial: "super_schema_display_actions", real: false)
+      end
+
+      # @private
+      def actions_called?
+        @actions_called
       end
     end
   end