super 0.0.2 → 0.0.7

data/lib/super/controls/steps.rb

@@ -0,0 +1,128 @@
+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:)
+        default_for(:load_records, action: action, params: params) do
+          scope(action: action)
+        end
+      end
+
+      # Loads a record using `#scope`
+      #
+      # @param action [ActionInquirer]
+      # @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
+      end
+
+      # Builds a record using `#scope`
+      #
+      # @param action [ActionInquirer]
+      # @return [ActiveRecord::Base]
+      def build_record(action:)
+        default_for(:build_record) do
+          scope(action: action).build
+        end
+      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:)
+        default_for(:build_record_with_params, action: action, params: params) do
+          scope(action: action).build(permitted_params(params, action: action))
+        end
+      end
+
+      # Saves a record
+      #
+      # @param action [ActionInquirer]
+      # @param params [ActionController::Parameters]
+      # @return [ActiveRecord::Base]
+      def save_record(action:, record:, params:)
+        default_for(:save_record, action: action, record: record, params: params) do
+          record.save
+        end
+      end
+
+      # Saves a record
+      #
+      # @param action [ActionInquirer]
+      # @param params [ActionController::Parameters]
+      # @return [ActiveRecord::Base]
+      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
+      end
+
+      # Destroys a record
+      #
+      # @param action [ActionInquirer]
+      # @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
+      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/schema_types.rb

@@ -3,39 +3,111 @@ 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.
     #
-    # Note: The constants under "Defined Under Namespace" are considered
-    # private.
+    # ```
+    # class MembersController::Controls
+    #   # ...
     #
-    #   class MemberDashboard
-    #     # ...
-    #
-    #     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
+    #   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
 
-        def present(field)
-          @transform_block.call(field)
+        def present(value)
+          @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(action_inquirer)
+        @action_inquirer = action_inquirer
+        @actions_called = false
+      end
+
+      def before_yield(fields:)
+        @fields = fields
+      end
+
+      def after_yield
+        return if !@action_inquirer.index?
+        return if @actions_called
+        @fields[:actions] = actions
       end
 
       def dynamic(&transform_block)
         Dynamic.new(transform_block)
       end
+
+      def actions
+        @actions_called = true
+        Bypass.new(partial: "super_schema_display_actions", real: false)
+      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
 end

data/lib/super/engine.rb

@@ -1,9 +1,16 @@
 module Super
+  # Configures the host Rails app to work with Super
   class Engine < ::Rails::Engine
     initializer "super.assets.precompile" do |app|
       if Super::Assets.sprockets_available?
         app.config.assets.precompile << "config/super_manifest.js"
       end
     end
+
+    config.to_prepare do
+      Super::Plugin::Registry.controller.ordered do |klass, method_name|
+        Super::ApplicationController.public_send(method_name, klass)
+      end
+    end
   end
 end

data/lib/super/error.rb

@@ -1,16 +1,17 @@
 module Super
+  # A container class for all internal errors thrown by this library
+  #
+  # See also `Super::ClientError`
   class Error < StandardError
+    # Error raised when some configuration is not set
     class UnconfiguredConfiguration < Error; end
+    # Error raised when a configuration is set to a invalid value
     class InvalidConfiguration < Error; end
-    class InvalidStyle < Error; end
+    # Error raised on problematic plugins, see `Super::Plugin`
     class InvalidPluginArgument < Error; end
+    # Error raised on problematic ActionInquirer settings, see `Super::ActionInquirer`
     class ActionInquirerError < Error; end
-
-    class ClientError < Error; end
-    class BadRequest < ClientError; end
-    class Unauthorized < ClientError; end
-    class Forbidden < ClientError; end
-    class NotFound < ClientError; end
-    class UnprocessableEntity < ClientError; end
+    # Error raised when a `Super::Link` couldn't be found
+    class LinkNotRegistered < Error; end
   end
 end

data/lib/super/filter.rb

@@ -0,0 +1,137 @@
+module Super
+  class Filter
+    module ControllerMethods
+      def index
+        super
+        @filter_form = controls.initialize_filtering(params: params, query_params: request.GET)
+        @records = controls.filter_records(filter_form: @filter_form, records: @records)
+        @view.asides.push(:@filter_form)
+      end
+    end
+
+    class FilterFormField
+      def initialize(humanized_field_name:, field_name:, type:, params:)
+        @humanized_field_name = humanized_field_name
+        @field_name = field_name
+        @field_type = type
+        @params = params
+        @specified_values =
+          type.q
+            .map do |query_field_name|
+              [
+                query_field_name,
+                (params || {})[query_field_name],
+              ]
+            end
+            .to_h
+
+        @specified_values.each do |key, value|
+          define_singleton_method(key) { value }
+        end
+      end
+
+      attr_reader :humanized_field_name
+      attr_reader :field_name
+      attr_reader :field_type
+      attr_reader :specified_values
+
+      def op
+        (@params || {})[:op]
+      end
+
+      def operators
+        @field_type.operators
+          .map { |o| [o.name, o.identifier] }
+          .to_h
+      end
+
+      def to_partial_path
+        @field_type.to_partial_path
+      end
+    end
+
+    def initialize(model:, url:, schema:, params:)
+      @model = model
+      @url = url
+      @schema = schema
+      @params = params
+
+      @form_fields = {}
+    end
+
+    def each_field
+      @schema.fields.each do |field_name, _field_type|
+        yield(form_field_for(field_name))
+      end
+    end
+
+    def url
+      @url
+    end
+
+    def to_partial_path
+      "filter"
+    end
+
+    def to_search_query(relation)
+      each_field do |form_field|
+        next if form_field.specified_values.values.map(&:to_s).map(&:strip).all? { |specified_value| specified_value == "" }
+        next if !Super::Filter::Operator.registry.key?(form_field.op)
+
+        operator = Super::Filter::Operator.registry[form_field.op]
+        updated_relation = operator.filter(relation, form_field.field_name, *form_field.specified_values.values)
+
+        if updated_relation.is_a?(ActiveRecord::Relation)
+          relation = updated_relation
+        end
+      end
+
+      relation
+    end
+
+    private
+
+    def form_field_for(field_name)
+      @form_fields[field_name] ||=
+        FilterFormField.new(
+          humanized_field_name: @model.human_attribute_name(field_name),
+          field_name: field_name,
+          type: @schema.fields[field_name],
+          params: (@params || {})[field_name]
+        )
+    end
+  end
+
+  class Controls
+    module Optional
+      def filters_enabled?
+        actual.respond_to?(:filter_schema)
+      end
+
+      def filter_schema
+        actual.filter_schema
+      end
+    end
+
+    module Steps
+      def initialize_filtering(params:, query_params:)
+        if filters_enabled?
+          Super::Filter.new(
+            model: model,
+            schema: filter_schema,
+            params: params[:q],
+            url: query_params
+          )
+        end
+      end
+
+      def filter_records(filter_form:, records:)
+        if filters_enabled? && records
+          filter_form.to_search_query(records)
+        else
+          records
+        end
+      end
+    end
+  end
+end

data/lib/super/filter/operator.rb

@@ -0,0 +1,103 @@
+module Super
+  class Filter
+    module Operator
+      class Definition
+        def initialize(identifier, name, filter)
+          @identifier = identifier
+          @name = name
+          @filter = filter
+        end
+
+        attr_reader :identifier
+        attr_reader :name
+
+        def filter(*args)
+          @filter.call(args)
+        end
+      end
+
+      class << self
+        def registry
+          @registry ||= {}
+        end
+
+        def range_defaults
+          [
+            registry["between"],
+          ]
+        end
+
+        def select_defaults
+          [
+            registry["eq"],
+            registry["neq"],
+          ]
+        end
+
+        def text_defaults
+          [
+            registry["eq"],
+            registry["neq"],
+            registry["contain"],
+            registry["ncontain"],
+            registry["start"],
+            registry["end"],
+          ]
+        end
+
+        def define(identifier, name, &filter)
+          identifier = identifier.to_s
+          name = name.to_s
+
+          definition = Definition.new(identifier, name, filter)
+
+          registry[identifier] = definition
+
+          define_singleton_method(identifier) do
+            registry[identifier]
+          end
+        end
+      end
+
+      define("eq", "equals") do |relation, field, query|
+        relation.where(field => query)
+      end
+
+      define("neq", "doesn't equal") do |relation, field, query|
+        relation.where.not(field => query)
+      end
+
+      define("contain", "contains") do |relation, field, query|
+        query = "%#{Compatability.sanitize_sql_like(query)}%"
+        relation.where("#{field} LIKE ?", "%#{query}%")
+      end
+
+      define("ncontain", "doesn't contain") do |relation, field, query|
+        query = "%#{Compatability.sanitize_sql_like(query)}%"
+        relation.where("#{field} NOT LIKE ?", query)
+      end
+
+      define("start", "starts with") do |relation, field, query|
+        query = "#{Compatability.sanitize_sql_like(query)}%"
+        relation.where("#{field} LIKE ?", query)
+      end
+
+      define("end", "ends with") do |relation, field, query|
+        query = "%#{Compatability.sanitize_sql_like(query)}"
+        relation.where("#{field} LIKE ?", query)
+      end
+
+      define("between", "between") do |relation, field, query0, query1|
+        if query0.present?
+          relation = relation.where("#{field} >= ?", query0)
+        end
+
+        if query1.present?
+          relation = relation.where("#{field} <= ?", query1)
+        end
+
+        relation
+      end
+    end
+  end
+end