super 0.0.7 → 0.0.8

data/lib/super/display/schema_types.rb

@@ -1,33 +1,15 @@
 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(value)
+          return nil if value.nil? && @ignore_nil
+
           @transform_block.call(value)
         end
 
@@ -51,23 +33,27 @@ module Super
         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 string
+        Dynamic.new(&:to_s)
+      end
+
+      alias text string
+
+      def timestamp
+        Dynamic.new(&:iso8601)
       end
 
-      def after_yield
-        return if !@action_inquirer.index?
-        return if @actions_called
-        @fields[:actions] = actions
+      def manual(&transform_block)
+        Dynamic.new(&transform_block)
       end
 
       def dynamic(&transform_block)
-        Dynamic.new(transform_block)
+        Dynamic.new(&transform_block)
       end
 
       def actions
@@ -75,38 +61,9 @@ module Super
         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
+      def actions_called?
+        @actions_called
       end
     end
   end

data/lib/super/engine.rb

@@ -2,7 +2,7 @@ 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?
+      if Super::Assets::Handler.sprockets_available?
         app.config.assets.precompile << "config/super_manifest.js"
       end
     end

data/lib/super/filter.rb

@@ -1,137 +1,12 @@
 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 initialize
+      @schema_type = Filter::SchemaTypes.new
+      @fields = Schema::Fields.new
 
-    def to_partial_path
-      "filter"
+      yield(@fields, @schema_type)
     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
+    attr_reader :fields
   end
 end

data/lib/super/filter/form_object.rb

@@ -0,0 +1,97 @@
+module Super
+  class Filter
+    class FormObject
+      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
+  end
+end

data/lib/super/filter/guesser.rb

@@ -0,0 +1,30 @@
+module Super
+  class Filter
+    class Guesser
+      def initialize(model:, fields:, type:)
+        @model = model
+        @fields = fields
+        @type = type
+      end
+
+      def call
+        Schema::Guesser
+          .new(model: @model, fields: @fields, type: @type)
+          .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/filter/plugin.rb

@@ -0,0 +1,47 @@
+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
+  end
+
+  class Controls
+    module Optional
+      def filters_enabled?
+        true
+      end
+
+      def filter_schema
+        Filter.new do |fields, type|
+          Filter::Guesser.new(model: model, fields: fields, type: type).call
+        end
+      end
+    end
+
+    module Steps
+      def initialize_filtering(params:, query_params:)
+        if filters_enabled?
+          Super::Filter::FormObject.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/schema_types.rb

@@ -13,7 +13,7 @@ module Super
     #     # ...
     #
     #     def filter_schema
-    #       Super::Schema.new(Super::Filter::SchemaTypes.new) do |fields, type|
+    #       Super::Filter.new do |fields, type|
     #         fields[:name] = type.text(operators: [
     #           Super::Filter::Operator.eq,
     #           Super::Filter::Operator.contain,
@@ -90,12 +90,6 @@ module Super
         end
       end
 
-      def before_yield(fields:)
-      end
-
-      def after_yield
-      end
-
       def select(collection:, operators: Filter::Operator.select_defaults)
         Select.new(
           collection: collection,