dynamic_scope 0.5.4

data/app/assets/stylesheets/dynamic_scope.sass

@@ -0,0 +1,104 @@
+.dynamic_scope
+  fieldset
+    position: relative
+    margin: 5px 0
+    a
+      position: relative
+      top: 5px
+      &:before
+        content: image-url('dynamic_scope/fieldset-remove.png')
+
+  .dynamic_scope_add
+    text-decoration: none
+    font-size: 90%
+    span
+      text-decoration: underline
+
+  .dynamic_scope_add_and_submit
+    text-align: right
+
+    input
+      margin-bottom: 5px
+
+    .dynamic_scope_add
+      float: left
+
+  .dynamic_scope_inputs
+    float: left
+
+  .dynamic_scope_clear
+    text-decoration: underline
+
+  .dynamic_scope_value
+    width: 24em
+
+  .dynamic_scope_column, .dynamic_scope_operator
+    width: 9em
+
+.dynamic-scope
+  .inputs
+    fieldset
+      position: relative
+      margin: 5px 0
+
+      a.fieldset-remove
+        display: inline-block
+        position: relative
+        vertical-align: middle
+        top: 4px
+        &:before
+          position: relative
+          top: 4px
+          margin-right: 3px
+          content: image-url('dynamic_scope/fieldset-remove.png')
+
+      .key, .operator, .value
+        display: inline-block
+        position: relative
+        box-sizing: border-box
+        vertical-align: top
+        margin: 0 6px 0 0
+
+      .key
+        width: 25%
+
+      .operator
+        width: 15%
+
+      .value
+        width: auto
+        max-width: 60%
+        min-width: 40%
+
+      div.value
+        width: 40%
+
+        > *
+          width: 100%
+
+        &.type-month
+          select.month, input.year
+            display: inline-block
+            width: calc(50% - 3px)
+            vertical-align: top
+          select.month
+            margin-right: 0
+          input.year
+            margin-right: 6px
+
+  .fieldset-add
+    text-decoration: none
+    span
+      text-decoration: underline
+
+  .clearquery
+    text-decoration: underline
+
+  // ui select styling fixes
+  .ui-select-match-item
+    padding-bottom: 3px
+    padding-top: 3px
+    margin-bottom: 1px
+
+  .ui-select-scope
+    height: 1.8em !important

data/config/locales/dynamic_scope.de.yml

@@ -0,0 +1,24 @@
+de:
+  dynamic_scope:
+    operator:
+      matches: enthält
+      does_not_match: stimmt nicht überein
+      eq: ist
+      not_eq: ist nicht
+      gteq: mindestens
+      lteq: höchstens
+      in: umfasst
+      not_in: enthält nicht
+      begins_with: beginnt mit
+      ends_with: endet mit
+      eq_since: seit
+      gteq_since: mindestens seit
+      lteq_since: höchstens seit
+    values:
+      yes: Ja
+      no: Nein
+    add_fieldset: Filter hinzufügen
+    add_criteria: Filter hinzufügen
+    remove_fieldset: entfernen
+    clear: Suche zurücksetzen
+    submit: Suche

data/config/locales/dynamic_scope.en.yml

@@ -0,0 +1,24 @@
+en:
+  dynamic_scope:
+    operator:
+      matches: matches
+      does_not_match: does not match
+      eq: is
+      not_eq: is not
+      gteq: at least
+      lteq: at most
+      in: includes
+      not_in: does not include
+      begins_with: begins with
+      ends_with: ends with
+      eq_since: since
+      gteq_since: at least since
+      lteq_since: at most since
+    values:
+      yes: Yes
+      no: No
+    add_fieldset: Add search criteria
+    add_criteria: Add search criteria
+    remove_fieldset: Remove
+    clear: Clear search
+    submit: Search

data/config/locales/dynamic_scope.fr.yml

@@ -0,0 +1,24 @@
+fr:
+  dynamic_scope:
+    operator:
+      matches: correspond
+      does_not_match: ne correspond pas
+      eq: est
+      not_eq: n'est pas
+      gteq: au moins
+      lteq: au maximum
+      in: comprend
+      not_in: ne comprend pas
+      begins_with: commence par
+      ends_with: se termine par
+      eq_since: depuis
+      gteq_since: depuis au moins
+      lteq_since: au maximum depuis
+    values:
+      yes: Oui
+      no: Non
+    add_fieldset: Ajouter filtre
+    add_criteria: Ajouter filtre
+    remove_fieldset: Supprimer
+    clear: Réinitialiser recherche
+    submit: Rechercher

data/config/locales/dynamic_scope.it.yml

@@ -0,0 +1,24 @@
+it:
+  dynamic_scope:
+    operator:
+      matches: fiammiferi
+      does_not_match: non corrisponde
+      eq: è
+      not_eq: non è
+      gteq: almeno
+      lteq: al massimo
+      in: include
+      not_in: non include
+      begins_with: inizia con
+      ends_with: finisce con
+      eq_since: da
+      gteq_since: almendo since
+      lteq_since: al massimo da
+    values:
+      yes: Sì
+      no: No
+    add_fieldset: Aggiungi criteri di ricerca
+    add_criteria: Aggiungi criteri di ricerca
+    remove_fieldset: Rimuovi
+    clear: Ricerca chiara
+    submit: Ricerca

data/dynamic_scope.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dynamic_scope/version"
+
+Gem::Specification.new do |s|
+  s.name        = "dynamic_scope"
+  s.version     = DynamicScope::Version::VERSION
+  s.authors     = ["Aleksandr Balakiriev"]
+  s.email       = ["balakirevs@i.ua"]
+  s.homepage    = ""
+  s.summary     = %q{Dynamic scope for rails}
+  s.description = %q{Helpers and angular module to make fancy dynamic scopes with arel.}
+
+  s.required_ruby_version = ">= 3.2.0"
+
+  s.files       = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  s.bindir       = "exe"
+  s.executables  = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency('sass-rails', '>= 6.0')
+  s.add_dependency('coffee-rails', '>= 5.0')
+  s.add_dependency('i18n-js', '~> 3.9.2')
+
+  s.add_development_dependency "rspec", "~> 3.13"
+  s.add_development_dependency "rails", ">= 8.0"
+end

data/lib/dynamic_scope/acts_as_dynamically_scopable.rb

@@ -0,0 +1,17 @@
+require 'dynamic_scope/class_methods'
+
+module DynamicScope
+  module ActsAsDynamicallyScopable
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def acts_as_dynamically_scopable(config)
+        class_eval do
+          include DynamicScope::ActiveRecord::Concern
+        end
+
+        self.dynamic_scope_config = config
+      end
+    end
+  end
+end

data/lib/dynamic_scope/class_methods.rb

@@ -0,0 +1,71 @@
+module DynamicScope
+  module ClassMethods
+    def dynamic_scope_is_empty?(params)
+      params.blank? || params.select{|key, value| value["value"].present? }.blank?
+    end
+
+    private
+      
+    def dynamic_scope_to_ransack(params)
+      return {} unless params
+      params = params.deep_dup
+      g = 1
+      q = {
+        'g' => {
+          '0' => {
+            'm' => 'and'
+          }
+        }
+      }
+      params.each_pair do |index, args|
+        if args['name'] == 'any_field'
+          q['g'][(g+=1).to_s] = {
+            'm' => 'or',
+            'c' => {}
+          }
+          self.dynamic_scope_columns.each_with_index do |col, i|
+            q['g'][g.to_s]['c'][i.to_s] = {}
+            c = q['g'][g.to_s]['c'][i.to_s]
+            if col.first == :string && col.last != :any_field
+              c['a'] = { '0' => { 'name' => col.last.to_s } }
+              c['v'] = { '0' => { 'value' => args['value'] } }
+            end
+            c['p'] = args['operator']
+          end
+        else
+          col = dyn_scope_column(args['name'])
+          if col and col[0] == :age and col[2].present?
+            args = age_to_date(args)
+            args['name'] = col[2].to_s
+          end
+          q['g']['0']['c'] ||= {}
+          size = q['g']['0']['c'].size
+          q['g']['0']['c'][size.to_s] = {}
+          c = q['g']['0']['c'][size.to_s]
+
+          c['a'] = { '0' => { 'name' => args['name'] } }
+          c['p'] = args['operator']
+          c['v'] = { '0' => { 'value' => args['value'] } }
+        end
+      end
+      q
+    end
+
+    def dyn_scope_column(name)
+      dynamic_scope_columns.select{|c| c[1] == name.to_sym}.first
+    end
+
+    def age_to_date(args)
+      args['operator'] =
+        case args['operator']
+        when 'gt' then 'lt'
+        when 'lt' then 'gt'
+        else args['operator']
+        end
+      if args['value'].match(/^[0-9]+$/)
+        args['value'] = (Date.today - args['value'].to_i.years).to_s
+      end
+      args
+    end
+  end
+end

data/lib/dynamic_scope/concerns/active_record.rb

@@ -0,0 +1,19 @@
+require 'active_support/concern'
+
+module DynamicScope::Concerns::ActiveRecord
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :dynamic_scope_config
+  end
+
+  module ClassMethods
+    def dynamic_scope(query, config = nil)
+      config ||= self.dynamic_scope_config
+      scope = DynamicScope::Processor.new(all, query, config).scope
+      all.joins(scope.joins_values).distinct
+         .includes(scope.includes_values)
+         .and(scope.distinct)
+    end
+  end
+end

data/lib/dynamic_scope/concerns.rb

@@ -0,0 +1,2 @@
+module DynamicScope::Concerns
+end

data/lib/dynamic_scope/engine.rb

@@ -0,0 +1,7 @@
+module DynamicScope
+  if defined?(::Rails::Engine)
+    class Engine < ::Rails::Engine #@private
+      isolate_namespace DynamicScope
+    end
+  end
+end

data/lib/dynamic_scope/processor.rb

@@ -0,0 +1,89 @@
+require 'dynamic_scope/query'
+
+# Processor for dynamic scope.
+#
+# usage:
+#
+# params = {
+#   '0' => {key: 'id', operator: 'eq', value: '1'},
+# }
+#
+# config = {
+#   id: {type: :integer}
+# }
+# processor = DynamicScope::Processor.new(Model.all, params, config)
+# Model.all.merge(processor.scope)
+#
+#
+# Config format:
+# {
+#   key: {
+#     # Required
+#     type: :integer || :string || :enum || :datetime,
+#
+#     # Required for type :enum
+#     values: ['value_1', 'value_2'],
+#
+#     # Optional: uses key OR given value to determine which scope to call
+#     # scope receives (operator, value) as arguments.
+#     scope: true || :some_scope_name,
+#
+#     # Opional: adds "OR :attribute IS NULL" to SQL statement
+#     # when operator is negative.
+#     null: true,
+#
+#     # Optional: uses given value if attribute_name differs from key
+#     attribute_name: :some_column,
+#
+#     # Optional: use when attribute resides in some other model,
+#     # uses rails relations to generate joins.
+#     # If given, the scope option affects this class.
+#     relation: :parent_model,
+#     relation: {parent_model: :granparent_model},
+#
+#     # Optional: use to modify value coming from params
+#     value: lambda{|value| "#{value}"}
+# }
+#
+# Params format:
+# {
+#   '0' => {
+#     # Required: hash key of config
+#     key: 'key',
+#
+#     # Required:
+#     # Supported operators are defined in DynamicScope::Query::OPERATORS
+#     operator: 'operator',
+#
+#     # Required:
+#     value: 'value'
+#
+#     # Opional: adds "OR :attribute IS NULL" to SQL statement
+#     null: true,
+#   }
+# }
+class DynamicScope::Processor
+  attr_reader :params, :config
+
+  def initialize(scope, params, config)
+    @scope = scope
+    @params = params
+    @config = config
+  end
+
+  def scope
+    @params.values.inject(@scope) do |memo, query|
+      if (query_scope = DynamicScope::Query.new(@scope, query, @config).scope)
+        if query_scope
+          memo = memo.joins(query_scope.joins_values) if query_scope.try(:joins_values).present?
+          memo = memo.includes(query_scope.includes_values) if query_scope.try(:includes_values).present?
+          memo.distinct.and(query_scope.distinct).distinct
+        else
+          memo.distinct
+        end
+      else
+        memo.distinct
+      end
+    end
+  end
+end

data/lib/dynamic_scope/query.rb

@@ -0,0 +1,205 @@
+require 'dynamic_scope/query_helpers'
+
+class DynamicScope::Query
+  include DynamicScope::QueryHelpers
+
+  class UnallowedOperator < ::Exception
+  end
+
+  class InvalidValue < ::Exception
+  end
+
+  class MissingRequiredKey < ::Exception
+  end
+
+  class UnsupportedType < ::Exception
+  end
+
+  REQUIRED_KEYS = [:key, :operator, :value].freeze
+
+  SUPPORTED_TYPES = [:integer, :string, :enum, :year, :month, :date, :date_future, :datetime, :boolean].freeze
+
+  OPERATORS = {
+    integer:     [:eq, :not_eq, :gteq, :lteq, :in, :not_in],
+    string:      [:matches, :does_not_match, :begins_with, :ends_with, :eq, :not_eq],
+    enum:        [:eq, :not_eq, :in, :not_in],
+    year:        [:eq, :gteq, :lteq],
+    month:       [:eq, :gteq, :lteq, :eq_since, :gteq_since, :lteq_since],
+    date:        [:eq, :gteq, :lteq],
+    date_future: [:eq, :gteq, :lteq],
+    datetime:    [:eq, :gteq, :lteq],
+    boolean:     [:eq, :not_eq]
+  }.freeze
+
+  NEGATIVE_OPERATORS = [:not_eq, :does_not_match, :not_in].freeze
+
+  attr_accessor :query, :config
+
+  def initialize(_scope, _query, _config)
+    @query = _query
+    @config = _config
+
+    check_query_for_missing_keys!
+
+    @scope = query_config[:relation].present? ? _scope.joins(query_config[:relation]) : _scope
+  end
+
+  def query_config
+    @config[query_key]
+  end
+
+  def arel_query
+    arel = scope_klass.arel_table[attribute_name]
+    aq = arel.send(operator_for_arel, value_for_arel)
+    if query_param_truthy?(@query[:null] || query_config[:null]) and NEGATIVE_OPERATORS.include?(operator)
+      aq = aq.or(arel.eq(nil))
+    end
+    aq
+  end
+
+  def scope
+    return nil if value.blank?
+    if custom_scope?
+      scope_klass.send(custom_scope_name, operator, value)
+    else
+      @scope.where(arel_query)
+    end
+  end
+
+  def operator
+    oper = @query[:operator].to_sym
+    if OPERATORS[type].include?(oper)
+      oper
+    else
+      raise UnallowedOperator.new(@query), "Query (#{@query}) has unallowed operator: #{oper}"
+    end
+  end
+
+  def attribute_name
+    (query_config[:attribute_name] || query_key).to_sym
+  end
+
+  def value
+    val = query_config[:value].is_a?(Proc) ? query_config[:value].call(@query[:value]) : @query[:value]
+    return nil if val.nil? || val.to_s.strip.length == 0
+    case type
+    when :string
+      val.to_s
+    when :integer
+      val.to_s.include?(',') ? val.split(',').map(&:to_i) : val.to_i
+    when :enum
+      val.split(',').each do |v|
+        unless allowed_values.include?(v)
+          raise InvalidValue.new(@query), "Query (#{@query}) has invalid value: #{v}"
+        end
+      end
+      val
+    when :year
+      val.to_s
+    when :month
+      val.to_s
+    when :date, :date_future
+      Date.parse(val.to_s)
+    when :datetime
+      DateTime.parse(val.to_s)
+    when :boolean
+      if ['1', 'true', true].include?(val)
+        true
+      elsif ['0', 'false', false].include?(val)
+        false
+      end
+    end
+  end
+
+  def value_for_arel
+    case type
+    when :string
+      if [:matches, :does_not_match].include?(operator)
+        "%#{value}%"
+      elsif [:begins_with].include?(operator)
+        "#{value}%"
+      elsif [:ends_with].include?(operator)
+        "%#{value}"
+      else
+        value
+      end
+    when :enum
+      if [:in, :not_in].include?(operator)
+        value.split(',')
+      else
+        value
+      end
+    else
+      value
+    end
+  end
+
+  def type
+    t = query_config[:type].to_sym
+    unless SUPPORTED_TYPES.include?(t)
+      raise UnsupportedType.new(query_config), "Config (#{query_config}) has unsupported type: #{t}"
+    end
+    t
+  end
+
+  def scope_klass
+    @scope_klass ||=
+      if query_config[:relation]
+        resolve_relation(@scope.klass, query_config[:relation])
+      else
+        @scope.klass
+      end
+  end
+
+  def operator_for_arel
+    {
+      begins_with: :matches,
+      ends_with: :matches
+    }[operator] || operator
+  end
+
+  private
+  def resolve_relation(klass, relation)
+    if relation.is_a?(Hash)
+      resolve_relation(klass.reflect_on_association(relation.first.first).klass, relation.first.last)
+    elsif relation.is_a?(Symbol)
+      klass.reflect_on_association(relation).klass
+    else
+      raise
+    end
+  end
+
+  def allowed_values
+    query_config[:values] || []
+  end
+
+  def check_query_for_missing_keys!
+    if missing_required_keys.length > 0
+      raise MissingRequiredKey.new(@query), "Query (#{@query}) has missing keys: #{missing_required_keys}"
+    end
+  end
+
+  def missing_required_keys
+    (REQUIRED_KEYS - @query.keys.map(&:to_sym))
+  end
+
+  def query_key
+    @query[:key].to_sym
+  end
+
+  def custom_scope?
+    query_config[:scope].present?
+  end
+
+  def custom_scope_name
+    if query_config[:scope].is_a?(Symbol) || query_config[:scope].is_a?(String)
+      query_config[:scope]
+    else
+      query_key
+    end
+  end
+
+  def use_outer_join?
+    NEGATIVE_OPERATORS.include?(operator)
+  end
+end

data/lib/dynamic_scope/query_helpers.rb

@@ -0,0 +1,11 @@
+module DynamicScope::QueryHelpers
+  TRUTHY_VALUES = ['1', 'true', true]
+
+  def query_param_truthy?(value)
+    TRUTHY_VALUES.include?(value)
+  end
+
+  def query_param_falsy?(value)
+    !query_param_truthy?(value)
+  end
+end

data/lib/dynamic_scope/version.rb

@@ -0,0 +1,5 @@
+module DynamicScope
+  module Version
+    VERSION = '0.5.4'
+  end
+end