refine-rails 2.9.0

data/app/models/refine/conditions/text_condition.rb

@@ -0,0 +1,152 @@
+module Refine::Conditions
+  class TextCondition < Condition
+    include HasClauses
+
+    CLAUSE_EQUALS = Clauses::EQUALS
+    CLAUSE_DOESNT_EQUAL = Clauses::DOESNT_EQUAL
+
+    CLAUSE_STARTS_WITH = Clauses::STARTS_WITH
+    CLAUSE_ENDS_WITH = Clauses::ENDS_WITH
+    CLAUSE_DOESNT_START_WITH = Clauses::DOESNT_START_WITH
+    CLAUSE_DOESNT_END_WITH = Clauses::DOESNT_END_WITH
+
+    CLAUSE_CONTAINS = Clauses::CONTAINS
+    CLAUSE_DOESNT_CONTAIN = Clauses::DOESNT_CONTAIN
+
+    CLAUSE_SET = Clauses::SET
+
+    CLAUSE_NOT_SET = Clauses::NOT_SET
+
+    I18N_PREFIX = "refine.refine_blueprints.text_condition."
+
+    def component
+      "text-condition"
+    end
+
+    def human_readable(input)
+      current_clause = get_clause_by_id(input[:clause])
+      if input[:clause].in? [CLAUSE_SET, CLAUSE_NOT_SET]
+        "#{display} #{current_clause.display}"
+      else
+        "#{display} #{current_clause.display} #{input[:value]}"
+      end
+    end
+
+    def human_readable_value(input)
+      current_clause = get_clause_by_id(input[:clause])
+      if input[:clause].in? [CLAUSE_SET, CLAUSE_NOT_SET]
+        ""
+      else
+        input[:value]
+      end
+    end
+
+    def clauses
+      [
+        Clause.new(CLAUSE_EQUALS, I18n.t("#{I18N_PREFIX}is"))
+          .requires_inputs(["value"]),
+
+        Clause.new(CLAUSE_DOESNT_EQUAL, I18n.t("#{I18N_PREFIX}is_not"))
+          .requires_inputs(["value"]),
+
+        Clause.new(CLAUSE_STARTS_WITH, I18n.t("#{I18N_PREFIX}starts_with"))
+          .requires_inputs(["value"]),
+
+        Clause.new(CLAUSE_ENDS_WITH, I18n.t("#{I18N_PREFIX}ends_with"))
+          .requires_inputs(["value"]),
+
+        Clause.new(CLAUSE_DOESNT_START_WITH, I18n.t("#{I18N_PREFIX}does_not_start_with"))
+          .requires_inputs(["value"]),
+
+        Clause.new(CLAUSE_DOESNT_END_WITH, I18n.t("#{I18N_PREFIX}does_not_end_with"))
+          .requires_inputs(["value"]),
+
+        Clause.new(CLAUSE_CONTAINS, I18n.t("#{I18N_PREFIX}contains"))
+          .requires_inputs(["value"]),
+
+        Clause.new(CLAUSE_DOESNT_CONTAIN, I18n.t("#{I18N_PREFIX}does_not_contain"))
+          .requires_inputs(["value"]),
+
+        Clause.new(CLAUSE_SET, I18n.t("#{I18N_PREFIX}is_set")),
+
+        Clause.new(CLAUSE_NOT_SET, I18n.t("#{I18N_PREFIX}is_not_set"))
+      ]
+    end
+
+    def apply_condition(input, table, _inverse_clause)
+      value = input[:value]
+
+      case clause
+      when CLAUSE_EQUALS
+        apply_clause_equals(value, table)
+
+      when CLAUSE_DOESNT_EQUAL
+        apply_clause_doesnt_equal(value, table)
+
+      when CLAUSE_STARTS_WITH
+        apply_clause_starts_with(value, table)
+
+      when CLAUSE_ENDS_WITH
+        apply_clause_ends_with(value, table)
+
+      when CLAUSE_DOESNT_START_WITH
+        apply_clause_doesnt_start_with(value, table)
+
+      when CLAUSE_DOESNT_END_WITH
+        apply_clause_doesnt_end_with(value, table)
+
+      when CLAUSE_CONTAINS
+        apply_clause_contains(value, table)
+
+      when CLAUSE_DOESNT_CONTAIN
+        apply_clause_doesnt_contain(value, table)
+
+      when CLAUSE_SET
+        apply_clause_set(value, table)
+
+      when CLAUSE_NOT_SET
+        apply_clause_not_set(value, table)
+      end
+    end
+
+    def apply_clause_equals(value, table)
+      table.grouping(arel_attribute(table).eq(value))
+    end
+
+    def apply_clause_doesnt_equal(value, table)
+      table.grouping(arel_attribute(table).not_eq(value).or(arel_attribute(table).eq(nil)))
+    end
+
+    def apply_clause_starts_with(value, table)
+      table.grouping(arel_attribute(table).matches("#{value}%"))
+    end
+
+    def apply_clause_ends_with(value, table)
+      table.grouping(arel_attribute(table).matches("%#{value}"))
+    end
+
+    def apply_clause_contains(value, table)
+      table.grouping(arel_attribute(table).matches("%#{value}%"))
+    end
+
+    def apply_clause_doesnt_contain(value, table)
+      table.grouping(arel_attribute(table).does_not_match("%#{value}%").or(arel_attribute(table).eq(nil)))
+    end
+
+    def apply_clause_set(_, table)
+      table.grouping(arel_attribute(table).not_eq_all([nil, ""]))
+    end
+
+    def apply_clause_not_set(_, table)
+      table.grouping(arel_attribute(table).eq_any([nil, ""]))
+    end
+
+    def apply_clause_doesnt_start_with(value, table)
+      table.grouping(arel_attribute(table).does_not_match("#{value}%"))
+    end
+
+    def apply_clause_doesnt_end_with(value, table)
+      table.grouping(arel_attribute(table).does_not_match("%#{value}"))
+    end
+  end
+end

data/app/models/refine/conditions/uses_attributes.rb

@@ -0,0 +1,168 @@
+module Refine::Conditions
+  module UsesAttributes
+
+    def with_attribute(value)
+      @attribute = value
+      self
+    end
+
+    def apply_relationship_attribute(input:, query:)
+      # Split on first .
+      decompose_attribute = @attribute.split(".", 2)
+      # Attribute now is the back half of the initial attribute
+      @attribute = decompose_attribute[1]
+
+      if !@attribute.include?(".")
+        # No more .s, deepest level
+        @on_deepest_relationship = true
+      end
+      # Relation to be handled
+      relation = decompose_attribute[0]
+
+      # Get the Reflection object which defines the relationship between query and relation
+      # First iteration pull relationship using base query which responds to model.
+      instance = if query.respond_to? :model
+        query.model.reflect_on_association(relation.to_sym)
+      else
+        # When query is sent in as subquery (recursive) the query object is the model class pulled from the
+        # previous instance value
+        query.reflect_on_association(relation.to_sym)
+      end
+
+      unless instance
+        raise "Relationship does not exist for #{relation}."
+      end
+
+      filter.set_pending_relationship(relation, instance)
+      
+      # If the current condition is a refinement (filter refinement) set collapsible to true 
+      if is_refinement
+        filter.allow_pending_relationship_to_collapse
+      end
+
+      if can_use_where_in_relationship_subquery?(instance)
+        create_pending_wherein_subquery(input: input, relation: relation, instance: instance, query: query)
+      else
+        create_pending_has_many_through_subquery(input: input, relation: relation, instance: instance, query: query)
+      end
+
+      filter.release_pending_relationship
+      # We want the method to return nil for relationship attributes
+      # The purpose of this method is to populate pending relationship subqueries
+      nil
+    end
+
+    def key_1(instance)
+      # Foreign key on belongs to, primary key on HasMany
+      if instance.is_a? ActiveRecord::Reflection::BelongsToReflection
+        instance.foreign_key.to_sym
+      else
+        instance.active_record_primary_key.to_sym
+      end
+    end
+
+    def key_2(instance)
+      if instance.is_a? ActiveRecord::Reflection::BelongsToReflection
+        instance.active_record_primary_key.to_sym
+      else
+        instance.foreign_key.to_sym
+      end
+    end
+
+    def create_pending_wherein_subquery(input:, relation:, instance:, query:)
+      # This method builds out the linking keys between the provided query model and the relation
+      # and saves it to pending relationship subqueries
+      # Class of the relation as held in the AR::Relation object
+      relation_class = instance.klass
+
+      # Pull what's already in the tracker at this depth if already traversed
+      subquery = filter.get_pending_relationship_subquery || relation_class.select([key_2(instance)]).arel
+
+      # Primary/secondary keys keep track of how to link tables
+      # If depth has been added (i.e. filter.pending_relationship_subquery_depth = [:btt_user, :btt_notes])
+      # This will add the [:children] key to the pending_relationship_subqueries tracker under the parent key [:btt_user]
+      filter.add_pending_relationship_subquery(subquery: subquery, primary_key: key_1(instance), secondary_key: key_2(instance))
+
+      # Apply the condition. If a nested relationship, this apply is adding the children key (with values) to the pending_relationship_subqueries tracker
+      # due to the recursive nature of the apply method. This is critical because it get is then "rolled up" in release_pending_relationship
+      node = apply(input, relation_class.arel_table, relation_class, false)
+
+      # If node is an AREL::SELECT manager we are allowing the apply condition to return a fully formed subquery - we replace
+      # the linking keys in the tracker with the fully formed select query
+      # Has not been tested more than one level deep
+      if node.is_a? Arel::SelectManager
+        filter.add_pending_relationship_subquery(subquery: node, primary_key: key_1(instance), secondary_key: key_2(instance))
+      elsif node
+        # This modifies subquery *in* the pending_relationship_subqueries tracker.
+        subquery.where(node)
+      end
+    end
+
+    def group(nodes)
+      Arel::Nodes::Grouping.new(nodes)
+    end
+
+    # Determine if the clause should be flipped. For example, "not_eq" => "eq". Must also change "in" to "not in" upstream
+    # @param [Object] instance
+    # @param [String] clause The join clause (example: `eq` or `not_eq`)
+    # @return [Boolean]
+    def should_inverse_clause?(instance, clause)
+      is_through_reflection = instance.is_a?(ActiveRecord::Reflection::ThroughReflection)
+      is_inverse_clause_flippable = Clauses::FLIPPABLE.include?(clause)
+
+      is_through_reflection && is_inverse_clause_flippable
+    end
+
+    def create_pending_has_many_through_subquery(input:, relation:, instance:, query:)
+      # In a has_many relationship the negative has to be flipped to positive. 
+      inverse_clause = should_inverse_clause?(instance, input[:clause])
+      # Ex: A country has many posts through hmtt_users.
+      # Use AR to properly join the relation to the base query provided
+      # Convert to AREL to use with nodes 
+      subquery_path = query.model.select(key_1(instance)).joins(relation.to_sym).arel
+      relation_table_being_queried = instance.klass.arel_table
+
+      relation_class = instance.klass
+      
+      node_to_apply = apply(input, relation_table_being_queried, relation_class, inverse_clause)
+
+      complete_subquery = subquery_path.where(node_to_apply)
+      subquery = filter.get_pending_relationship_subquery || complete_subquery
+      filter.add_pending_relationship_subquery(subquery: subquery, primary_key: key_1(instance), secondary_key: nil, inverse_clause: inverse_clause)
+    end
+
+    def can_use_where_in_relationship_subquery?(instance)
+      # Where in only works for belongs to, has one, or has many
+      (instance.is_a? ActiveRecord::Reflection::BelongsToReflection) || (instance.is_a? ActiveRecord::Reflection::HasManyReflection) || (instance.is_a? ActiveRecord::Reflection::HasOneReflection)
+    end
+
+    def is_relationship_attribute?
+      # TODO: Allow user to decide attribute is not a relationship
+      # If we are on the deepest relationship, it's no longer a relationship attribute
+      return false if @on_deepest_relationship
+      # If the attribute includes a ., it's a relationship attribute
+      @attribute.include?(".")
+    end
+
+    def raw_attribute(attribute)
+      @attribute = Arel.sql(attribute)
+
+      self
+    end
+
+    # TODO Examine the existing relationships and suggest model names if not instance is found 
+    # def get_relationships(query)
+      # if query.respond_to? :model
+      #   associations = query.model.reflect_on_all_associations
+      # else
+      #   associations = query.reflect_on_all_associations
+      # end
+      # associations.map{|entry| puts entry.class, entry.foreign_key, entry.klass }
+      # differences=[]
+      # associations.each do association
+      #   differences << String::Similarity.levenshtein_distance(relation, association )
+      # end
+      # differences
+    # end
+  end
+end

data/app/models/refine/filter.rb

@@ -0,0 +1,302 @@
+module Refine
+  class Filter
+    include ActiveModel::Validations
+    include ActiveModel::Callbacks
+    include TracksPendingRelationshipSubqueries
+    include Stabilize
+    # This validation structure sents `initial_query` as the method to validate against
+    define_model_callbacks :initialize, only: [:after]
+    after_initialize :valid?
+
+    cattr_accessor :default_stabilizer, default: nil, instance_accessor: false
+    cattr_accessor :criteria_limit, default: 5, instance_accessor: true
+
+    attr_reader :blueprint, :initial_query
+
+    # Give each Filter subclass its own default_condition_id,
+    # that is also also readable from instances
+    #
+    # class UserFilter
+    #   self.default_condition_id = "email"
+    # # ...
+    # end
+    #
+    class << self
+      attr_accessor :default_condition_id
+    end
+    delegate :default_condition_id, to: :class
+
+    def initialize(blueprint = nil, query_scope = nil)
+      run_callbacks :initialize do
+        # If using this in test mode, `blueprint` will be an instance of
+        # `Blueprint` and the value must be extracted
+        if blueprint.is_a? Blueprints::Blueprint
+          blueprint = blueprint.to_array
+        end
+        @initial_query = query_scope
+        @blueprint = blueprint
+        @relation = initial_query
+        @immediately_commit_pending_relationship_subqueries = false
+        @@default_stabilizer = Refine::Stabilizers::UrlEncodedStabilizer
+      end
+    end
+
+    # DEPRECATED use Refine::Filters::Criterion#human_readable instead
+    def human_readable_criterions
+      output = []
+      if blueprint.present?
+        blueprint.each do |criterion|
+          if criterion[:type] == "conjunction"
+            output << criterion[:word]
+          else
+            output << get_condition_for_criterion(criterion).human_readable(criterion[:input])
+          end
+        end
+      end
+      output
+    end
+
+    def automatically_stabilize?
+      true
+    end
+
+    # e.g. ContactsFilter -> Contact
+    def model
+      initial_query&.model || self.class.to_s.gsub(/Filter$/, "").singularize.constantize
+    end
+
+    def table
+      model.arel_table
+    end
+
+    def valid_query?
+      get_query
+      errors.none?
+    end
+
+    def get_query
+      raise "Initial query must exist" if initial_query.nil?
+      if blueprint.present?
+        @relation.where(group(make_sub_query(blueprint)))
+      else
+        @relation
+      end
+    end
+
+    def get_query!
+      result = get_query
+      raise Refine::InvalidFilterError.new(filter: self) unless errors.none?
+      result
+    end
+
+    def add_nodes_to_query(subquery:, nodes:, query_method:)
+      # Apply existing nodes to existing subquery
+      if subquery.present? && nodes.present?
+        subquery = if query_method == "and"
+          # Apply the nodes using the AREL AND method
+          subquery.send(query_method, group(nodes))
+        else
+          # Override the AREL OR method in order to remove the automatic parens
+          Arel::Nodes::Or.new(subquery, group(nodes))
+        end
+      # No nodes returned, do nothing
+      elsif subquery.present? && nodes.blank?
+        subquery
+      # Subquery has not yet been initialized, initialize with new nodes - must use !nil? here, present/exists/blank etc don't
+      # account for AR::Relation object.
+      elsif subquery.blank? && !nodes.nil?
+        subquery = group(nodes)
+      end
+      subquery
+    end
+
+    def make_sub_query(modified_blueprint, depth = 0, subquery = nil)
+      # Need index control to directly skip indicies in fast forward (recursive call)
+      index = 0
+      while index < modified_blueprint.length
+        criterion = modified_blueprint[index]
+        # Decreasing depth, pass control back to caller
+        break if criterion[:depth] < depth
+
+        # If it's a conjunction, the next condition will handle it.
+        if criterion[:type] == "conjunction"
+          index += 1
+          next
+        end
+
+        # Check the word on the previous blueprint method. If it is not 'and'....?
+        query_method = if index == 0
+          "and"
+        else
+          modified_blueprint[index - 1][:word] == "and" ? "and" : "or"
+        end
+
+        # If the new depth is deeper than our current depth, that means we're
+        # starting a new group. We'll recursively call this method again
+        # with a subset of the blueprint.
+        if criterion[:depth] > depth
+          # Modify the array to send in the elements not yet handled (depth>current depth)
+          new_depth_array = modified_blueprint[index..-1]
+
+          # Return the nodes in () for elements on the same depth
+          recursive_nodes = make_sub_query(new_depth_array, depth + 1)
+
+          # Add the recursive subquery nodes to the existing query and modify the query
+          subquery = add_nodes_to_query(subquery: subquery, nodes: recursive_nodes, query_method: query_method)
+
+          # Skip indexes handled by recursive call
+          index = fast_forward(index, modified_blueprint, depth) + 1
+          next
+        end
+        # If there are any ORs at this depth, commit subqueries
+        @immediately_commit_pending_relationship_subqueries = if modified_blueprint.select { |item| (item[:type] == "conjunction" && item[:word] == "or" && item[:depth] == depth) }.present?
+          true
+        else
+          false
+        end
+
+        # If it is a relationship attribute apply_condition will call apply_relationship_attribute which will set up the pending relationship
+        # subquery but will not return a value.
+        # apply condition is NOT idempotent, hence the placeholder var
+        nodes_to_apply = apply_condition(criterion)
+        # If an error has been added to the errors array from apply_condition, do not continue execution at this level
+        if errors.any?
+          index += 1
+          next
+        end
+
+        subquery = add_nodes_to_query(subquery: subquery, nodes: nodes_to_apply, query_method: query_method)
+
+        if @immediately_commit_pending_relationship_subqueries.present?
+          committed_nodes_from_pending = commit_pending_relationship_subqueries
+          subquery = add_nodes_to_query(subquery: subquery, nodes: committed_nodes_from_pending, query_method: query_method)
+        end
+
+        index += 1
+      end
+
+      unless errors.any?
+        final_depth_nodes = commit_pending_relationship_subqueries
+        # Add nodes to existing query and return existing query
+        add_nodes_to_query(subquery: subquery, nodes: final_depth_nodes, query_method: query_method)
+      end
+    end
+
+    def fast_forward(index, modified_blueprint, depth)
+      fast_forward_index = (index..modified_blueprint.length - 1).each do |cursor|
+        break cursor if modified_blueprint[cursor][:depth] <= depth
+      end
+      # TODO refactor for clarity. If I break early from the iterator I have an int. If not,
+      # default to modfied_blueprint.length -1 as the correct value
+      (fast_forward_index.is_a? Integer) ? fast_forward_index : modified_blueprint.length - 1
+    end
+
+    def group(nodes)
+      Arel::Nodes::Grouping.new(nodes)
+    end
+
+    def apply_condition(criterion)
+      begin
+        get_condition_for_criterion(criterion)&.apply(criterion[:input], table, initial_query)
+      rescue Refine::Conditions::Errors::ConditionClauseError => e
+        e.errors.each do |error|
+          errors.add(:base, error.full_message, criterion_uid: criterion[:uid])
+        end
+      end
+    end
+
+    def get_condition_for_criterion(criterion)
+      # Returns the object that matches the condition. Adds errors if not found.
+      # This checks the id on the condition such as text_test
+      returned_object = conditions.find { |condition| condition.id == criterion[:condition_id] }
+      if returned_object.nil?
+        errors.add(:filter, "The condition ID #{criterion[:condition_id]} was not found")
+      else
+        # Set filter variable on condition
+        instantiate_condition(returned_object)
+      end
+      # Must duplicate the condition so nested attributes don't bleed into one another
+      returned_object.dup
+    end
+
+    def configuration
+      {
+        type: "Refine",
+        class_name: self.class.name,
+        blueprint: @blueprint,
+        conditions: conditions_to_array,
+        stable_id: to_optional_stable_id
+      }
+    end
+
+    def conditions_to_array
+      return nil unless conditions
+      # Set filter object on condition and return to_array
+      conditions.map { |condition| instantiate_condition(condition) }.map(&:to_array)
+    end
+
+    def instantiate_condition(condition)
+      condition.set_filter(self)
+      translate_display(condition)
+      condition
+    end
+
+    # Set filter object on condition and sort alphabetically
+    def instantiated_conditions
+      conditions
+        .map { |c| instantiate_condition(c.dup) }
+        .sort_by { |c| c.display.to_s.downcase }
+    end
+
+    def translate_display(condition)
+      # If there are no locale definitions for this condition's subject, we can allow I18n to use a human-readable version of the ID.
+      # But, ideally, they have locales defined and we can find one of those.
+      label_fallback = {default: condition.id.humanize(keep_id_suffix: true).titleize}
+      condition.display = condition.display || I18n.t(".filter.conditions.#{condition.id}.label", default: I18n.t(".fields.#{condition.id}.label", **label_fallback))
+    end
+
+    def state
+      {
+        type: type,
+        blueprint: blueprint
+      }.to_json
+    end
+
+    def type
+      self.class.name
+    end
+
+    def self.from_state(state, initial_query = nil)
+      klass = state[:type].constantize
+      filter = klass.new(state[:blueprint], initial_query)
+    end
+
+    def self.default_stable_id_generator(klass)
+      if klass.method_defined?(:to_stable_id) && klass.method_defined?(:from_stable_id)
+        @@default_stabilizer = klass
+      else
+        raise ArgumentError.new('Given class doesn\'t implement to_stable_id and from_stable_id!')
+      end
+    end
+
+    def to_stable_id
+       Refine::Rails.configuration.stabilizer_classes[:url].new.to_stable_id(filter: self)
+    end
+
+    def blueprint_criteria
+      blueprint&.filter { |node| node.is_a?(Hash) && node[:type] == 'criterion' }.to_a
+    end
+
+    def criteria_limit_exceeded?
+      criteria_limit_set? && blueprint_criteria.length > criteria_limit
+    end
+
+    def criteria_limit_reached?
+      criteria_limit_set? && blueprint_criteria.length >= criteria_limit
+    end
+
+    def criteria_limit_set?
+      criteria_limit.to_i.positive?
+    end
+  end
+end