super 0.0.6 → 0.0.11

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,33 +1,17 @@
+# 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)
+        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 +35,33 @@ 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 rich_text
+        Dynamic.new do |value|
+          Partial.new("display_rich_text", locals: { rich_text: value })
+        end
       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,8 +69,9 @@ module Super
         Bypass.new(partial: "super_schema_display_actions", real: false)
       end
 
-      def to_partial_path
-        "super_schema_display_#{@action_inquirer.action}"
+      # @private
+      def actions_called?
+        @actions_called
       end
     end
   end

data/lib/super/engine.rb

@@ -1,10 +1,20 @@
+# frozen_string_literal: true
+
 module Super
   # Configures the host Rails app to work with Super
   class Engine < ::Rails::Engine
+    isolate_namespace Super
+
     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
+
+    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,3 +1,5 @@
+# frozen_string_literal: true
+
 module Super
   # A container class for all internal errors thrown by this library
   #
@@ -13,5 +15,17 @@ module Super
     class ActionInquirerError < Error; end
     # Error raised when a `Super::Link` couldn't be found
     class LinkNotRegistered < Error; end
+    # Error raised when rendering if `@view` wasn't set by the controller
+    class NothingToRender < Error
+      def initialize(basename)
+        super(
+          "Super's built-in `#{basename}.html.erb` requires `@view` to be set " \
+          "by the controller, but it wasn't set"
+        )
+      end
+    end
+    # Error raised when something wasn't initalized correctly, and if there isn't
+    # a more specific error
+    class Initalization < Error; end
   end
 end

data/lib/super/filter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Super
+  class Filter
+    def initialize
+      @schema_type = Filter::SchemaTypes.new
+      @fields = Schema::Fields.new
+
+      yield(@fields, @schema_type)
+    end
+
+    attr_reader :fields
+  end
+end

data/lib/super/filter/form_object.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+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:, params:, schema:)
+        @model = model
+        @params = params
+        @schema = schema
+
+        @form_fields = {}
+      end
+
+      def each_field
+        @schema.fields.each do |field_name, _field_type|
+          yield(form_field_for(field_name))
+        end
+      end
+
+      def to_partial_path
+        "filter"
+      end
+
+      def apply_changes(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,32 @@
+# frozen_string_literal: true
+
+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/operator.rb

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

data/lib/super/filter/schema_types.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Super
+  class Filter
+    # This schema type is used to configure the filtering form on your +#index+
+    # action.
+    #
+    # The +operators:+ keyword argument can be left out in each case. There is
+    # a default set of operators that are provided.
+    #
+    # Note: The constants under "Defined Under Namespace" are considered
+    # private.
+    #
+    #   class MemberDashboard
+    #     # ...
+    #
+    #     def filter_schema
+    #       Super::Filter.new do |fields, type|
+    #         fields[:name] = type.text(operators: [
+    #           Super::Filter::Operator.eq,
+    #           Super::Filter::Operator.contain,
+    #           Super::Filter::Operator.ncontain,
+    #           Super::Filter::Operator.start,
+    #           Super::Filter::Operator.end,
+    #         ])
+    #         fields[:rank] = type.select(collection: Member.ranks.values)
+    #         fields[:position] = type.text(operators: [
+    #           Super::Filter::Operator.eq,
+    #           Super::Filter::Operator.neq,
+    #           Super::Filter::Operator.contain,
+    #           Super::Filter::Operator.ncontain,
+    #         ])
+    #         fields[:ship_id] = type.select(
+    #           collection: Ship.all.map { |s| ["#{s.name} (Ship ##{s.id})", s.id] },
+    #         )
+    #         fields[:created_at] = type.timestamp
+    #         fields[:updated_at] = type.timestamp
+    #       end
+    #     end
+    #
+    #     # ...
+    #   end
+    class SchemaTypes
+      class Text
+        def initialize(partial_path:, operators:)
+          @partial_path = partial_path
+          @operators = operators
+        end
+
+        attr_reader :operators
+
+        def to_partial_path
+          @partial_path
+        end
+
+        def q
+          [:q]
+        end
+      end
+
+      class Select
+        def initialize(collection:, operators:)
+          @collection = collection
+          @operators = operators
+        end
+
+        attr_reader :collection
+        attr_reader :operators
+
+        def to_partial_path
+          "filter_type_select"
+        end
+
+        def q
+          [:q]
+        end
+      end
+
+      class Timestamp
+        def initialize(operators:)
+          @operators = operators
+        end
+
+        attr_reader :operators
+
+        def to_partial_path
+          "filter_type_timestamp"
+        end
+
+        def q
+          [:q0, :q1]
+        end
+      end
+
+      def select(collection:, operators: Filter::Operator.select_defaults)
+        Select.new(
+          collection: collection,
+          operators: operators
+        )
+      end
+
+      def text(operators: Filter::Operator.text_defaults)
+        Text.new(
+          partial_path: "filter_type_text",
+          operators: operators
+        )
+      end
+
+      def timestamp(operators: Filter::Operator.range_defaults)
+        Timestamp.new(operators: operators)
+      end
+    end
+  end
+end