activeadmin_favorites 0.1.0

data/app/models/active_admin/favorites/favorite/macro_catalog.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Favorites
+    class Favorite
+      class MacroCatalog
+        Template = Data.define(:key, :category, :requires_attribute, :resolver)
+
+        CATEGORIES = %i[time_range fiscal].freeze
+
+        def self.all
+          @all ||= build_templates.index_by(&:key)
+        end
+
+        def self.fetch(key)
+          all.fetch(key.to_s) { raise KeyError, "Unknown macro template: #{key}" }
+        end
+
+        def self.template_keys
+          all.keys
+        end
+
+        def self.options_for_select(category: nil)
+          templates = all.values
+          templates = templates.select { |template| template.category == category.to_sym } if category.present?
+          templates.map { |template| [I18n.t("active_admin.favorites.macro_templates.#{template.key}"), template.key] }
+        end
+
+        def self.resolve(template_key, attribute:, at: Time.zone.now)
+          fetch(template_key).resolver.call(attribute:, at: at.in_time_zone)
+        end
+
+        def self.describe(macro)
+          case macro["type"]
+          when "template"
+            attribute = macro["attribute"]
+            label = I18n.t("active_admin.favorites.macro_templates.#{macro["name"]}", default: macro["name"].humanize)
+            "#{attribute_label(attribute)}: #{label}"
+          when "relative_time_range"
+            "#{attribute_label(macro["attribute"])}: #{I18n.t("active_admin.favorites.macro_templates.#{macro["preset"]}", default: macro["preset"].humanize)}"
+          when "relative_time_bound"
+            "#{attribute_label(macro["attribute"])} #{macro["predicate"]} (#{macro["unit"]} #{macro["offset"]})"
+          else
+            macro["type"].to_s.humanize
+          end
+        end
+
+        def self.attribute_label(attribute)
+          attribute.to_s.tr("_", " ")
+        end
+
+        def self.build_templates
+          [
+            template(:previous_calendar_month, :time_range) { |attribute:, at:|
+              month = at.to_date.last_month
+              range_bounds(attribute, month.beginning_of_month, month.end_of_month)
+            },
+            template(:current_calendar_month, :time_range) { |attribute:, at:|
+              month = at.to_date
+              range_bounds(attribute, month.beginning_of_month, month.end_of_month)
+            },
+            template(:previous_calendar_day, :time_range) { |attribute:, at:|
+              day = at.to_date.yesterday
+              range_bounds(attribute, day, day)
+            },
+            template(:current_calendar_day, :time_range) { |attribute:, at:|
+              day = at.to_date
+              range_bounds(attribute, day, day)
+            },
+            template(:rolling_last_7_days, :time_range) { |attribute:, at:|
+              day = at.to_date
+              range_bounds(attribute, day - 6.days, day)
+            },
+            template(:rolling_last_30_days, :time_range) { |attribute:, at:|
+              day = at.to_date
+              range_bounds(attribute, day - 29.days, day)
+            },
+            template(:previous_fiscal_year, :fiscal) { |attribute:, at:|
+              start_date = fiscal_year_start(at.to_date) - 1.year
+              range_bounds(attribute, start_date, start_date + 1.year - 1.day)
+            },
+            template(:current_fiscal_year_to_date, :fiscal) { |attribute:, at:|
+              start_date = fiscal_year_start(at.to_date)
+              range_bounds(attribute, start_date, at.to_date)
+            }
+          ]
+        end
+
+        def self.template(key, category, &resolver)
+          Template.new(
+            key: key.to_s,
+            category: category,
+            requires_attribute: true,
+            resolver: resolver
+          )
+        end
+
+        def self.range_bounds(attribute, from_date, to_date)
+          {
+            "#{attribute}_gteq" => format_date(from_date),
+            "#{attribute}_lteq" => format_date(to_date)
+          }
+        end
+
+        def self.format_date(value)
+          value.to_date.strftime("%Y-%m-%d")
+        end
+
+        def self.fiscal_year_start(date)
+          year = (date.month >= 4) ? date.year : date.year - 1
+          Date.new(year, 4, 1)
+        end
+
+        private_class_method :build_templates, :template, :range_bounds, :fiscal_year_start
+      end
+    end
+  end
+end

data/app/models/active_admin/favorites/favorite/macro_resolver.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Favorites
+    class Favorite
+      class MacroResolver
+        ALLOWED_UNITS = %w[day week month year].freeze
+        ALLOWED_ANCHORS = %w[beginning_of_unit end_of_unit].freeze
+        ALLOWED_PREDICATES = %w[gteq lteq].freeze
+        MAX_MACROS = 10
+
+        def self.call(macros:, at: Time.zone.now)
+          new(macros:, at:).call
+        end
+
+        def self.q_keys(macros)
+          call(macros: macros, at: Time.zone.now).keys
+        end
+
+        def initialize(macros:, at:)
+          @macros = Array(macros)
+          @at = at.in_time_zone
+        end
+
+        def call
+          @macros.each_with_object({}) do |macro, resolved|
+            raise ArgumentError, "too many macros" if resolved.size > MAX_MACROS
+
+            resolved.merge!(resolve_macro(macro))
+          end
+        end
+
+        private
+
+        def resolve_macro(macro)
+          case macro["type"]
+          when "template"
+            resolve_template(macro)
+          when "relative_time_range"
+            resolve_relative_time_range(macro)
+          when "relative_time_bound"
+            key, value = resolve_relative_time_bound(macro)
+            {key => value}
+          else
+            raise ArgumentError, "unsupported macro type: #{macro["type"]}"
+          end
+        end
+
+        def resolve_template(macro)
+          MacroCatalog.resolve(macro.fetch("name"), attribute: macro.fetch("attribute"), at: @at)
+        end
+
+        def resolve_relative_time_range(macro)
+          MacroCatalog.resolve(macro.fetch("preset"), attribute: macro.fetch("attribute"), at: @at)
+        end
+
+        def resolve_relative_time_bound(macro)
+          attribute = macro.fetch("attribute")
+          predicate = macro.fetch("predicate")
+          unit = macro.fetch("unit")
+          offset = macro.fetch("offset").to_i
+          anchor = macro.fetch("anchor")
+
+          unless ALLOWED_UNITS.include?(unit) && ALLOWED_ANCHORS.include?(anchor) && ALLOWED_PREDICATES.include?(predicate)
+            raise ArgumentError, "invalid relative_time_bound macro"
+          end
+
+          if offset.abs > 120
+            raise ArgumentError, "offset out of range"
+          end
+
+          date = @at.to_date
+          shifted = date.advance("#{unit}s": offset)
+          bound =
+            if anchor == "beginning_of_unit"
+              shifted.public_send("beginning_of_#{unit}")
+            else
+              shifted.public_send("end_of_#{unit}")
+            end
+
+          ["#{attribute}_#{predicate}", MacroCatalog.format_date(bound)]
+        end
+      end
+    end
+  end
+end

data/app/models/active_admin/favorites/favorite/macro_validator.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Favorites
+    class Favorite
+      class MacroValidator
+        class ValidationError < StandardError; end
+
+        def self.validate!(macros, resource_key:)
+          new(macros, resource_key:).validate!
+        end
+
+        def initialize(macros, resource_key:)
+          @macros = Array(macros)
+          @resource_key = resource_key
+          @allowed_attributes = Favorite.ransackable_attributes_for(resource_key)
+        end
+
+        def validate!
+          raise ValidationError, "macros must be an array" unless @macros.is_a?(Array)
+          raise ValidationError, "too many macros" if @macros.size > MacroResolver::MAX_MACROS
+
+          @macros.each { |macro| validate_macro!(macro) }
+          true
+        end
+
+        private
+
+        def validate_macro!(macro)
+          raise ValidationError, "macro must be an object" unless macro.is_a?(Hash)
+          raise ValidationError, "macro type is required" if macro["type"].blank?
+
+          case macro["type"]
+          when "template"
+            validate_template!(macro)
+          when "relative_time_range"
+            validate_relative_time_range!(macro)
+          when "relative_time_bound"
+            validate_relative_time_bound!(macro)
+          else
+            raise ValidationError, "unsupported macro type: #{macro["type"]}"
+          end
+        end
+
+        def validate_template!(macro)
+          MacroCatalog.fetch(macro.fetch("name"))
+          validate_attribute!(macro.fetch("attribute"))
+        end
+
+        def validate_relative_time_range!(macro)
+          MacroCatalog.fetch(macro.fetch("preset"))
+          validate_attribute!(macro.fetch("attribute"))
+        end
+
+        def validate_relative_time_bound!(macro)
+          validate_attribute!(macro.fetch("attribute"))
+          predicate = macro.fetch("predicate")
+          unit = macro.fetch("unit")
+          anchor = macro.fetch("anchor")
+          offset = macro.fetch("offset").to_i
+
+          unless MacroResolver::ALLOWED_PREDICATES.include?(predicate)
+            raise ValidationError, "invalid predicate: #{predicate}"
+          end
+          unless MacroResolver::ALLOWED_UNITS.include?(unit)
+            raise ValidationError, "invalid unit: #{unit}"
+          end
+          unless MacroResolver::ALLOWED_ANCHORS.include?(anchor)
+            raise ValidationError, "invalid anchor: #{anchor}"
+          end
+          if offset.abs > 120
+            raise ValidationError, "offset out of range"
+          end
+        end
+
+        def validate_attribute!(attribute)
+          unless attribute.to_s.match?(/\A[a-z0-9_]+\z/)
+            raise ValidationError, "invalid attribute name"
+          end
+          unless @allowed_attributes.include?(attribute.to_s)
+            raise ValidationError, "attribute not allowed for resource: #{attribute}"
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/active_admin/favorites/favorite/query_params.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Favorites
+    class Favorite
+      module QueryParams
+        module_function
+
+        def parse(query_string)
+          return {} if query_string.blank?
+
+          Rack::Utils.parse_nested_query(query_string.to_s).except("commit")
+        end
+
+        def build(params)
+          Rack::Utils.build_nested_query(params.compact_blank).presence
+        end
+
+        def merge_query_string(query_string, q_overrides:)
+          params = parse(query_string)
+          params["q"] = (params["q"] || {}).merge(q_overrides.stringify_keys)
+          build(params)
+        end
+
+        def without_q_keys(query_string, keys:)
+          params = parse(query_string)
+          query_filters = params["q"]
+          return query_string if query_filters.blank?
+
+          keys.each { |key| query_filters.delete(key.to_s) }
+          params["q"] = query_filters.presence
+          build(params)
+        end
+
+        def q_keys_for_macros(macros)
+          Favorite::MacroResolver.q_keys(macros)
+        end
+      end
+    end
+  end
+end

data/app/models/active_admin/favorites/favorite/range_detector.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Favorites
+    class Favorite
+      class RangeDetector
+        DATE_PREDICATES = %w[gteq lteq gt lt].freeze
+        DATE_PATTERN = /\A\d{4}-\d{2}-\d{2}/
+
+        def self.call(query_string:, resource_key:)
+          new(query_string:, resource_key:).call
+        end
+
+        def initialize(query_string:, resource_key:)
+          @query_filters = QueryParams.parse(query_string).fetch("q", {})
+          @resource_key = resource_key
+        end
+
+        def call
+          attributes = allowed_attributes
+          attributes.filter_map do |attribute|
+            detect_range(attribute)
+          end
+        end
+
+        private
+
+        def allowed_attributes
+          Favorite.ransackable_attributes_for(@resource_key)
+            .select { |attribute| date_like_attribute?(attribute) }
+        end
+
+        def date_like_attribute?(attribute)
+          DATE_PREDICATES.any? do |predicate|
+            value = @query_filters["#{attribute}_#{predicate}"]
+            value.present? && value.to_s.match?(DATE_PATTERN)
+          end
+        end
+
+        def detect_range(attribute)
+          gteq = @query_filters["#{attribute}_gteq"].presence
+          lteq = @query_filters["#{attribute}_lteq"].presence
+          return if gteq.blank? && lteq.blank?
+
+          {
+            attribute: attribute,
+            gteq: gteq,
+            lteq: lteq
+          }
+        end
+      end
+    end
+  end
+end