refine-rails 2.9.0

data/app/javascript/controllers/refine/update-controller.js

@@ -0,0 +1,86 @@
+import ServerRefreshController from './server-refresh-controller'
+import { debounce } from 'lodash'
+
+export default class extends ServerRefreshController {
+  static values = {
+    criterionId: Number,
+  }
+
+  initialize() {
+    this.updateBlueprint = debounce((event, value, inputKey) => {
+      this.value(event, value, inputKey)
+    }, 500)
+  }
+
+  refinedFilter(event) {
+    const { criterionIdValue, state } = this
+    const dataset = event.target.dataset
+    const inputId = dataset.inputId
+
+    state.updateInput(
+      criterionIdValue,
+      {
+        id: event.target.value,
+      },
+      inputId
+    )
+    this.refreshFromServer()
+  }
+
+  clause(event) {
+    const { criterionIdValue, state } = this
+    const dataset = event.target.dataset
+    const inputId = dataset.inputId
+    state.updateInput(
+      criterionIdValue,
+      {
+        clause: event.target.value,
+      },
+      inputId
+    )
+    this.refreshFromServer()
+  }
+
+  selected(event) {
+    const { target: select } = event
+    const options = Array.prototype.slice.call(select.options)
+    const selectedOptions = options.filter((option) => option.selected)
+    const selected = selectedOptions.map((option) => option.value)
+    this.value(event, selected, 'selected')
+  }
+
+  value(event, value, inputKey) {
+    const { criterionIdValue, state } = this
+    const dataset = event.target.dataset
+    const inputId = dataset.inputId
+    inputKey = inputKey || dataset.inputKey || 'value'
+    value = value || event.target.value
+    state.updateInput(
+      criterionIdValue,
+      {
+        [inputKey]: value,
+      },
+      inputId
+    )
+  }
+
+  condition(event) {
+    const { criterionIdValue, state } = this
+    const element = event.target
+    let newConditionId = element.value
+    if (!newConditionId) newConditionId = element.querySelector('select').value    
+    const config = this.state.conditionConfigFor(newConditionId)
+    const updatePerformed = state.replaceCriterion(criterionIdValue, newConditionId, config)
+    if (updatePerformed) {
+      this.refreshFromServer()
+    }
+  }
+
+  // Prevent form submission when hitting enter in a text box
+  cancelEnter(event) {
+    if (event.code === "Enter") {
+      event.preventDefault()
+      event.stopPropagation()
+    }
+  }
+}

data/app/javascript/index.js

@@ -0,0 +1 @@
+export * from './controllers'

data/app/javascript/refine/helpers/index.js

@@ -0,0 +1,77 @@
+// Polyfill for custom events in IE9-11
+// https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent/CustomEvent#polyfill
+;(function () {
+  if (typeof window.CustomEvent === 'function') return false
+
+  function CustomEvent(event, params) {
+    params = params || { bubbles: false, cancelable: false, detail: undefined }
+    var evt = document.createEvent('CustomEvent')
+    evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail)
+    return evt
+  }
+
+  CustomEvent.prototype = window.Event.prototype
+
+  window.CustomEvent = CustomEvent
+
+  // eslint expects a return here
+  return true
+})()
+
+export const filterStabilizedEvent = (element, stableId, filterName) => {
+  const event = new CustomEvent('filter-stabilized', {
+    bubbles: true,
+    cancelable: true,
+    detail: {
+      stableId,
+      filterName,
+    },
+  })
+  element.dispatchEvent(event)
+}
+
+export const filterUnstableEvent = (blueprint) => {
+  const event = new CustomEvent('filter-unstable', {
+    bubbles: true,
+    cancelable: true,
+    detail: {
+      blueprint,
+    },
+  })
+  window.dispatchEvent(event)
+}
+
+export const filterInvalidEvent = ({blueprint, errors}) => {
+  const event = new CustomEvent('filter-invalid', {
+    bubbles: true,
+    cancelable: true,
+    detail: {
+      blueprint,
+      errors,
+    },
+  })
+  window.dispatchEvent(event)
+}
+
+export const filterStoredEvent = (storedFilterId) => {
+  const event = new CustomEvent('filter-stored', {
+    bubbles: true,
+    cancelable: true,
+    detail: {
+      storedFilterId,
+    },
+  })
+  window.dispatchEvent(event)
+}
+
+export const blueprintUpdatedEvent = (element, {blueprint, formId}) => {
+  const event = new CustomEvent('blueprint-updated', {
+    bubbles: true,
+    cancelable: true,
+    detail: {
+      blueprint,
+      formId
+    },
+  })
+  element.dispatchEvent(event)
+}

data/app/models/refine/blueprints/blueprint.rb

@@ -0,0 +1,58 @@
+module Refine::Blueprints
+  class Blueprint
+    # DSL-based model for building filter blueprints
+    attr_reader :blueprint
+
+    def initialize
+      @blueprint = []
+      @depth = 0
+    end
+
+    def group(&block)
+      @depth = @depth += 1
+      instance_eval(&block)
+      @depth = @depth -= 1
+      self
+    end
+
+    def criterion(condition_id, input)
+      if !@blueprint.blank? && @blueprint.last[:type] == "criterion"
+        raise "Conjunction missing"
+      end
+
+      add({
+        depth: @depth,
+        type: "criterion",
+        condition_id: condition_id,
+        input: input,
+      })
+      self
+    end
+
+    def conjunction(word)
+      add({
+        depth: @depth,
+        type: "conjunction",
+        word: word
+      })
+    end
+
+    def and
+      conjunction("and")
+      self
+    end
+
+    def or
+      conjunction("or")
+      self
+    end
+
+    def add(item)
+      @blueprint.append(item)
+    end
+
+    def to_array
+      @blueprint
+    end
+  end
+end

data/app/models/refine/blueprints/blueprint_example.json

@@ -0,0 +1,25 @@
+[
+  {
+    "depth": 0,
+    "type": "criterion",
+    "condition_id": "some_text_condition",
+    "input": {
+      "clause": "eq",
+      "value": "aaron"
+    }
+  },
+  {
+    "depth": 0,
+    "type": "conjunction",
+    "word": "and"
+  },
+  {
+    "depth": 0,
+    "type": "criterion",
+    "condition_id": "some_text_condition",
+    "input": {
+      "clause": "sw",
+      "value": "aa"
+    }
+  }
+]

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

@@ -0,0 +1,112 @@
+module Refine::Conditions
+  class BooleanCondition < Condition
+    include HasClauses
+
+    CLAUSE_TRUE = Clauses::TRUE
+    CLAUSE_FALSE = Clauses::FALSE
+    CLAUSE_SET = Clauses::SET # non null
+    CLAUSE_NOT_SET = Clauses::NOT_SET # null
+
+    I18N_PREFIX = "refine.refine_blueprints.boolean_condition."
+
+    def component
+      "boolean-condition"
+    end
+
+    def human_readable(input)
+      current_clause = get_clause_by_id(input[:clause])
+      if input[:value]
+        "#{display} #{current_clause.display} #{input[:value]}"
+      else
+        "#{display} #{current_clause.display}"
+      end
+    end
+
+    def boot
+      @nulls_are = nil
+      hide_unknowns
+    end
+
+    def hide_unknowns
+      without_clauses([
+        CLAUSE_SET,
+        CLAUSE_NOT_SET,
+      ])
+      self
+    end
+
+    def nulls_are_true
+      @nulls_are = true
+      self
+    end
+
+    def nulls_are_false
+      @nulls_are = false
+      self
+    end
+
+    def nulls_are_unknown
+      @nulls_are = nil
+      self
+    end
+
+    def show_unknowns
+      with_clauses([
+        CLAUSE_SET,
+        CLAUSE_NOT_SET
+      ])
+      self
+    end
+
+    def clauses
+      [
+        Clause.new(CLAUSE_TRUE, I18n.t("#{I18N_PREFIX}is_true")),
+        Clause.new(CLAUSE_FALSE, I18n.t("#{I18N_PREFIX}is_false")),
+        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)
+      case clause
+      when CLAUSE_SET
+        apply_clause_set(table)
+
+      when CLAUSE_NOT_SET
+        apply_clause_not_set(table)
+
+      when CLAUSE_TRUE
+        apply_clause_true(table)
+
+      when CLAUSE_FALSE
+        apply_clause_false(table)
+      end
+
+      # Apply a custom clause
+    end
+
+    def apply_clause_set(table)
+      table.grouping(table[:"#{attribute}"].not_eq(nil))
+    end
+
+    def apply_clause_not_set(table)
+      table.grouping(table[:"#{attribute}"].eq(nil))
+    end
+
+    def apply_clause_true(table)
+      apply_clause_bool(table, true)
+    end
+
+    def apply_clause_bool(table, bool)
+      if @nulls_are == bool
+        table.grouping(table[:"#{attribute}"].eq(bool).or(table[:"#{attribute}"].eq(nil)))
+      else
+        table.grouping(table[:"#{attribute}"].eq(bool))
+      end
+    end
+
+    def apply_clause_false(table)
+      apply_clause_bool(table, false)
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Refine::Conditions
+  class Clause
+    include HasMeta
+
+    attr_reader :id, :rules
+    attr_accessor :display
+
+    I18N_PREFIX = "refine.refine_blueprints.clause."
+
+    def initialize(id = nil, display = nil)
+      @id = id
+      @display = display || id.humanize(keep_id_suffix: true).titleize
+      @rules = {}
+      @messages
+    end
+
+    def with_rules(user_defined_hash)
+      @rules.merge!(user_defined_hash)
+      self
+    end
+
+    def requires_inputs(fields)
+      # Coerce field to an array
+      [*fields].each do |field|
+        @rules.merge!({"#{field}": I18n.t("#{I18N_PREFIX}required")})
+      end
+      self
+    end
+
+    def to_array
+      {
+        id: @id,
+        display: @display,
+        meta: meta
+      }
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Refine::Conditions
+  class Clauses
+    EQUALS = "eq"
+    DOESNT_EQUAL = "dne"
+
+    SET = "st"
+    NOT_SET = "nst"
+
+    TRUE = "true"
+    FALSE = "false"
+
+    LESS_THAN_OR_EQUAL = "lte"
+    LESS_THAN = "lt"
+    BETWEEN = "btwn"
+    NOT_BETWEEN = "nbtwn"
+    GREATER_THAN = "gt"
+    GREATER_THAN_OR_EQUAL = "gte"
+
+    EXACTLY = "exct"
+
+    EXISTS = "exst"
+    DOESNT_EXIST = "dexst"
+
+    IN = "in"
+    NOT_IN = "nin"
+
+    CONTAINS = "cont"
+    DOESNT_CONTAIN = "dcont"
+
+    STARTS_WITH = "sw"
+    ENDS_WITH = "ew"
+
+    DOESNT_START_WITH = "dsw"
+    DOESNT_END_WITH = "dew"
+
+    FLIPPABLE = [NOT_IN, DOESNT_EQUAL].freeze
+  end
+end