super 0.0.4 → 0.0.9

data/lib/super/filter/guesser.rb

@@ -0,0 +1,30 @@
+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,103 @@
+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/plugin.rb

@@ -0,0 +1,47 @@
+module Super
+  class Filter
+    module ControllerMethods
+      def index
+        super
+        @filter_form = controls.initialize_filtering(params: params, query_params: request.GET)
+        @records = controls.filter_records(filter_form: @filter_form, records: @records)
+        @view.asides.push(:@filter_form)
+      end
+    end
+  end
+
+  class Controls
+    module Optional
+      def filters_enabled?
+        true
+      end
+
+      def filter_schema
+        Filter.new do |fields, type|
+          Filter::Guesser.new(model: model, fields: fields, type: type).call
+        end
+      end
+    end
+
+    module Steps
+      def initialize_filtering(params:, query_params:)
+        if filters_enabled?
+          Super::Filter::FormObject.new(
+            model: model,
+            schema: filter_schema,
+            params: params[:q],
+            url: query_params
+          )
+        end
+      end
+
+      def filter_records(filter_form:, records:)
+        if filters_enabled? && records
+          filter_form.to_search_query(records)
+        else
+          records
+        end
+      end
+    end
+  end
+end

data/lib/super/filter/schema_types.rb

@@ -0,0 +1,112 @@
+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

data/lib/super/form.rb

@@ -0,0 +1,35 @@
+module Super
+  # This schema type is used on your +#edit+ and +#new+ forms
+  #
+  # ```ruby
+  # class MembersController::Controls
+  #   # ...
+  #
+  #   def new_schema
+  #     Super::Form.new do |fields, type|
+  #       fields[:name] = type.string
+  #       fields[:rank] = type.select
+  #       fields[:position] = type.string
+  #       fields[:ship_id] = type.select(
+  #         collection: Ship.all.map { |s| ["#{s.name} (Ship ##{s.id})", s.id] },
+  #       )
+  #     end
+  #   end
+  #
+  #   # ...
+  # end
+  # ```
+  class Form
+    include Schema::Common
+
+    def initialize
+      @fields = Schema::Fields.new
+      @schema_types = SchemaTypes.new(fields: @fields)
+      yield(@fields, @schema_types)
+    end
+
+    def to_partial_path
+      "super_schema_form"
+    end
+  end
+end

data/lib/super/form/builder.rb

@@ -0,0 +1,48 @@
+module Super
+  class Form
+    module FieldErrorProc
+      def error_wrapping(html_tag)
+        if Thread.current[:super_form_builder]
+          return html_tag
+        end
+
+        super
+      end
+    end
+
+    class Builder < ActionView::Helpers::FormBuilder
+      # These methods were originally defined in the following files
+      #
+      # * actionview/lib/action_view/helpers/form_helper.rb
+      # * actionview/lib/action_view/helpers/form_options_helper.rb
+      # * actionview/lib/action_view/helpers/date_helper.rb
+      %w[
+        label text_field password_field hidden_field file_field text_area
+        check_box radio_button color_field search_field telephone_field
+        date_field time_field datetime_field month_field week_field url_field
+        email_field number_field range_field
+
+        select collection_select grouped_collection_select time_zone_select
+        collection_radio_buttons collection_check_boxes
+
+        time_select datetime_select date_select
+      ].each do |field_type_method|
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          def #{field_type_method}(*)
+            Thread.current[:super_form_builder] = true
+            super
+          ensure
+            Thread.current[:super_form_builder] = nil
+          end
+        RUBY
+      end
+
+      alias datetime_local_field datetime_field
+      alias phone_field telephone_field
+    end
+  end
+end
+
+ActionView::Helpers::Tags::Base.class_eval do
+  prepend Super::Form::FieldErrorProc
+end

data/lib/super/form/guesser.rb

@@ -0,0 +1,27 @@
+module Super
+  class Form
+    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) }
+          .reject { |attribute_name| attribute_name == "id" }
+          .reject { |attribute_name| attribute_name == "created_at" }
+          .reject { |attribute_name| attribute_name == "updated_at" }
+          .call
+      end
+
+      private
+
+      def attribute_type_for(attribute_name)
+        @type.string
+      end
+    end
+  end
+end

data/lib/super/form/schema_types.rb

@@ -1,26 +1,5 @@
 module Super
   class Form
-    # This schema type is used on your +#edit+ and +#new+ forms
-    #
-    # ```ruby
-    # class MembersController::Controls
-    #   # ...
-    #
-    #   def new_schema
-    #     Super::Schema.new(Super::Form::SchemaTypes.new) do |fields, type|
-    #       fields[:name] = type.generic("form_field_text")
-    #       fields[:rank] = type.generic("form_field_select", collection: Member.ranks.keys)
-    #       fields[:position] = type.generic("form_field_text")
-    #       fields[:ship_id] = type.generic(
-    #         "form_field_select",
-    #         collection: Ship.all.map { |s| ["#{s.name} (Ship ##{s.id})", s.id] },
-    #       )
-    #     end
-    #   end
-    #
-    #   # ...
-    # end
-    # ```
     class SchemaTypes
       class Generic
         def initialize(partial_path:, extras:, nested:)
@@ -31,6 +10,16 @@ module Super
 
         attr_reader :nested_fields
 
+        def each_attribute
+          if block_given?
+            @nested_fields.each do |key, value|
+              yield(key, value)
+            end
+          end
+
+          enum_for(:each_attribute)
+        end
+
         # This takes advantage of a feature of Rails. If the value of
         # `#to_partial_path` is `my_form_field`, Rails renders
         # `app/views/super/application/_my_form_field.html.erb`, and this
@@ -69,7 +58,7 @@ module Super
         end
       end
 
-      def setup(fields:)
+      def initialize(fields:)
         @fields = fields
       end
 
@@ -77,6 +66,24 @@ module Super
         Generic.new(partial_path: partial_path, extras: extras, nested: {})
       end
 
+      def select(**extras)
+        Generic.new(partial_path: "form_field_select", extras: extras, nested: {})
+      end
+
+      def string(**extras)
+        Generic.new(partial_path: "form_field_text", extras: extras, nested: {})
+      end
+
+      alias text string
+
+      def rich_text_area(**extras)
+        Generic.new(partial_path: "form_field_rich_text_area", extras: extras, nested: {})
+      end
+
+      def checkbox(**extras)
+        Generic.new(partial_path: "form_field_checkbox", extras: extras, nested: {})
+      end
+
       def has_many(reader, **extras)
         nested = @fields.nested do
           yield