super 0.0.14 → 0.18.0

data/lib/super/action_inquirer.rb

@@ -19,12 +19,27 @@ module Super
     #
     def self.default_for_resources
       {
-        read: %i[index show new edit],
-        write: %i[create update destroy],
-        delete: %i[destroy]
+        "read" => %w[index show new edit],
+        "write" => %w[create update destroy],
+        "delete" => %w[destroy],
       }
     end
 
+    # @return [ActionInquirer]
+    def self.index!; new(default_for_resources, "index"); end
+    # @return [ActionInquirer]
+    def self.show!; new(default_for_resources, "show"); end
+    # @return [ActionInquirer]
+    def self.new!; new(default_for_resources, "new"); end
+    # @return [ActionInquirer]
+    def self.edit!; new(default_for_resources, "edit"); end
+    # @return [ActionInquirer]
+    def self.create!; new(default_for_resources, "create"); end
+    # @return [ActionInquirer]
+    def self.update!; new(default_for_resources, "update"); end
+    # @return [ActionInquirer]
+    def self.destroy!; new(default_for_resources, "destroy"); end
+
     def initialize(categories_and_their_actions, action)
       @categories = categories_and_their_actions.keys.map(&:to_s)
       @actions = categories_and_their_actions.values.flatten.uniq.map(&:to_s)

data/lib/super/badge.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Super
+  class Badge
+    STYLES = {
+      light: "bg-gray-100 text-black",
+      dark: "bg-gray-900 text-white",
+      red: "bg-red-700 text-white",
+      yellow: "bg-yellow-400 text-black",
+      green: "bg-green-700 text-white",
+      blue: "bg-blue-700 text-white",
+      purple: "bg-purple-800 text-white",
+    }
+
+    def initialize(text, styles: nil)
+      @text = text
+      @requested_styles = Array(styles.presence).flatten
+    end
+
+    def styles
+      return @styles if instance_variable_defined?(:@styles)
+      @styles =
+        if requested_styles.delete(:reset)
+          []
+        else
+          COMMON_STYLES
+        end
+
+      if requested_styles.empty?
+        @styles += [STYLES[:light]]
+      else
+        requested_styles.each do |style|
+          @styles +=
+            if STYLES.key?(style)
+              [STYLES[style]]
+            else
+              [style]
+            end
+        end
+      end
+
+      @styles
+    end
+
+    def to_s
+      ActionController::Base.helpers.content_tag(
+        :span,
+        @text,
+        class: styles.join(" ")
+      )
+    end
+
+    private
+
+    COMMON_STYLES = %w[rounded px-2 py-1 text-xs leading-none font-bold]
+    private_constant :COMMON_STYLES
+
+    attr_reader :requested_styles
+  end
+end

data/lib/super/cheat.rb

@@ -2,15 +2,15 @@
 
 module Super
   class Cheat
-    def controls
-      paths = %w[controls.rb controls/optional.rb controls/steps.rb controls/view.rb]
+    def controller
+      paths = %w[../../app/controllers/super/substructure_controller.rb]
       methods =
         paths
-        .map { |f| File.read(File.join(__dir__, f)) }
-        .flat_map { |content| content.scan(/^\s+def .*$/) }
-        .map { |method| method.strip.sub(/^def /, "#") }
+        .map { |f| File.read(File.expand_path(f, __dir__)) }
+        .flat_map { |content| content.scan(/^\s+(?:helper_method )?def .*$/) }
+        .map { |method| method.strip.sub(/^(?:helper_method )?def /, "#") }
 
-      puts "== Super::Controls"
+      puts "== Super::ApplicationController"
       puts methods.join("\n")
     end
   end

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

@@ -61,6 +61,47 @@ module Super
         end
       end
 
+      class Badge
+        extend Useful::Builder
+
+        def initialize(builder)
+          @builder = builder
+          @whens = {}
+          format_for_lookup(&:itself)
+          format_for_display(&:itself)
+        end
+
+        builder_with_block def when(*patterns, &block)
+          patterns.each do |pattern|
+            @whens[pattern] = block
+          end
+        end
+
+        builder_with_block def else(&block)
+          @else = block
+        end
+
+        builder_with_block def format_for_lookup(&block)
+          @format_for_lookup = block
+        end
+
+        builder_with_block def format_for_display(&block)
+          @format_for_display = block
+        end
+
+        def build
+          @builder.transform do |value|
+            lookup_value = @format_for_lookup.call(value)
+            block = @whens[lookup_value] || @else
+            Super::Badge.new(
+              @format_for_display.call(value),
+              styles: block&.call
+            )
+          end
+          @builder.build
+        end
+      end
+
       def initialize(fields:)
         @actions_called = false
         @fields = fields
@@ -89,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
@@ -100,6 +140,14 @@ module Super
         end
       end
 
+      def badge(*builder_methods)
+        builder_methods = %i[real ignore_nil column] if builder_methods.empty?
+        builder = builder_methods.each_with_object(Builder.new) do |builder_method, builder|
+          builder.public_send(builder_method)
+        end
+        Badge.new(builder)
+      end
+
       def actions
         @actions_called = true
         Builder.new.computed.none.transform do

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/error.rb

@@ -28,6 +28,9 @@ 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

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