super 0.0.16 → 0.17.0

data/frontend/super-frontend/dist/application.js

@@ -413,7 +413,7 @@ var Super = (function (exports) {
         }).call(this);
         (function () {
           var AcceptHeaders, CSRFProtection, createXHR, cspNonce, prepareOptions, processResponse;
-          cspNonce = Rails.cspNonce, CSRFProtection = Rails.CSRFProtection, Rails.fire;
+          cspNonce = Rails.cspNonce, CSRFProtection = Rails.CSRFProtection;
           AcceptHeaders = {
             '*': '*/*',
             text: 'text/plain',
@@ -3975,7 +3975,7 @@ var Super = (function (exports) {
     };
   }
 
-  var _default$6 = /*#__PURE__*/function (_Controller) {
+  var _default$8 = /*#__PURE__*/function (_Controller) {
     _inherits(_default, _Controller);
 
     var _super = _createSuper(_default);
@@ -4004,7 +4004,7 @@ var Super = (function (exports) {
     return _default;
   }(Controller);
 
-  var _default$5 = /*#__PURE__*/function (_Controller) {
+  var _default$7 = /*#__PURE__*/function (_Controller) {
     _inherits(_default, _Controller);
 
     var _super = _createSuper(_default);
@@ -4040,7 +4040,7 @@ var Super = (function (exports) {
     return _default;
   }(Controller);
 
-  var _default$4 = /*#__PURE__*/function (_Controller) {
+  var _default$6 = /*#__PURE__*/function (_Controller) {
     _inherits(_default, _Controller);
 
     var _super = _createSuper(_default);
@@ -4064,7 +4064,7 @@ var Super = (function (exports) {
     return _default;
   }(Controller);
 
-  var _default$3 = /*#__PURE__*/function (_Controller) {
+  var _default$5 = /*#__PURE__*/function (_Controller) {
     _inherits(_default, _Controller);
 
     var _super = _createSuper(_default);
@@ -4094,7 +4094,7 @@ var Super = (function (exports) {
     return _default;
   }(Controller);
 
-  var _default$2 = /*#__PURE__*/function (_Controller) {
+  var _default$4 = /*#__PURE__*/function (_Controller) {
     _inherits(_default, _Controller);
 
     var _super = _createSuper(_default);
@@ -6354,7 +6354,7 @@ var Super = (function (exports) {
     window.flatpickr = flatpickr;
   }
 
-  var _default$1 = /*#__PURE__*/function (_Controller) {
+  var _default$3 = /*#__PURE__*/function (_Controller) {
     _inherits(_default, _Controller);
 
     var _super = _createSuper(_default);
@@ -6382,6 +6382,137 @@ var Super = (function (exports) {
     return _default;
   }(Controller);
 
+  var _default$2 = /*#__PURE__*/function (_Controller) {
+    _inherits(_default, _Controller);
+
+    var _super = _createSuper(_default);
+
+    function _default() {
+      _classCallCheck(this, _default);
+
+      return _super.apply(this, arguments);
+    }
+
+    _createClass(_default, [{
+      key: "connect",
+      value: function connect() {
+        var _this = this;
+
+        this.tabTargets.forEach(function (tab) {
+          tab.tabContainer = _this;
+        });
+      }
+    }, {
+      key: "activeTabIdentifier",
+      get: function get() {
+        return this.controlTarget.value;
+      }
+    }, {
+      key: "change",
+      value: function change(event) {
+        this.update(event.target.value);
+      }
+    }, {
+      key: "update",
+      value: function update(newActiveTabIdentifier) {
+        var _this2 = this;
+
+        this.tabTargets.forEach(function (tab) {
+          var tabController = _this2.application.getControllerForElementAndIdentifier(tab, _this2.tabControllerNameValue);
+
+          if (tab.dataset[_this2.tabIdentifierGetterValue] == newActiveTabIdentifier) {
+            tabController.show();
+          } else {
+            tabController.hide();
+          }
+        });
+      }
+    }], [{
+      key: "targets",
+      get: function get() {
+        return ["control", "tab"];
+      }
+    }, {
+      key: "values",
+      get: function get() {
+        return {
+          tabIdentifierGetter: String,
+          tabControllerName: String
+        };
+      }
+    }]);
+
+    return _default;
+  }(Controller);
+
+  var _default$1 = /*#__PURE__*/function (_Controller) {
+    _inherits(_default, _Controller);
+
+    var _super = _createSuper(_default);
+
+    function _default() {
+      _classCallCheck(this, _default);
+
+      return _super.apply(this, arguments);
+    }
+
+    _createClass(_default, [{
+      key: "connect",
+      value: function connect() {
+        var tabContainer = this.element[this.tabContainerGetterValue];
+
+        if (tabContainer.activeTabIdentifier === this.identifierValue) {
+          this.show();
+        } else {
+          this.hide();
+        }
+      }
+    }, {
+      key: "toggle",
+      value: function toggle() {
+        if (this.hasContentTarget) {
+          this.hide();
+        } else {
+          this.show();
+        }
+      }
+    }, {
+      key: "show",
+      value: function show() {
+        if (this.hasContentTarget) {
+          return;
+        }
+
+        var pocketContent = this.pocketTarget.content.cloneNode(true);
+        this.element.appendChild(pocketContent);
+      }
+    }, {
+      key: "hide",
+      value: function hide() {
+        if (!this.hasContentTarget) {
+          return;
+        }
+
+        this.contentTarget.remove();
+      }
+    }], [{
+      key: "targets",
+      get: function get() {
+        return ["pocket", "content"];
+      }
+    }, {
+      key: "values",
+      get: function get() {
+        return {
+          identifier: String,
+          tabContainerGetter: String
+        };
+      }
+    }]);
+
+    return _default;
+  }(Controller);
+
   var _default = /*#__PURE__*/function (_Controller) {
     _inherits(_default, _Controller);
 
@@ -6412,12 +6543,14 @@ var Super = (function (exports) {
   }(Controller);
 
   var StimulusApplication = Application.start();
-  StimulusApplication.register("apply-template", _default$6);
-  StimulusApplication.register("clean-filter-param", _default$5);
-  StimulusApplication.register("clean-filter-params", _default$4);
-  StimulusApplication.register("click-outside-to-close", _default$3);
-  StimulusApplication.register("delete", _default$2);
-  StimulusApplication.register("flatpickr", _default$1);
+  StimulusApplication.register("apply-template", _default$8);
+  StimulusApplication.register("clean-filter-param", _default$7);
+  StimulusApplication.register("clean-filter-params", _default$6);
+  StimulusApplication.register("click-outside-to-close", _default$5);
+  StimulusApplication.register("delete", _default$4);
+  StimulusApplication.register("flatpickr", _default$3);
+  StimulusApplication.register("tab-container", _default$2);
+  StimulusApplication.register("tab", _default$1);
   StimulusApplication.register("toggle-pending-destruction", _default);
 
   exports.StimulusApplication = StimulusApplication;

data/lib/super.rb

@@ -25,6 +25,7 @@ require "super/filter/operator"
 require "super/filter/schema_types"
 require "super/form"
 require "super/form/builder"
+require "super/form/field_transcript"
 require "super/form/guesser"
 require "super/form/inline_errors"
 require "super/form/schema_types"

data/lib/super/display/guesser.rb

@@ -30,7 +30,7 @@ module Super
         when :time
           @type.time
         else
-          @type.text
+          @type.string
         end
       end
     end

data/lib/super/display/schema_types.rb

@@ -130,7 +130,6 @@ module Super
       end
 
       def string; real(&:to_s); end
-      alias text string
 
       def timestamp; real(&:to_s); end
       def time; real { |value| value.strftime("%H:%M:%S") }; end

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