super 0.0.16 → 0.19.0

data/frontend/super-frontend/dist/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@superadministration/super",
+  "description": "The frontend code for Super, a Rails admin framework",
+  "homepage": "https://github.com/zachahn/super",
+  "license": "LGPL-3.0-only",
+  "main": "application.js",
+  "files": [
+    "application.js",
+    "application.css",
+    "package.json"
+  ],
+  "version": "0.19.0"
+}

data/lib/generators/super/webpacker/USAGE

@@ -1,15 +1,9 @@
 Description:
     Creates the necessary files for assets to be served under Webpacker
 
-    Webpacker support requires that you install ERB support for Webpacker.
-
-    Installing ERB on webpacker is usually done by running the command:
-    `rails webpacker:install:erb`
-
 Example:
-    rails webpacker:install:erb             # if you hadn't set up ERB already
     rails generate super:webpacker
 
     This will:
-        Create app/javascript/packs/super/application.js.erb
+        Create app/javascript/packs/super/application.js
         Modify config/initializers/super.rb

data/lib/generators/super/webpacker/templates/pack_super_application.js.tt

@@ -0,0 +1,2 @@
+import Super from "@superadministration/super";
+import "@superadministration/super/application.css";

data/lib/generators/super/webpacker/webpacker_generator.rb

@@ -7,12 +7,12 @@ module Super
     def copy_the_pack_file
       path =
         if Gem::Dependency.new("webpacker", ">= 6.0.0.beta2", "!= 6.0.0.pre1", "!= 6.0.0.pre2").matching_specs.any?
-          "app/packs/entrypoints/super/application.js.erb"
+          "app/packs/entrypoints/super/application.js"
         else
-          "app/javascript/packs/super/application.js.erb"
+          "app/javascript/packs/super/application.js"
         end
 
-      template("pack_super_application.js.erb", path)
+      template("pack_super_application.js", path)
     end
 
     def set_asset_handler_to_webpacker
@@ -24,9 +24,13 @@ module Super
       )
     end
 
-    def remind_about_erb
-      say "Make sure ERB is set up for Webpacker!", :bold
-      say "Run if needed: bundle exec rails webpacker:install:erb"
+    def install_via_yarn
+      super_root = Pathname.new(__dir__).join("../../../..")
+      if super_root.join("dummy_path.rb").file?
+        run "yarn add file:#{super_root.join("frontend/super-frontend/dist")}"
+      else
+        run "yarn add @superadministration/super@#{Super::VERSION} --exact"
+      end
     end
   end
 end

data/lib/super/cheat.rb

@@ -8,6 +8,7 @@ module Super
         paths
         .map { |f| File.read(File.expand_path(f, __dir__)) }
         .flat_map { |content| content.scan(/^\s+(?:helper_method )?def .*$/) }
+        .reject { |method| method =~ /\bdef self\./ }
         .map { |method| method.strip.sub(/^(?:helper_method )?def /, "#") }
 
       puts "== Super::ApplicationController"

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

@@ -129,8 +129,13 @@ module Super
         real(:column, &transform_block)
       end
 
+      def batch
+        real do |value|
+          Partial.new("batch_checkbox", locals: { value: value })
+        end
+      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/display.rb

@@ -32,10 +32,11 @@ module Super
       yield(@fields, @schema_types)
     end
 
-    def apply(action:)
+    def apply(action:, format:)
       @action_inquirer = action
       return self if !@action_inquirer.index?
       return self if @schema_types.actions_called?
+      return self if !format.html?
       @fields[:actions] = @schema_types.actions
       self
     end

data/lib/super/engine.rb

@@ -15,6 +15,11 @@ module Super
       Super::Plugin::Registry.controller.ordered do |klass, method_name|
         Super::ApplicationController.public_send(method_name, klass)
       end
+
+      Super::PackagedAsset.warning_message =
+        if !Super::PackagedAsset.version_matches_gem?(Rails.root.join("package.json"))
+          I18n.t("super.mismatching_package_json_gemfile_versions")
+        end
     end
   end
 end

data/lib/super/error.rb

@@ -28,11 +28,23 @@ module Super
     # a more specific error
     class Initalization < Error; end
     class ArgumentError < Error; end
+    class AlreadyRegistered < Error; end
+    class AlreadyTranscribed < Error; end
+    class NotImplementedError < Error; end
 
     class Enum < Error
       class ImpossibleValue < Enum; end
       class ArgumentError < Enum; end
       class UndefinedCase < Enum; end
     end
+
+    class ReorderableHash < Error
+      class DuplicateKey < ReorderableHash; end
+      class KeyError < ReorderableHash; end
+    end
+
+    class ViewChain < Error
+      class ChainAlreadyStarted < ViewChain; end
+    end
   end
 end

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