warped 0.2.0 → 1.0.0

data/lib/warped/api/filter/base/value.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/module/delegation"
+
+module Warped
+  module Filter
+    class Base
+      class Value
+        attr_reader :filter
+
+        delegate :name, :alias_name, :parameter_name, :kind, to: :filter
+
+        # @param filter [Warped::Filter::Base] The filter object
+        # @param relation [String] The filter relation.
+        # @param value [String] The filter value.
+        def initialize(filter, relation, value)
+          @filter = filter
+          @relation = relation
+          @value = value
+        end
+
+        # @return [String] The casted filter value.
+        def value
+          filter.cast(@value)
+        end
+
+        # @return [String] The validated filter relation.
+        def relation
+          filter.relation(@relation)
+        end
+
+        # @return [Boolean] Whether the filter is empty.
+        def empty?
+          value.nil? && !%w[is_null is_not_null].include?(relation)
+        end
+
+        def to_h
+          {
+            field: filter.name,
+            relation:,
+            value:
+          }
+        end
+
+        # Some filters may need to be parsed/formatted differently for the HTML input value.
+        # This method can be overridden in the filter value class to provide a different value.
+        alias html_value value
+      end
+    end
+  end
+end

data/lib/warped/api/filter/base.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/string/inflections"
+
+module Warped
+  module Filter
+    class Base
+      RELATIONS = %w[eq neq gt gte lt lte between in not_in starts_with ends_with contains is_null is_not_null].freeze
+
+      attr_reader :name, :strict, :alias_name, :options
+
+      delegate :[], to: :options
+
+      # @return [Symbol, nil] The filter kind.
+      def self.kind
+        filter_type = name.demodulize.underscore.to_sym
+
+        filter_type == :filter ? nil : filter_type
+      end
+
+      # @param name [String] The name of the filter.
+      # @param alias_name [String] The alias name of the filter, used for renaming the filter key in the URL params
+      # @param options [Hash] The filter options.
+      def initialize(name, strict:, alias_name: nil, **options)
+        raise ArgumentError, "name cannot be nil" if name.nil?
+
+        @name = name.to_s
+        @strict = strict
+        @alias_name = alias_name&.to_s
+        @options = options
+      end
+
+      # @return [Symbol, nil] The filter kind.
+      def kind
+        self.class.kind
+      end
+
+      # @return [Array<String>] The valid filter relations.
+      def relations
+        self.class::RELATIONS
+      end
+
+      # @param relation [Object] The filter relation.
+      # @return [Object] The casted value.
+      # @raise [Warped::Filter::RelationError] If the relation is invalid and strict is true.
+      def cast(value)
+        return if value.nil?
+
+        value
+      end
+
+      # @param relation [String] The validated filter relation.
+      # @return [String] The validated filter relation.
+      # @raise [Warped::Filter::RelationError] If the relation is invalid and strict is true.
+      def relation(relation)
+        if valid_relation?(relation)
+          relation
+        else
+          raise RelationError, "Invalid relation: #{relation}" unless strict
+
+          "eq"
+        end
+      end
+
+      # @return [String] The name to use in the URL params.
+      def parameter_name
+        alias_name.presence || name
+      end
+
+      # @return [String] The HTML input type.
+      def html_type
+        raise NotImplementedError, "#{self.class.name}#html_type not implemented"
+      end
+
+      private
+
+      def valid_relation?(relation)
+        relations.include?(relation.to_s)
+      end
+    end
+  end
+end

data/lib/warped/api/filter/boolean.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Warped
+  module Filter
+    class Boolean < Base
+      RELATIONS = %w[eq neq is_null is_not_null].freeze
+
+      def cast(value)
+        return if value.nil?
+
+        casted_value = case value
+                       when true, false
+                         value
+                       when "true", "1", "t", 1
+                         true
+                       when "false", "0", "f", 0
+                         false
+                       end
+
+        casted_value.tap do |casted|
+          raise ValueError, "#{value} cannot be casted to #{kind}" if casted.nil? && strict
+        end
+      end
+
+      def html_type
+        "text"
+      end
+
+      class Value < Value
+        def html_value
+          case value.class
+          when TrueClass
+            "true"
+          when FalseClass
+            "false"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/warped/api/filter/date.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "date"
+require "active_support/core_ext/object/blank"
+
+module Warped
+  module Filter
+    class Date < Base
+      RELATIONS = %w[eq neq gt gte lt lte between is_null is_not_null].freeze
+
+      def cast(value)
+        return if value.blank?
+
+        ::Date.parse(value)
+      rescue ::Date::Error
+        raise ValueError, "#{value} cannot be casted to #{kind}" if strict
+
+        nil
+      end
+
+      def html_type
+        "date"
+      end
+    end
+  end
+end

data/lib/warped/api/filter/date_time.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "date"
+require "active_support/core_ext/object/blank"
+
+module Warped
+  module Filter
+    class DateTime < Base
+      RELATIONS = %w[eq neq gt gte lt lte between is_null is_not_null].freeze
+
+      def cast(value)
+        return if value.blank?
+
+        ::DateTime.parse(value)
+      rescue ::Date::Error
+        raise ValueError, "#{value} cannot be casted to #{kind}" if strict
+
+        nil
+      end
+
+      def html_type
+        "datetime-local"
+      end
+
+      class Value < Value
+        def html_value
+          value.strftime("%Y-%m-%dT%H:%M:%S")
+        end
+      end
+    end
+  end
+end

data/lib/warped/api/filter/decimal.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "active_support/core_ext/object/blank"
+
+module Warped
+  module Filter
+    class Decimal < Base
+      RELATIONS = %w[eq neq gt gte lt lte between in not_in is_null is_not_null].freeze
+
+      def cast(value)
+        return if value.blank?
+
+        casted_value = case value
+                       when ::BigDecimal
+                         value
+                       when ::Integer, ::Float, ::String
+                         value.to_d
+                       end
+
+        casted_value.tap do |casted|
+          raise ValueError, "#{value} cannot be casted to #{kind}" if casted.nil? && strict
+        end
+      end
+
+      def html_type
+        "number"
+      end
+    end
+  end
+end

data/lib/warped/api/filter/factory.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Warped
+  module Filter
+    class Factory
+      TYPES = %i[string integer float decimal date time date_time boolean].freeze
+
+      def self.build(kind, *args, **kwargs)
+        new(kind).build(*args, **kwargs)
+      end
+
+      def initialize(kind = nil)
+        @kind = kind
+        validate_kind!
+      end
+
+      def build(*args, **kwargs)
+        filter_class.new(*args, **kwargs)
+      end
+
+      private
+
+      attr_reader :kind
+
+      def validate_kind!
+        return if kind.nil?
+
+        raise ArgumentError, "#{kind} is not a valid filter type" unless TYPES.include?(kind)
+      end
+
+      def filter_class
+        return Base if kind.nil?
+
+        Filter.const_get(kind.to_s.camelize)
+      end
+    end
+  end
+end

data/lib/warped/api/filter/integer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/blank"
+
+module Warped
+  module Filter
+    class Integer < Base
+      RELATIONS = %w[eq neq gt gte lt lte between in not_in is_null is_not_null].freeze
+
+      def cast(value)
+        return if value.blank?
+
+        casted_value = case value
+                       when ::Integer
+                         value
+                       when ::String
+                         value.to_i if value.match?(/\A-?\d+\z/)
+                       when ::Float, ::BigDecimal
+                         value.to_i
+                       end
+
+        check_casted_value!(casted_value)
+      end
+
+      def html_type
+        "number"
+      end
+
+      private
+
+      def check_casted_value!(value)
+        raise ValueError, "#{value} cannot be casted to #{kind}" if value.nil? && strict
+
+        value
+      end
+    end
+  end
+end

data/lib/warped/api/filter/string.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/blank"
+
+module Warped
+  module Filter
+    class String < Base
+      RELATIONS = Queries::Filter::RELATIONS
+
+      def cast(value)
+        return if value.blank?
+
+        value.to_s
+      rescue StandardError
+        raise ValueError, "#{value} cannot be casted to #{kind}" if strict
+
+        nil
+      end
+
+      def html_type
+        "text"
+      end
+    end
+  end
+end

data/lib/warped/api/filter/time.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/blank"
+
+module Warped
+  module Filter
+    class Time < Base
+      RELATIONS = %w[eq neq gt gte lt lte between is_null is_not_null].freeze
+
+      def cast(value)
+        return if value.blank?
+
+        ::Time.parse(value)
+      rescue StandardError
+        raise ValueError, "#{value} cannot be casted to #{kind}" if strict
+
+        nil
+      end
+
+      def html_type
+        "time"
+      end
+    end
+  end
+end

data/lib/warped/api/filter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/delegation"
+
+module Warped
+  module Filter
+    class ValueError < StandardError; end
+    class RelationError < StandardError; end
+
+    class << self
+      delegate :build, to: Factory
+    end
+  end
+end

data/lib/warped/api/sort/value.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/delegation"
+
+module Warped
+  class Sort
+    class Value
+      attr_reader :sort
+
+      delegate :name, :alias_name, :parameter_name, to: :sort
+
+      # @param sort [Warped::Sort] The sort object
+      # @param direction [String] The sort direction.
+      def initialize(sort, direction)
+        @sort = sort
+        @direction = direction
+      end
+
+      # @return [String] The sort direction.
+      def direction
+        sort.direction!(@direction)
+      end
+
+      # @return [String] The opposite sort direction.
+      def opposite_direction
+        sort.opposite_direction(direction)
+      end
+
+      # @return [Boolean] Whether the sort is ascending.
+      def asc?
+        %w[asc asc_nulls_first asc_nulls_last].include?(direction)
+      end
+
+      # @return [Boolean] Whether the sort is descending.
+      def desc?
+        %w[desc desc_nulls_first desc_nulls_last].include?(direction)
+      end
+    end
+  end
+end

data/lib/warped/api/sort.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/blank"
+
+module Warped
+  class Sort
+    class DirectionError < StandardError; end
+
+    SORT_DIRECTIONS = %w[asc desc].freeze
+    NULLS_SORT_DIRECTION = %w[asc_nulls_first asc_nulls_last desc_nulls_first desc_nulls_last].freeze
+
+    attr_accessor :name, :alias_name
+
+    # @return [Array<String>] The valid sort directions.
+    def self.directions
+      @directions ||= SORT_DIRECTIONS + NULLS_SORT_DIRECTION
+    end
+
+    # @param name [String] The name of the sort.
+    # @param alias_name [String] The alias name of the sort, used for renaming the sort key in the URL params
+    def initialize(name, alias_name: nil)
+      raise ArgumentError, "name cannot be nil" if name.nil?
+
+      @name = name.to_s
+      @alias_name = alias_name&.to_s
+    end
+
+    # @return [String] The name to use in the URL params.
+    def parameter_name
+      alias_name.presence || name
+    end
+
+    # @param direction [String] The sort direction.
+    # @return [String] The sort direction.
+    # @raise [DirectionError] If the direction is invalid.
+    def direction!(direction)
+      raise DirectionError, "Invalid direction: #{direction}" unless valid_direction?(direction.to_s)
+
+      direction.to_s
+    end
+
+    # @param direction [String] The sort direction.
+    # @return [String] The opposite sort direction.
+    def opposite_direction(direction)
+      opposite_directions[direction]
+    end
+
+    private
+
+    def valid_direction?(relation)
+      self.class.directions.include?(relation.to_s)
+    end
+
+    def opposite_directions
+      @opposite_directions ||= {
+        "asc" => "desc",
+        "desc" => "asc",
+        "asc_nulls_first" => "desc_nulls_last",
+        "asc_nulls_last" => "desc_nulls_first",
+        "desc_nulls_first" => "asc_nulls_last",
+        "desc_nulls_last" => "asc_nulls_first"
+      }.freeze
+    end
+  end
+end

data/lib/warped/controllers/filterable/ui.rb

@@ -10,57 +10,35 @@ module Warped
         include Filterable
 
         included do
-          helper_method :filters, :filtered?, :current_filters, :filter_url_params, :filterable_by
+          helper_method :filters, :filtered?, :filter_url_params, :filterable_by
         end
 
+        # @see Filterable#filter
         def filter(...)
           @filtered = true
 
           super
         end
 
+        # @return [Boolean] Whether the current action is filtered.
         def filtered?
           @filtered ||= false
         end
 
+        # @return [Hash] The filters for the current action.
         def filter_url_params(**options)
           url_params = {}
-          current_filters.each_with_object(url_params) do |filter, hsh|
-            if filter[:value].is_a?(Array)
-              filter[:value].each { |value| hsh["#{filter[:name]}[]"] = value }
+          current_action_filter_values.each_with_object(url_params) do |filter_value, hsh|
+            if filter_value.value.is_a?(Array)
+              filter_value.value.each { |value| hsh["#{filter_value.parameter_name}[]"] = value }
             else
-              hsh[filter[:name]] = filter[:value]
+              hsh[filter_value.parameter_name] = filter_value.value
             end
 
-            hsh["#{filter[:name]}.rel"] = filter[:relation]
+            hsh["#{filter_value.parameter_name}.rel"] = filter_value.relation
           end
 
-          url_params.tap { _1.merge!(options) }
-        end
-
-        def filters
-          (filter_fields | mapped_filter_fields).map do |field|
-            {
-              name: filter_mapped_name(field),
-              value: filter_value(field),
-              relation: filter_rel_value(field)
-            }
-          end
-        end
-
-        def current_filters
-          (filter_fields | mapped_filter_fields).filter_map do |field|
-            filter_value = filter_value(field)
-            filter_rel_value = filter_rel_value(field)
-
-            next if filter_value.blank? && %w[is_null is_not_null].exclude?(filter_rel_value)
-
-            {
-              name: filter_mapped_name(field),
-              value: filter_value,
-              relation: filter_rel_value
-            }
-          end
+          url_params.merge!(options)
         end
       end
     end