super 0.0.7 → 0.0.12

data/lib/super/controls/steps.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Super
   class Controls
     # Methods that are called by controller actions. All of these methods have
@@ -10,9 +12,7 @@ module Super
       # @param params [ActionController::Parameters]
       # @return [ActiveRecord::Relation]
       def load_records(action:, params:)
-        default_for(:load_records, action: action, params: params) do
-          scope(action: action)
-        end
+        scope(action: action)
       end
 
       # Loads a record using `#scope`
@@ -21,9 +21,7 @@ module Super
       # @param params [ActionController::Parameters]
       # @return [ActiveRecord::Base]
       def load_record(action:, params:)
-        default_for(:load_record, action: action, params: params) do
-          scope(action: action).find(params[:id])
-        end
+        scope(action: action).find(params[:id])
       end
 
       # Builds a record using `#scope`
@@ -31,9 +29,7 @@ module Super
       # @param action [ActionInquirer]
       # @return [ActiveRecord::Base]
       def build_record(action:)
-        default_for(:build_record) do
-          scope(action: action).build
-        end
+        scope(action: action).build
       end
 
       # Builds and populates a record using `#scope`
@@ -42,31 +38,25 @@ module Super
       # @param params [ActionController::Parameters]
       # @return [ActiveRecord::Base]
       def build_record_with_params(action:, params:)
-        default_for(:build_record_with_params, action: action, params: params) do
-          scope(action: action).build(permitted_params(params, action: action))
-        end
+        scope(action: action).build(permitted_params(params, action: action))
       end
 
       # Saves a record
       #
       # @param action [ActionInquirer]
       # @param params [ActionController::Parameters]
-      # @return [ActiveRecord::Base]
+      # @return [true, false]
       def save_record(action:, record:, params:)
-        default_for(:save_record, action: action, record: record, params: params) do
-          record.save
-        end
+        record.save
       end
 
       # Saves a record
       #
       # @param action [ActionInquirer]
       # @param params [ActionController::Parameters]
-      # @return [ActiveRecord::Base]
+      # @return [true, false]
       def update_record(action:, record:, params:)
-        default_for(:update_record, action: action, record: record, params: params) do
-          record.update(permitted_params(params, action: action))
-        end
+        record.update(permitted_params(params, action: action))
       end
 
       # Destroys a record
@@ -75,53 +65,41 @@ module Super
       # @param params [ActionController::Parameters]
       # @return [ActiveRecord::Base, false]
       def destroy_record(action:, record:, params:)
-        default_for(:update_record, action: action, record: record, params: params) do
-          record.destroy
-        end
+        record.destroy
       end
 
-      def build_index_view
-        Super::Layout.new(
-          mains: [
-            Super::Panel.new(
-              Super::Partial.new("collection_header"),
-              :@display
-            ),
-          ]
+      def initialize_query_form(params:, current_path:)
+        Super::Query::FormObject.new(
+          model: model,
+          params: params,
+          namespace: :q,
+          current_path: current_path,
         )
       end
 
-      def build_show_view
-        Super::Layout.new(
-          mains: [
-            Super::Panel.new(
-              Super::Partial.new("member_header"),
-              :@display
-            ),
-          ]
-        )
+      def apply_queries(query_form:, records:)
+        query_form.apply_changes(records)
       end
 
-      def build_new_view
-        Super::Layout.new(
-          mains: [
-            Super::Panel.new(
-              Super::Partial.new("collection_header"),
-              :@form
-            ),
-          ]
-        )
+      def initialize_filter_form(query_form:)
+        if filters_enabled?
+          query_form.add(
+            Super::Filter::FormObject,
+            namespace: :f,
+            schema: filter_schema
+          )
+        end
       end
 
-      def build_edit_view
-        Super::Layout.new(
-          mains: [
-            Super::Panel.new(
-              Super::Partial.new("member_header"),
-              :@form
-            ),
-          ]
-        )
+      def initialize_sort_form(query_form:)
+        if sort_enabled?
+          query_form.add(
+            Super::Sort::FormObject,
+            namespace: :s,
+            default: default_sort,
+            sortable_columns: sortable_columns
+          )
+        end
       end
     end
   end

data/lib/super/controls/view.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Super
+  class Controls
+    # Methods for `Controls` that have a sane default implementation
+    module View
+      def index_view
+        Super::Layout.new(
+          mains: [
+            Super::Panel.new(
+              Super::Partial.new("collection_header"),
+              :@display
+            ),
+          ],
+          asides: [
+            :@query_form,
+          ]
+        )
+      end
+
+      def show_view
+        Super::Layout.new(
+          mains: [
+            Super::Panel.new(
+              Super::Partial.new("member_header"),
+              :@display
+            ),
+          ]
+        )
+      end
+
+      def new_view
+        Super::Layout.new(
+          mains: [
+            Super::Panel.new(
+              Super::Partial.new("collection_header"),
+              :@form
+            ),
+          ]
+        )
+      end
+
+      def edit_view
+        Super::Layout.new(
+          mains: [
+            Super::Panel.new(
+              Super::Partial.new("member_header"),
+              :@form
+            ),
+          ]
+        )
+      end
+    end
+  end
+end

data/lib/super/display.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+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
+    include Schema::Common
+
+    def initialize
+      @fields = Super::Schema::Fields.new
+      @schema_types = SchemaTypes.new(fields: @fields)
+
+      yield(@fields, @schema_types)
+    end
+
+    def apply(action:)
+      @action_inquirer = action
+      return self if !@action_inquirer.index?
+      return self if @schema_types.actions_called?
+      @fields[:actions] = @schema_types.actions
+      self
+    end
+
+    def to_partial_path
+      if @action_inquirer.nil?
+        raise Super::Error::Initalization,
+          "You must call the `#apply` method after instantiating Super::Display"
+      elsif @action_inquirer.index?
+        "display_index"
+      elsif @action_inquirer.show?
+        "display_show"
+      else
+        "display_#{@action_inquirer.action}"
+      end
+    end
+
+    # @private
+    def render_attribute(template:, record:, column:)
+      formatter = @fields[column]
+      formatter = formatter.build if formatter.respond_to?(:build)
+
+      formatted =
+        SchemaTypes::TYPES
+        .case(formatter.type)
+        .when(:record) do
+          formatter.present(column, record)
+        end
+        .when(:column) do
+          value = record.public_send(column)
+          formatter.present(column, value)
+        end
+        .when(:none) do
+          formatter.present(column)
+        end
+        .result
+
+      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,36 @@
+# frozen_string_literal: true
+
+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,112 +1,114 @@
+# frozen_string_literal: true
+
 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)
-          @transform_block = transform_block
-        end
+      TYPES = Useful::Enum.new(:column, :record, :none)
+
+      class Builder
+        extend Useful::Builder
 
-        def present(value)
-          @transform_block.call(value)
+        builder_with_block def transform(&block)
+          @transform_block = block
         end
 
-        def real?
-          true
+        builder def real; @real = true; end
+        builder def computed; @real = false; end
+
+        builder def column; @type = :column; end
+        builder def record; @type = :record; end
+        builder def none; @type = :none; end
+
+        builder def ignore_nil; @ignore_nil = true; end
+
+        def build
+          Built.new(
+            real: @real,
+            type: @type,
+            ignore_nil: !!@ignore_nil,
+            &@transform_block
+          )
         end
       end
 
-      class Bypass
-        def initialize(partial:, real:)
-          @partial = partial
+      class Built
+        def initialize(real:, type:, ignore_nil:, &transform_block)
           @real = real
+          @type = type
+          @ignore_nil = ignore_nil
+          @transform_block = transform_block
         end
 
-        def present
-          Partial.new(@partial)
-        end
+        def real?; @real; end
+        attr_reader :type
+
+        def present(attribute_name, value = nil)
+          if @transform_block.nil?
+            if attribute_name
+              raise Error::ArgumentError, "Transformation block is not set for column: #{attribute_name}"
+            else
+              raise Error::ArgumentError, "Transformation block is not set!"
+            end
+          end
+
+          return nil if value.nil? && @ignore_nil
 
-        def real?
-          @real
+          if @type == :none
+            @transform_block.call
+          else
+            @transform_block.call(value)
+          end
         end
       end
 
-      def initialize(action_inquirer)
-        @action_inquirer = action_inquirer
+      def initialize(fields:)
         @actions_called = false
+        @fields = fields
       end
 
-      def before_yield(fields:)
-        @fields = fields
+      def real(type = :column, &transform_block)
+        TYPES
+          .case(type)
+          .when(:column) { Builder.new.real.ignore_nil.column.transform(&transform_block) }
+          .when(:record) { Builder.new.real.ignore_nil.record.transform(&transform_block) }
+          .when(:none)   { Builder.new.real.ignore_nil.none.transform(&transform_block) }
+          .result
       end
 
-      def after_yield
-        return if !@action_inquirer.index?
-        return if @actions_called
-        @fields[:actions] = actions
+      def computed(type = :column, &transform_block)
+        TYPES
+          .case(type)
+          .when(:column) { Builder.new.computed.ignore_nil.column.transform(&transform_block) }
+          .when(:record) { Builder.new.computed.ignore_nil.record.transform(&transform_block) }
+          .when(:none)   { Builder.new.computed.ignore_nil.none.transform(&transform_block) }
+          .result
       end
 
-      def dynamic(&transform_block)
-        Dynamic.new(transform_block)
+      def manual(&transform_block)
+        real(:column, &transform_block)
       end
 
-      def actions
-        @actions_called = true
-        Bypass.new(partial: "super_schema_display_actions", real: false)
+      def string; real(&:to_s); end
+      alias text string
+
+      def timestamp; real(&:to_s); end
+
+      def rich_text
+        real do |value|
+          Partial.new("display_rich_text", locals: { rich_text: value })
+        end
       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}"
+      def actions
+        @actions_called = true
+        Builder.new.computed.none.transform do
+          Partial.new("display_actions")
         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
+      def actions_called?
+        @actions_called
       end
     end
   end