super 0.0.12 → 0.17.0

data/lib/super/error.rb

@@ -28,6 +28,8 @@ module Super
     # a more specific error
     class Initalization < Error; end
     class ArgumentError < Error; end
+    class AlreadyRegistered < Error; end
+    class AlreadyTranscribed < Error; end
 
     class Enum < Error
       class ImpossibleValue < Enum; end

data/lib/super/filter.rb

@@ -3,7 +3,7 @@
 module Super
   class Filter
     def initialize
-      @schema_type = Filter::SchemaTypes.new
+      @schema_type = SchemaTypes.new
       @fields = Schema::Fields.new
 
       yield(@fields, @schema_type)

data/lib/super/filter/form_object.rb

@@ -3,58 +3,95 @@
 module Super
   class Filter
     class FormObject
-      class FilterFormField
-        def initialize(humanized_field_name:, field_name:, type:, params:)
-          @humanized_field_name = humanized_field_name
+      class AttributeForm
+        def initialize(model:, field_name:, operators:, params:)
+          @model = model
           @field_name = field_name
-          @field_type = type
-          @params = params
+          @operators = operators
+          @params = params || {}
+        end
+
+        attr_reader :model
+        attr_reader :field_name
+        attr_reader :operators
+        attr_reader :params
+
+        def each_operator
+          return enum_for(:each_operator) if !block_given?
+
+          @operators.each do |operator|
+            operator_form = OperatorForm.new(
+              operator: operator,
+              params: @params[operator.identifier]
+            )
+
+            yield(operator_form)
+          end
+        end
+
+        def humanized_attribute_name
+          @model.human_attribute_name(@field_name)
+        end
+      end
+
+      class OperatorForm
+        NULLARY = :_apply
+
+        def initialize(operator:, params:)
+          @operator = operator
+          @params = params || {}
+          query_parameter_keys = operator.query_parameter_keys
+          query_parameter_keys = [NULLARY] if query_parameter_keys.empty?
           @specified_values =
-            type.q
-              .map do |query_field_name|
-                [
-                  query_field_name,
-                  (params || {})[query_field_name],
-                ]
-              end
-              .to_h
+            query_parameter_keys
+            .map { |key| [key, @params[key].presence&.strip] }
+            .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
+        def specified?
+          @specified_values.any? { |_key, value| value }
+        end
+
+        attr_reader :operator
         attr_reader :specified_values
 
-        def op
-          (@params || {})[:op]
+        def identifier
+          @operator.identifier
         end
 
-        def operators
-          @field_type.operators
-            .map { |o| [o.name, o.identifier] }
-            .to_h
-        end
+        def each_field
+          return enum_for(:each_field) if !block_given?
 
-        def to_partial_path
-          @field_type.to_partial_path
+          @specified_values.each do |key, _value|
+            yield(key)
+          end
         end
       end
 
       def initialize(model:, params:, schema:)
         @model = model
-        @params = params
+        @params = params || {}
         @schema = schema
 
         @form_fields = {}
       end
 
-      def each_field
-        @schema.fields.each do |field_name, _field_type|
-          yield(form_field_for(field_name))
+      def each_attribute
+        return enum_for(:each_attribute) if !block_given?
+
+        @schema.fields.each do |field_name, field_operators|
+          attribute_form = AttributeForm.new(
+            model: @model,
+            field_name: field_name,
+            operators: field_operators,
+            params: @params[field_name]
+          )
+
+          yield(attribute_form)
         end
       end
 
@@ -63,32 +100,21 @@ module Super
       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)
+        each_attribute do |attribute_form|
+          attribute_form.each_operator do |operator_form|
+            next if operator_form.specified_values.values.map(&:to_s).map(&:presence).none?
 
-          operator = Super::Filter::Operator.registry[form_field.op]
-          updated_relation = operator.filter(relation, form_field.field_name, *form_field.specified_values.values)
+            operator_behavior = operator_form.operator.behavior
+            updated_relation = operator_behavior.call(relation, attribute_form.field_name, **operator_form.specified_values)
 
-          if updated_relation.is_a?(ActiveRecord::Relation)
-            relation = updated_relation
+            if updated_relation.is_a?(ActiveRecord::Relation)
+              relation = updated_relation
+            end
           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

@@ -23,6 +23,8 @@ module Super
         case type
         when :datetime
           @type.timestamp
+        when :boolean
+          @type.boolean
         else
           @type.text
         end

data/lib/super/filter/operator.rb

@@ -2,100 +2,126 @@
 
 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 Operator
       class << self
         def registry
           @registry ||= {}
         end
 
-        def range_defaults
-          [
-            registry["between"],
-          ]
+        def [](key)
+          registry.fetch(key.to_s)
         end
 
-        def select_defaults
-          [
-            registry["eq"],
-            registry["neq"],
-          ]
+        def register(identifier, operator)
+          identifier = identifier.to_s
+          if registry.key?(identifier)
+            raise Error::AlreadyRegistered, "Already registered: #{identifier}"
+          end
+
+          registry[identifier] = operator
         end
 
-        def text_defaults
-          [
-            registry["eq"],
-            registry["neq"],
-            registry["contain"],
-            registry["ncontain"],
-            registry["start"],
-            registry["end"],
-          ]
+        def define(identifier, display, &block)
+          operator = new(identifier, display, &block).freeze
+          register(identifier, operator)
+          operator
         end
+      end
 
-        def define(identifier, name, &filter)
-          identifier = identifier.to_s
-          name = name.to_s
+      def initialize(identifier, display, &behavior)
+        @identifier = identifier.to_s
+        @humanized_operator_name = display
+        self.behavior = behavior
+      end
+
+      def behavior=(behavior)
+        behavior_params = behavior.parameters
+        if behavior_params.size < 2
+          raise Error::ArgumentError, "Operator behavior must include `column_name` and `relation`"
+        end
+        if behavior_params[0][0] != :req && behavior_params[0][0] != :opt
+          raise Error::ArgumentError, "First argument `relation` must be a required, positional argument"
+        end
+        if behavior_params[1][0] != :req && behavior_params[1][0] != :opt
+          raise Error::ArgumentError, "Second argument `column_name` must be a required, positional argument"
+        end
+        if !behavior_params[2..-1].all? { |(type, _name)| type == :keyreq }
+          raise Error::ArgumentError, "All query parameter keys must be required, keyword arguments"
+        end
+        @behavior = behavior
+        @query_parameter_keys = behavior_params[2..-1].map(&:last)
+      end
 
-          definition = Definition.new(identifier, name, filter)
+      attr_reader :identifier
+      attr_reader :query_parameter_keys
+      attr_reader :humanized_operator_name
 
-          registry[identifier] = definition
+      def behavior(&block)
+        self.behavior = block if block_given?
+        @behavior
+      end
 
-          define_singleton_method(identifier) do
-            registry[identifier]
-          end
-        end
+      define("eq", "Equals") do |relation, field, q:|
+        relation.where(field => q)
       end
 
-      define("eq", "equals") do |relation, field, query|
-        relation.where(field => query)
+      define("neq", "Doesn't equal") do |relation, field, q:|
+        relation.where.not(field => q)
       end
 
-      define("neq", "doesn't equal") do |relation, field, query|
-        relation.where.not(field => query)
+      define("null", "Is NULL") do |relation, field|
+        relation.where(field => nil)
       end
 
-      define("contain", "contains") do |relation, field, query|
-        query = "%#{Compatability.sanitize_sql_like(query)}%"
-        relation.where("#{field} LIKE ?", "%#{query}%")
+      define("nnull", "Isn't NULL") do |relation, field|
+        relation.where.not(field => nil)
       end
 
-      define("ncontain", "doesn't contain") do |relation, field, query|
-        query = "%#{Compatability.sanitize_sql_like(query)}%"
-        relation.where("#{field} NOT LIKE ?", query)
+      define("true", "Is true") do |relation, field|
+        relation.where(field => true)
+      end
+
+      define("false", "Is false") do |relation, field|
+        relation.where(field => false)
+      end
+
+      define("empty", "Is empty") do |relation, field|
+        relation.where(field => "")
       end
 
-      define("start", "starts with") do |relation, field, query|
-        query = "#{Compatability.sanitize_sql_like(query)}%"
-        relation.where("#{field} LIKE ?", query)
+      define("nempty", "Isn't empty") do |relation, field|
+        relation.where.not(field => "")
       end
 
-      define("end", "ends with") do |relation, field, query|
-        query = "%#{Compatability.sanitize_sql_like(query)}"
-        relation.where("#{field} LIKE ?", query)
+      define("blank", "Is blank") do |relation, field|
+        relation.where(field => [nil, ""])
+      end
+
+      define("nblank", "Isn't blank") do |relation, field|
+        relation.where.not(field => [nil, ""])
+      end
+
+      define("contain", "Contains") do |relation, field, q:|
+        query = "%#{Compatability.sanitize_sql_like(q)}%"
+        if relation.connection.adapter_name == "PostgreSQL"
+          relation.where("#{field} ILIKE ?", query)
+        else
+          relation.where("#{field} LIKE ?", query)
+        end
+      end
+
+      define("ncontain", "Doesn't contain") do |relation, field, q:|
+        query = "%#{Compatability.sanitize_sql_like(q)}%"
+        relation.where("#{field} NOT LIKE ?", query)
       end
 
-      define("between", "between") do |relation, field, query0, query1|
-        if query0.present?
-          relation = relation.where("#{field} >= ?", query0)
+      define("between", "Between") do |relation, field, q0:, q1:|
+        if q0.present?
+          relation = relation.where("#{field} >= ?", q0)
         end
 
-        if query1.present?
-          relation = relation.where("#{field} <= ?", query1)
+        if q1.present?
+          relation = relation.where("#{field} <= ?", q1)
         end
 
         relation

data/lib/super/filter/schema_types.rb

@@ -2,112 +2,95 @@
 
 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
+      class OperatorList
+        include Enumerable
 
-        attr_reader :operators
+        def initialize(*new_operators)
+          @operators = {}
+          @operator_transcript = {}
+          @fallback_transcript = nil
 
-        def to_partial_path
-          @partial_path
+          push(*new_operators)
         end
 
-        def q
-          [:q]
-        end
-      end
+        def push(*new_operators)
+          new_operators.flatten.map(&:dup).each do |new_operator|
+            new_identifier = new_operator.identifier.to_s
+
+            raise Error::AlreadyRegistered if @operators.key?(new_identifier)
 
-      class Select
-        def initialize(collection:, operators:)
-          @collection = collection
-          @operators = operators
+            @operators[new_identifier] = new_operator
+          end
+
+          nil
         end
 
-        attr_reader :collection
-        attr_reader :operators
+        alias add push
+
+        def each
+          return enum_for(:each) if !block_given?
 
-        def to_partial_path
-          "filter_type_select"
+          @operators.each do |identifier, operator|
+            yield(
+              OperatorWithFieldTranscript.new(
+                operator,
+                @operator_transcript[identifier] || @fallback_transcript
+              )
+            )
+          end
         end
 
-        def q
-          [:q]
+        def transcribe(operator_identifier = nil)
+          transcript = Form::FieldTranscript.new
+          yield transcript
+
+          if operator_identifier.nil?
+            @fallback_transcript = transcript
+          else
+            @operator_transcript[operator_identifier.to_s] = transcript
+          end
+
+          self
         end
       end
 
-      class Timestamp
-        def initialize(operators:)
-          @operators = operators
+      class OperatorWithFieldTranscript
+        def initialize(operator, field_transcript)
+          @operator = operator
+          @field_transcript = field_transcript
         end
 
-        attr_reader :operators
-
-        def to_partial_path
-          "filter_type_timestamp"
+        Super::Filter::Operator.instance_methods(false).each do |name|
+          delegate name, to: :@operator
         end
 
-        def q
-          [:q0, :q1]
-        end
+        attr_reader :field_transcript
+      end
+
+      def use(*identifiers)
+        found_operators = identifiers.flatten.map { |id| Operator[id] }
+        OperatorList.new(*found_operators)
+      end
+
+      def select(collection)
+        use("eq", "null", "nnull")
+          .transcribe { |f| f.super.select(collection) }
       end
 
-      def select(collection:, operators: Filter::Operator.select_defaults)
-        Select.new(
-          collection: collection,
-          operators: operators
-        )
+      def text
+        use("contain", "ncontain", "blank", "nblank")
       end
 
-      def text(operators: Filter::Operator.text_defaults)
-        Text.new(
-          partial_path: "filter_type_text",
-          operators: operators
-        )
+      def timestamp
+        use("between", "null", "nnull")
+          .transcribe { |f| f.super.datetime_flatpickr }
       end
 
-      def timestamp(operators: Filter::Operator.range_defaults)
-        Timestamp.new(operators: operators)
+      def boolean
+        use("true", "false", "null", "nnull")
       end
     end
   end