refine-rails 2.9.0

data/app/models/refine/filters/blueprint_editor.rb

@@ -0,0 +1,102 @@
+class Refine::Filters::BlueprintEditor
+  # Editor that will transform a given blueprint IN PLACE
+  # Designed to support operations for the v2 inline filter builder via ConditionsController
+
+  attr_reader :blueprint
+
+  INPUT_ATTRS = %i[
+    clause
+    date1
+    date2
+    days
+    modifier
+    selected
+    value
+    value1
+    value2
+    count_refinement
+  ].freeze
+
+  def initialize(blueprint)
+    @blueprint = blueprint
+  end
+
+  # add a criteria at the specified position (defaults to the end)
+  def add(position: -1, conjunction: "and", criterion:)
+    # TODO support multiple input conditions, refinements, etc
+
+    conjunction_depth = case conjunction
+    in "and" then 1
+    in "or" then 0
+    end
+
+    # extract data from criterion
+    condition_id = criterion[:condition_id]
+    input = criterion[:input].slice(*INPUT_ATTRS)
+
+    nodes_to_insert = []
+    nodes_to_insert << {
+      depth: conjunction_depth,
+      type: "conjunction",
+      word: conjunction,
+    } if blueprint[(position.negative? ? position + 1 : position - 1)]
+
+    nodes_to_insert << {
+      depth: 1,
+      type: "criterion",
+      condition_id: condition_id,
+      input: input
+    }
+
+    blueprint.insert position, *nodes_to_insert
+  end
+
+  def update(index, criterion:)
+    # extract data from criterion
+    input = criterion[:input].slice(*INPUT_ATTRS)
+
+    blueprint[index][:input] = input
+  end
+
+  def delete(index)
+   # To support 'groups' there is some complicated logic for deleting criterion.
+   #
+   # Imagine this simplified blueprint: [eq, and, sw, or, eq]
+   #
+   # User clicks to delete the last eq. We also have to delete the preceding or
+   # otherwise we're left with a hanging empty group
+   #
+   # What if the user deletes the sw? We have to clean up the preceding and.
+   #
+   # Imagine another scenario: [eq or sw and ew]
+   # Now we delete the first eq but this time we need to clean up the or.
+   #
+   # These conditionals cover these cases.
+
+    previous_entry = index.zero? ? nil : blueprint[index - 1]
+    next_entry = blueprint[index + 1]
+
+    next_is_or = next_entry && next_entry[:word] == 'or'
+    previous_is_or = previous_entry && previous_entry[:word] == 'or'
+
+    next_is_right_paren = next_is_or || !next_entry
+    previous_is_left_paren = previous_is_or || !previous_entry
+
+    is_first_in_group = previous_is_left_paren && !next_is_right_paren
+    is_last_in_group = previous_is_left_paren && next_is_right_paren
+    is_last_criterion = !previous_entry && !next_entry
+
+    if is_last_criterion
+      blueprint.slice!(index)
+    elsif is_last_in_group && previous_is_or
+      blueprint.slice!((index - 1)..index)
+    elsif is_last_in_group && !previous_entry
+      blueprint.slice!(index..(index + 1))
+    elsif is_first_in_group
+      blueprint.slice!(index..(index + 1))
+    else
+      blueprint.slice!((index - 1)..index)
+    end
+
+  end
+end

data/app/models/refine/filters/builder.rb

@@ -0,0 +1,59 @@
+class Refine::Filters::Builder
+  # View Model that holds all aspects of the client state related to the filter builder
+  # This includes auxiliary state like client_id and selected stored filter id
+  #
+  # State for the main query builder form is held in #query which is an instance of 
+  # Refine::Filters::Query
+  include ActiveModel::Model
+
+  attr_accessor :blueprint_json,
+    :filter_class,
+    :stable_id,
+    :stored_filter_id,
+    :client_id,
+    :initial_query
+
+  attr_reader :blueprint, :refine_filter, :query
+
+  def initialize(attrs = {})
+    super
+    @client_id ||= SecureRandom.uuid
+    set_refine_filter_and_blueprint!
+    set_query!
+  end
+
+  def to_params
+    {
+      refine_filters_builder: {
+        blueprint_json: blueprint.to_json,
+        stable_id: stable_id,
+        stored_filter_id: stored_filter_id,
+        client_id: client_id,
+        filter_class: filter_class
+      }
+    }
+  end
+
+  # For use with the Rails dom_id helper
+  def to_key
+    [client_id]
+  end
+
+  private
+
+  def set_refine_filter_and_blueprint!
+    if stable_id.present?
+      @refine_filter = Refine::Rails.configuration.stabilizer_classes[:url].new.from_stable_id(id: stable_id, initial_query: initial_query)
+      @blueprint = @refine_filter.blueprint
+    else
+      json = blueprint_json || "[]"
+      @blueprint = JSON.parse(json).map(&:deep_symbolize_keys)
+      @refine_filter = filter_class.constantize.new(blueprint, initial_query)
+    end
+  end
+
+  def set_query!
+    @query = Refine::Filters::Query.new(@refine_filter)
+  end
+
+end

data/app/models/refine/filters/criterion.rb

@@ -0,0 +1,87 @@
+class Refine::Filters::Criterion
+  # View model that holds the state of individual criteria within the Filter query
+  include ActiveModel::Model
+  include ActiveModel::Attributes
+
+  attribute :depth, :integer
+  attribute :criterion, :string
+  attribute :condition_id, :string
+  attribute :input
+  attribute :word, :string
+  attribute :type, :string
+  attribute :position, :integer
+  attribute :uid, :string
+
+  attr_accessor :query
+  delegate :filter, to: :query, allow_nil: true
+
+  attr_reader :condition
+
+  def initialize(**attrs)
+    super
+    initialize_condition!
+  end
+
+  def validate!
+    return if (input&.has_key?(:count_refinement) || input&.has_key?(:date_refinement))
+    errors.clear
+    return true if type == "conjunction"
+    begin
+      query_for_validate = filter.initial_query || filter.model.all
+      condition&.apply(input, filter.table, query_for_validate)
+    rescue Refine::Conditions::Errors::ConditionClauseError => e
+      e.errors.each do |error|
+        errors.add(:base, error.full_message)
+      end
+    end
+  end
+
+  def condition_attributes
+    result = condition&.to_array(allow_errors: true)
+    result.to_h
+  end
+
+  def meta
+    condition_attributes[:meta]
+  end
+
+  def selected_clause
+    input[:clause]
+  end
+
+  def selected_clause_meta
+    meta[:clauses].find {|c| c[:id] == selected_clause }[:meta]
+  end
+
+  def refinements
+    condition.refinements_to_array
+  end
+
+  def meta_for_refinement_clause(refinement)
+    refinement_meta = refinement[:meta]
+    selected_clause_id = input[refinement[:id].to_sym][:clause]
+    clauses = refinement_meta[:clauses]
+    selected_clause = clauses.find { |clause| clause[:id] == selected_clause_id }
+    selected_clause[:meta]
+  end
+
+  def component
+    condition.component.underscore
+  end
+
+  private
+
+  def initialize_condition!
+    @condition = query
+      .available_conditions
+      .find { |condition| condition.id == condition_id }
+      .dup
+
+    if @condition
+      @condition.set_filter(filter)
+      filter.translate_display(@condition)
+    elsif type != "conjunction"
+      raise Refine::InvalidFilterError
+    end
+  end
+end

data/app/models/refine/filters/query.rb

@@ -0,0 +1,82 @@
+class Refine::Filters::Query
+  include ActiveModel::Model
+  # View Model for the main section of the filter builder- the dynamic query form
+
+  attr_reader :filter
+
+  def initialize(filter)
+    @filter = filter
+    add_criteria!
+  end
+
+  def validate!
+    @criteria.each(&:validate!)
+  end
+
+  def valid?
+    validate!
+    @criteria.all? { |c| c.errors.empty? }
+  end
+
+  def clear_errors
+    @criteria.each { |c| c.errors.clear }
+  end
+
+  def grouped_criteria
+    # Allow for an empty blueprint
+    return [] if @criteria.blank?
+    [].tap do |result|
+      # start with an empty group
+      result.push []
+      @criteria.each_with_index do |criterion, index|
+        case criterion.word
+        when "or"
+          result.push []
+        when "and"
+          next
+        else
+          result.last.push criterion
+        end
+      end
+    end
+  end
+
+  def available_conditions
+    @filter.conditions
+  end
+
+  def blueprint
+    if @filter.blueprint&.any?
+      @filter.blueprint
+    else
+      []
+    end
+  end
+
+  def configuration
+    @filter.configuration
+  end
+
+
+  # The json representation of conditions that is sent to the front end. 
+  def available_conditions_attributes
+    configuration[:conditions]
+  end
+
+  # TODO make this a more useful data with pointers to which criteria
+  # each error goes with
+  def error_messages
+    @criteria.flat_map {|c| c.errors.full_messages }
+  end
+
+  private
+
+  def add_criteria!
+    @criteria = []
+    blueprint.each.with_index do |criterion_attrs, index|
+      @criteria << Refine::Filters::Criterion.new(
+        **criterion_attrs.merge(query: self, uid: index, position: index)
+      )
+    end
+  end
+end

data/app/models/refine/inline/criteria/input.rb

@@ -0,0 +1,50 @@
+class Refine::Inline::Criteria::Input
+  include ActiveModel::Model
+
+  MODIFIERS = {
+    ago: "days ago",
+    from_now: "days from now"
+  }.freeze
+
+  attr_accessor :clause,
+  :date1,
+  :date2,
+  :days,
+  :modifier,
+  :selected,
+  :value,
+  :value1,
+  :value2,
+  :count_refinement
+
+  def attributes
+    {
+      clause: clause,
+      date1: date1,
+      date2: date2,
+      days: days,
+      modifier: modifier,
+      selected: selected,
+      value: value,
+      value1: value1,
+      value2: value2,
+      count_refinement_attributes: count_refinement_attributes.presence
+    }.compact
+  end
+
+  def count_refinement
+    @count_refinement ||= Refine::Inline::Criteria::NumericRefinement.new
+  end
+
+  def count_refinement_attributes
+    count_refinement.attributes
+  end
+
+  def count_refinement_attributes=(attrs = {})
+    count_refinement.attributes = attrs.to_h
+  end
+
+  def selected=(value)
+    @selected = Array.wrap(value)
+  end
+end

data/app/models/refine/inline/criteria/numeric_refinement.rb

@@ -0,0 +1,13 @@
+class Refine::Inline::Criteria::NumericRefinement
+  include ActiveModel::Model
+
+  attr_accessor :clause, :value1, :value2
+
+  def attributes
+    {
+      clause: clause,
+      value1: value1,
+      value2: value2
+    }.compact
+  end
+end

data/app/models/refine/inline/criteria/option.rb

@@ -0,0 +1,2 @@
+class Refine::Inline::Criteria::Option < Struct.new(:id, :display, keyword_init: true)
+end

data/app/models/refine/inline/criterion.rb

@@ -0,0 +1,141 @@
+class Refine::Inline::Criterion
+  include ActiveModel::Model
+
+  attr_accessor :stable_id,
+    :client_id,
+    :condition_id,
+    :input,
+    :position,
+    :conjunction,
+    :refine_filter
+
+  # initialize a Crtierion object from a blueprint node
+  def self.from_blueprint_node(node, **additional_attrs)
+    attrs = node.deep_dup.merge(additional_attrs)
+
+    # delete some attributes we don't need
+    attrs.delete(:depth)
+    attrs.delete(:type)
+
+    # suffix nested hash keys with '_attributes' to initialize objects
+    attrs[:input_attributes] = attrs.delete(:input)
+    if input_attrs = attrs[:input_attributes]
+      input_attrs[:count_refinement_attributes] = input_attrs.delete(:count_refinement)
+    end
+    new(attrs)
+  end
+
+  # 
+  # Returns a nested array of Criterion objects reflecting the grouping of the OR groups in a filter's blueprint
+  def self.groups_from_filter(refine_filter, **attrs)
+    return [] unless refine_filter&.blueprint.present?
+    [].tap do |result|
+      result.push([])
+      refine_filter.blueprint.each_with_index do |node, i|
+        case node[:word]
+        when "or"
+          result.push []
+        when "and"
+          next
+        else
+          criterion = from_blueprint_node(node, **attrs.merge(refine_filter: refine_filter, position: i))
+          result.last.push criterion
+        end
+      end
+    end
+  end
+
+  def attributes
+    {
+      stable_id: stable_id,
+      client_id: client_id,
+      condition_id: condition_id,
+      position: position,
+      conjunction: conjunction,
+      input_attributes: input_attributes
+    }.compact
+  end
+
+  def to_params
+    {refine_inline_criterion: attributes}
+  end
+
+  def input
+    @input ||= Refine::Inline::Criteria::Input.new
+  end
+
+  def input_attributes
+    input.attributes
+  end
+
+  def input_attributes=(attrs = {})
+    input.attributes = attrs.to_h
+  end
+
+  def to_key
+    [client_id, position, conjunction].map(&:presence).compact
+  end
+
+  def condition
+    @condition ||= begin
+      @refine_filter
+        .instantiated_conditions
+        .find { |c| c.id == condition_id }
+    end
+  end
+
+  def input_partial
+    "refine/inline/inputs/#{condition.component}".underscore
+  end
+
+  def to_blueprint_node
+    result = attributes.slice(:condition_id, :input_attributes)
+    result[:input] = result.delete(:input_attributes)
+    if input_attrs = result[:input]
+      input_attrs[:count_refinement] = input_attrs.delete(:count_refinement_attributes)
+    end
+    result
+  end
+
+  def human_readable_value
+    condition.human_readable_value(to_blueprint_node[:input])
+  end
+
+  def condition_display
+    condition&.display
+  end
+
+  def clause_display
+    condition&.clause_display(input&.clause)
+  end
+
+  def options
+    if condition.respond_to? :get_options
+      condition.get_options.call.map {|option_hash| Refine::Inline::Criteria::Option.new(**option_hash)}
+    end
+  end
+
+  def multiple?
+    selected_clause = condition.clauses.detect {|c| c.id == input.clause } || condition.clauses.first
+    selected_clause.meta[:multiple].present?
+  end
+
+  def validate!
+    # TODO figure out how to validate inputs with count refinements
+    return if input.count_refinement.attributes.present?
+    errors.clear
+    begin
+      query_for_validate = refine_filter.initial_query || refine_filter.model.all
+      condition&.apply(input_attributes, refine_filter.table, query_for_validate)
+    rescue Refine::Conditions::Errors::ConditionClauseError => e
+      e.errors.each do |error|
+        errors.add(:base, error.full_message)
+      end
+    end
+  end
+
+  def valid?
+    validate!
+    errors.empty?
+  end
+end

data/app/models/refine/invalid_filter_error.rb

@@ -0,0 +1,8 @@
+class Refine::InvalidFilterError < StandardError
+  attr_reader :filter
+
+  def initialize(msg="Filter is invalid", filter: nil)
+    @msg = msg
+    filter = filter
+  end
+end

data/app/models/refine/stabilize.rb

@@ -0,0 +1,29 @@
+module Refine
+  module Stabilize
+
+    def automatically_stabilize?
+      false
+    end
+
+    def automatic_stable_id_generator
+      self.class.default_stabilizer
+    end
+
+    def to_optional_stable_id(stabilizer=nil)
+      create_stable_id(stabilizer) if automatically_stabilize?
+    end
+
+    def create_stable_id(stabilizer=nil)
+      make_stable_id_generator(stabilizer).new.to_stable_id(filter: self)
+    end
+
+    def make_stable_id_generator(stabilizer = nil)
+      generator = stabilizer || automatic_stable_id_generator
+      if generator.blank?
+        raise ArgumentError.new('No stable id class set. Set using the default_stable_id_generator method')
+      end
+      generator
+    end
+
+  end
+end

data/app/models/refine/stabilizers/database_stabilizer.rb

@@ -0,0 +1,21 @@
+module Refine
+  module Stabilizers
+    class DatabaseStabilizer
+
+      def to_stable_id(filter:, name: nil)
+        # Serialize the filter class and blueprint. Reference via id.
+        model.find_or_create_by!(state: filter.state, name: name).id
+      end
+
+      def from_stable_id(id:, initial_query: nil)
+        # Find the associated StoredFilter by id and return state. Decode to create blueprint
+        state = ActiveSupport::JSON.decode(model.find(id).state).deep_symbolize_keys
+        Refine::Filter.from_state(state, initial_query)
+      end
+
+      def model
+        Refine::StoredFilter
+      end
+    end
+  end
+end

data/app/models/refine/stabilizers/errors/url_stabilizer_error.rb

@@ -0,0 +1,2 @@
+class Refine::Stabilizers::Errors::UrlStabilizerError < StandardError
+end

data/app/models/refine/stabilizers/url_encoded_stabilizer.rb

@@ -0,0 +1,21 @@
+module Refine
+  module Stabilizers
+    class UrlEncodedStabilizer
+
+      def to_stable_id(filter:)
+        compressed_state = ActiveSupport::Gzip.compress(filter.state)
+        encoded_state = Base64.encode64(compressed_state)
+        CGI.escape(encoded_state)
+      end
+
+      def from_stable_id(id:, initial_query: nil)
+        raise Refine::Stabilizers::Errors::UrlStabilizerError if id.blank?
+        url_decoded = CGI.unescape(id)
+        base_64_decoded = Base64.decode64(url_decoded)
+        uncompress = ActiveSupport::Gzip.decompress(base_64_decoded)
+        state = ActiveSupport::JSON.decode(uncompress).deep_symbolize_keys
+        Refine::Filter.from_state(state, initial_query)
+      end
+    end
+  end
+end

data/app/models/refine/stored_filter.rb

@@ -0,0 +1,14 @@
+module Refine
+  class StoredFilter < ApplicationRecord
+    validates_presence_of :state
+    self.table_name = "refine_stored_filters"
+
+    def refine_filter(initial_query: nil)
+      Refine::Rails.configuration.stabilizer_classes[:db].new.from_stable_id(id: id, initial_query: initial_query)
+    end
+
+    def blueprint
+      JSON.parse(state)["blueprint"]
+    end
+  end
+end