validates_overlap 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4cb1a64ca3a5f173591cc6e6ee54268711a12dc49da4e8e5041aedd94f40e81
-  data.tar.gz: ad351e1f69f9c6f05dc9a38b6d23530672bc986fb19d48e890ba4a94e14ee9ba
+  metadata.gz: 22d9351114cf974a1843daead1ff7fb57503951d2cfecd9bfe19c2041bd4dd01
+  data.tar.gz: 95e4e59f48f05f22ad589a06e77224fd1d065414ddb22a0d68f17e23005c0168
 SHA512:
-  metadata.gz: 0da45c30fd0a89545921403ed0956891c3828a42494130369bc9ffba80a36070beeead19caac80c9ef0ce21773cd355f73dbab9fc8750f2ab19df0d28acb5d0a
-  data.tar.gz: 4c3d245beba5c257f8682d2ff23dcc491caede32a68237a12838965da94101e520bd975ab761ef86d66cf44e9ac8065381612f756b2d3a93d76db3d2f87d279d
+  metadata.gz: 8483ac32c24e082f364de7e090dd01b6d14183657bbf6e002770b1d256904eed24e56fcf19707bfa586d79ca9be24b1b7e5e5f9d09de9f2f18d404cc0dec840b
+  data.tar.gz: 4b2d9a55f399584ba014ca1633bfa4e278ad42a89db9ff5db4828da9c71d1bba731ceb9394ee5cb9903f2ffa51c76f542efea40037a4e99e7ed6bcea2498f73d

data/CHANGELOG.md

@@ -0,0 +1,53 @@
+# ValidatesOverlap 1.x Change Log
+
+## 1.2.0 (2026-08-11)
+
+RSpec tests: **85 → 126** (+41 tests)
+
+### Bug Fixes
+
+  - 🎉 the validator is now stateless and thread-safe 🎉 — fixes [Issue #50](https://github.com/tilo/validates_overlap/issues/50): concurrent validations of the same model class could corrupt each other's query, because Rails shares one validator instance per class and the query lived on it as instance state (intermittent `ActiveRecord::PreparedStatementInvalid`, or silently wrong validation results). Thanks to [Jorge Santos](https://github.com/jsantos) for the report
+  - string range columns raised `TypeError` because a default shift of `0` was added even when no shift was configured — shifts are now only applied when set
+  - open-ended (nil) endpoints produced wrong results in several cases: an endless range failed to conflict with records after January 2038 (the nil endpoint was substituted with a Unix-time sentinel), and open-ended integer or string ranges could silently never conflict at all. A nil endpoint now simply drops its comparison from the query — type-independent and exact
+  - the record's primary key is now passed to the database as a bind value when a persisted record is excluded from the comparison — it was interpolated into the SQL, which broke string keys containing a quote
+
+### Improvements
+
+  - documented in the README that `start_shift` / `end_shift` work in both directions: widening the range enforces a minimum gap, shrinking it tolerates a specified amount of overlap — now locked in by specs
+  - the overlap check works on any linearly orderable column type — now covered by specs for date, datetime, timestamp, integer, decimal, and string range columns (including open-ended ranges and integer gap/tolerance shifts) and documented in the README ("non-date ranges")
+  - `:time` range columns now raise `OverlapValidator::UnsupportedColumnType` — time-of-day is a cyclic domain, where a wraparound window is indistinguishable from accidentally swapped fields; the validator refuses loudly instead of answering wrong (see the README note for cyclic domains)
+  - test coverage: real UUID/string primary key test restored (lost in a 2019 refactor), new tests for `:scoped_model`, literal scope values, and the two-attributes requirement; the long-disabled endless-objects test was fixed and re-enabled — the suite has no pending tests
+
+### Internal
+
+  - removed the accessors `sql_conditions`, `sql_values`, and `scoped_model` from `OverlapValidator` — they were the shared state causing thread-safety issues; the query-building methods now take and return their inputs
+  - removed the constants `OverlapValidator::BEGIN_OF_UNIX_TIME` and `END_OF_UNIX_TIME` — the sentinel substitution is gone; an open-ended boundary simply contributes no comparison to the query
+
+## 1.1.0 (2026-08-07)
+
+RSpec tests: **81 → 85** (+4 tests)
+
+First release under new maintainership — [Tilo Sloboda](https://github.com/tilo) took over maintenance from [Robin Bortlik](https://github.com/robinbortlik) in August 2026. Thank you, Robin, for creating this gem and maintaining it for many years! ❤️
+
+### Bug Fixes
+
+  - fixed [Issue #54](https://github.com/tilo/validates_overlap/issues/54): a scope naming an enum attribute as a symbol (e.g. `scope: [:kind]`) crashed with `NoMethodError`. Thanks to [Nujian Den Mark Meralpis](https://github.com/denmarkmeralpis) ([PR #55](https://github.com/tilo/validates_overlap/pull/55)); covered by a new regression test
+
+### Improvements
+
+  - verified support for Rails 6.1, 7.0, 7.1, 7.2, 8.0, and 8.1 on Ruby 3.0–3.4 — an 18-cell GitHub Actions matrix now runs on every push (the first working CI since 2019)
+  - the gem now depends on `activerecord` instead of the full `rails` meta-gem, so it no longer pulls actionpack etc. into your bundle (version floor unchanged: `>= 6.0`)
+  - the gem package now ships only `lib/`, README, and license — previously the entire test app was packaged into the gem
+  - test suite modernized: migrated from the long-dead `factory_girl` to `factory_bot`, runs on current Ruby/Rails, SimpleCov added with 100% line coverage, new tests for nil scope values (`IS NULL` matching) and symbol enum scopes
+  - the gem version now lives in `ValidatesOverlap::VERSION` (`lib/validates_overlap/version.rb`); the `VERSION` file is gone
+  - README: badges, Ruby/Rails compatibility matrix, clearer description of what the gem does
+
+## 1.0.0 (2019-11-17)
+
+  - Rails 6 support; support for Rails 3, 4, and 5 dropped — use version 0.8.6 for those. Thanks to [Robin Bortlik](https://github.com/robinbortlik)
+  - avoid implicit `scoped_model.all` delegation in the validation ([PR #52](https://github.com/tilo/validates_overlap/pull/52)). Thanks to [Ryuta Kamizono](https://github.com/kamipo)
+  - Russian validation error message ([PR #47](https://github.com/tilo/validates_overlap/pull/47)). Thanks to [Alexander Gornov](https://github.com/Zmokizmoghi)
+
+## 0.8.6 (2017-11-20) and earlier
+
+  - releases from 2011 through 2017 by [Robin Bortlik](https://github.com/robinbortlik) and contributors were not tracked in a changelog; see the git history and [CONTRIBUTORS.md](CONTRIBUTORS.md)

data/CONTRIBUTORS.md

@@ -0,0 +1,26 @@
+# A Big Thank You to all 21 Contributors!!
+
+`validates_overlap` was created in 2011 by [Robin Bortlik](https://github.com/robinbortlik), who designed it and maintained it, reviewing and merging every pull request below along the way. Thank you, Robin, for this gem and all the work you put into it! ❤️
+
+A Big Thank you to everyone who filed issues, sent comments, and who contributed with pull requests:
+
+ * [Kyle Bolton](https://github.com/kb)
+ * [Jon Pascoe](https://github.com/pacso)
+ * [Mark Campbell](https://github.com/Nitrodist)
+ * [Thibaut Courouble](https://github.com/Thibaut)
+ * [Tawan Sierek](https://github.com/tawan)
+ * [Martin Lagrange](https://github.com/supertinou)
+ * [Geoff Harcourt](https://github.com/geoffharcourt)
+ * [Brenton 'B-Train' Fletcher](https://github.com/bloopletech)
+ * [Victor Hugo Bueno](https://github.com/victorbueno)
+ * [rmathew1992](https://github.com/rmathew1992)
+ * [Mikhail Dieterle](https://github.com/mikdiet)
+ * [Roberto Romero](https://github.com/sildur)
+ * [Patrick Smith](https://github.com/royalicing)
+ * [Rafał Trojanowski](https://github.com/rafaltrojanowski)
+ * [Szymon Rut](https://github.com/RutSzymon)
+ * [Alexander Gornov](https://github.com/Zmokizmoghi)
+ * [Ryuta Kamizono](https://github.com/kamipo)
+ * [Nujian Den Mark Meralpis](https://github.com/denmarkmeralpis)
+ * [ohenrik](https://github.com/ohenrik)
+ * [Jorge Santos](https://github.com/jsantos)

data/MIT-LICENSE

@@ -1,4 +1,5 @@
-Copyright 2011 YOURNAME
+Copyright 2011 Robin Bortlik
+Copyright 2026 Tilo Sloboda
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,15 +1,58 @@
-[![Build Status](https://secure.travis-ci.org/robinbortlik/validates_overlap.png?branch=master)](https://secure.travis-ci.org/robinbortlik/validates_overlap)
-
 # ValidatesOverlap
 
-This project rocks and uses MIT-LICENSE.
+![Gem Version](https://img.shields.io/gem/v/validates_overlap) [![RSpec](https://github.com/tilo/validates_overlap/actions/workflows/ruby.yml/badge.svg)](https://github.com/tilo/validates_overlap/actions/workflows/ruby.yml) [![codecov](https://codecov.io/gh/tilo/validates_overlap/branch/main/graph/badge.svg)](https://app.codecov.io/gh/tilo/validates_overlap/tree/main) [![Downloads](https://img.shields.io/gem/dt/validates_overlap)](https://rubygems.org/gems/validates_overlap) [![RubyGems](https://img.shields.io/badge/RubyGems-validates__overlap-brightgreen?logo=rubygems&logoColor=white)](https://rubygems.org/gems/validates_overlap) [![Ruby Toolbox](https://img.shields.io/badge/Ruby%20Toolbox-validates__overlap-brightgreen)](https://www.ruby-toolbox.com/projects/validates_overlap)
+
+`validates_overlap` provides an ActiveRecord validator for resources that must not overlap, e.g. in datetime. Think rentals, meetings, bookings, work shifts, or assignments where the same resource cannot be assigned to multiple people or entities during overlapping time periods. But it also works for other domains than datetime (see below).
+
+You specify two attributes defining a datetime range, such as `starts_at` and `ends_at`, and the validator checks with a single SQL query whether another record overlaps that range — no records are loaded for the comparison. If one does, the record receives a normal validation error.
+
+It also supports scoped validation (per user, room, resource, etc.), open-ended ranges (a nil start or end counts as extending forever), ranges that may touch at their boundaries (`exclude_edges`), required gaps between ranges or a tolerated amount of overlap (`start_shift` / `end_shift`), associations, and retrieving the conflicting records.
+
+The range columns don't have to be dates or times: any linearly orderable column type works, such as integer ranges (ticket number blocks), decimal ranges (price bands), or string ranges (alphabetical partitions).
+
+## Note: Other Domains
+
+Other domains / types can be checked for overlap, as long as they can be compared linearly.
+e.g. The overlap check runs on plain SQL comparisons, so any linearly orderable column type works — for example integer ranges (no two records may claim overlapping number blocks), decimal ranges (price bands), or string ranges (alphabetical partitions). A nil endpoint means the range is open-ended on that side, for these types too, and the shifts work for numeric ranges as well (e.g. an integer gap or overlap tolerance). The test suite covers `date`, `datetime`, `timestamp`, `integer`, `decimal`, and `string` range columns.
+
+## ⚠️ Note: Cyclic Domains can NOT be validated for overlap
+
+Overlap validation requires a linear domain: every range must satisfy `start <= end`. On a cyclic (wrap-around) domain, like time, every pair of values denotes *some* valid range (`11:00..10:00` is simply the 23-hour complement of `10:00..11:00`), so a wraparound range is indistinguishable from accidentally swapped fields — no validation can tell intent from typo. This is a mathematical property of circular domains, not an implementation gap.
+
+The validator therefore refuses `:time` range columns and raises `OverlapValidator::UnsupportedColumnType` — use datetime columns instead, or split windows that cross midnight into two records.
+
+But cyclicity is a property of the domain, not the column type — ⚠️ user-encoded cyclic domains hide inside perfectly linear columns, where no guard can see them:
+
+- day-of-week as integer (0..6): a Friday-to-Monday shift range `5..1` wraps — same pathology as `22:00..02:00`, stored in an innocent `:integer` column
+- month numbers (1..12): a November-to-February season range `11..2`
+- ISO week numbers: a range from week 52 to week 2 across New Year
+- angles / compass headings (0..360): a heading sector `350..10`
+- longitude (−180°..+180°)
+- hour-of-day as integer — people re-implement `:time` in an int column all the time
+- time-of-day (24-hour clock values without a date component)
+
+If your domain is cyclic, the validator will silently give wrong answers for wrapping ranges. Restructure the data instead: split wrapping ranges into two linear records, or lift the values into a linear domain (e.g. datetime instead of time-of-day).
+
+To catch inverted ranges loudly instead of silently (for any column type), pair the overlap validation with an order check on your model, e.g. `validates :ends_at, comparison: { greater_than: :starts_at }`.
+
+## Ruby / Rails Compatibility
+
+Every combination below is verified on every push by the [CI matrix](https://github.com/tilo/validates_overlap/actions):
 
-#### This gem is compatible with Rails 6. If you are looking for version compatible with Rails 3,4,5 please use version 0.8.6 .
+| Rails | Tested with Ruby   |
+|-------|--------------------|
+| 8.1   | 3.2, 3.3, 3.4      |
+| 8.0   | 3.2, 3.3, 3.4      |
+| 7.2   | 3.1, 3.2, 3.3, 3.4 |
+| 7.1   | 3.0, 3.1, 3.2, 3.3 |
+| 7.0   | 3.0, 3.1, 3.2      |
+| 6.1   | 3.0                |
 
-#### When this gem should be helpful for you?
-Ideal solution for booking applications where you want to make sure, that one place can be booked only once in specific time period.
+The gemspec requires `activerecord >= 6.0`. Rails 6.0 is not part of the test matrix, but no incompatibilities are known. The previous version 0.8.6 was compatible with Rails 3, 4, and 5.
 
-#### Using
+Note for MySQL users: use `DATETIME` (not `TIMESTAMP`) columns for your range attributes — MySQL's `TIMESTAMP` type cannot store dates after January 2038, which matters for long-running or far-future ranges. PostgreSQL and SQLite date/time types have no such limit.
+
+## Usage
 
 Add to your gemfile
 
@@ -40,8 +83,29 @@ validates :starts_at, :ends_at, :overlap => {:exclude_edges => ["starts_at", "en
 
 #### shift edges
 
+The shifts move the record's own range edges before the overlap check, so you can require a gap between records — or tolerate a bounded overlap:
+
 ```ruby
+# widen the range: records must be at least 1 day apart (gap enforced)
 validates :starts_at, :ends_at, :overlap => {:start_shift => -1.day, :end_shift => 1.day}
+
+# shrink the range: up to 2 days of overlap are accepted
+validates :starts_at, :ends_at, :overlap => {:start_shift => 2.days, :end_shift => -2.days}
+```
+
+#### non-date ranges
+
+The overlap check runs on plain SQL comparisons, so any orderable column type works — for example integer ranges (no two records may claim overlapping number blocks), decimal ranges (price bands), or string ranges (alphabetical partitions). A nil endpoint means the range is open-ended on that side, for these types too, and the shifts work for numeric ranges as well (e.g. an integer gap or overlap tolerance). The test suite covers `date`, `datetime`, `timestamp`, `integer`, `decimal`, and `string` range columns.
+
+```ruby
+class TicketBlock < ActiveRecord::Base
+  validates :number_start, :number_end, :overlap => true
+end
+
+TicketBlock.create!(number_start: 100, number_end: 199)
+TicketBlock.new(number_start: 150, number_end: 250).valid?  # => false (overlaps)
+TicketBlock.new(number_start: 150, number_end: nil).valid?  # => false (open-ended, overlaps)
+TicketBlock.new(number_start: 200, number_end: 299).valid?  # => true
 ```
 
 #### define custom validation key(s) and message
@@ -53,7 +117,7 @@ validates :starts_at, :ends_at, :overlap => {:message_title => [:start_at, :end_
 
 #### with complicated relations
 
-Example describes valildatation of user, positions and time slots.
+Example describes validation of user, positions and time slots.
 User can't be assigned 2 times on position which is under time slot with time overlap.
 
 ```ruby
@@ -90,3 +154,12 @@ class ActiveMeeting < ActiveRecord::Base
 end
 
 ```
+
+## Maintainership
+
+`validates_overlap` was created by [Robin Bortlik](https://github.com/robinbortlik), who built and maintained it starting 2011.
+Since August 2026 the gem is maintained by [Tilo Sloboda](https://github.com/tilo).
+
+A big thank you to Robin for creating this awesome gem and for the years of work he put into it. ❤️
+
+

data/lib/validates_overlap/overlap_validator.rb

@@ -3,12 +3,9 @@ require 'active_support/i18n'
 I18n.load_path << File.dirname(__FILE__) + '/locale/en.yml'
 
 class OverlapValidator < ActiveModel::EachValidator
-  BEGIN_OF_UNIX_TIME = Time.at(-2_147_483_648).to_datetime
-  END_OF_UNIX_TIME = Time.at(2_147_483_648).to_datetime
-
-  attr_accessor :sql_conditions
-  attr_accessor :sql_values
-  attr_accessor :scoped_model
+  # Raised when a range attribute uses a column type the validator cannot
+  # operate on (e.g. :time — a cyclic domain, see README)
+  class UnsupportedColumnType < ArgumentError; end
 
   def initialize(args)
     attributes_are_range(args[:attributes])
@@ -16,11 +13,15 @@ class OverlapValidator < ActiveModel::EachValidator
     super
   end
 
+  # NOTE: Rails registers ONE validator instance per model class, shared by every
+  # validation of that class (including concurrent ones) — so the query being
+  # built must never be stored on the validator itself (issue #50)
   def validate(record)
-    initialize_query(record, options)
-    if overlapped_exists?
+    reject_unsupported_column_types(record)
+    relation, sql_conditions, sql_values = initialize_query(record, options)
+    if overlapped_exists?(relation, sql_conditions, sql_values)
       if options[:load_overlapped]
-        record.instance_variable_set(:@overlapped_records, get_overlapped)
+        record.instance_variable_set(:@overlapped_records, get_overlapped(relation, sql_conditions, sql_values))
       end
 
       if record.respond_to? attributes.first
@@ -39,22 +40,41 @@ class OverlapValidator < ActiveModel::EachValidator
 
   protected
 
+  # Time-of-day is a cyclic domain: every pair of values denotes some valid
+  # range there, so wraparound intent is indistinguishable from accidentally
+  # swapped fields — refuse loudly instead of answering wrong (see README).
+  # Checked at validate time, not at class-definition time, because column
+  # metadata must not be touched while migrations may still be pending.
+  def reject_unsupported_column_types(record)
+    return unless record.class.respond_to?(:columns_hash)
+    attributes.each do |attr|
+      next if attr.to_s.include?('.')
+      column = record.class.columns_hash[attr.to_s]
+      next unless column && column.type == :time
+      raise UnsupportedColumnType, "#{record.class.name}##{attr} is a :time column; time-of-day is a cyclic domain and cannot be validated for overlap — use datetime columns, or split ranges that cross midnight (see README)"
+    end
+  end
+
+  # Build the complete overlap query for this record.
+  # return array in form [relation, sql_conditions, sql_values]
   def initialize_query(record, options = {})
     scoped_model = options[:scoped_model].present? ? options[:scoped_model].constantize : record.class
-    self.scoped_model = scoped_model.default_scoped
-    generate_overlap_sql_values(record)
-    generate_overlap_sql_conditions(record)
-    add_attributes(record, options[:scope]) if options && options[:scope].present?
-    add_query_options(options[:query_options]) if options && options[:query_options].present?
+    relation = scoped_model.default_scoped
+    sql_values = generate_overlap_sql_values(record)
+    sql_conditions, primary_key_values = generate_overlap_sql_conditions(record, sql_values)
+    sql_values = sql_values.merge(primary_key_values)
+    sql_conditions, sql_values = add_attributes(record, options[:scope], sql_conditions, sql_values) if options && options[:scope].present?
+    relation = add_query_options(relation, options[:query_options]) if options && options[:query_options].present?
+    [relation, sql_conditions, sql_values]
   end
 
   # Check if exists at least one record in DB which is overlapped with current record
-  def overlapped_exists?
-    scoped_model.exists?([sql_conditions, sql_values])
+  def overlapped_exists?(relation, sql_conditions, sql_values)
+    relation.exists?([sql_conditions, sql_values])
   end
 
-  def get_overlapped
-    scoped_model.where([sql_conditions, sql_values])
+  def get_overlapped(relation, sql_conditions, sql_values)
+    relation.where([sql_conditions, sql_values])
   end
 
   # Resolve attributes values from record to use in sql conditions
@@ -108,55 +128,70 @@ class OverlapValidator < ActiveModel::EachValidator
     record.send(primary_key_name)
   end
 
-  # Generate sql condition for time range cross
-  def generate_overlap_sql_conditions(record)
+  # Generate sql condition for time range cross; a persisted record is excluded
+  # from the comparison by its primary key, passed as a bind value
+  # return array in form [sql_conditions, sql_values]
+  def generate_overlap_sql_conditions(record, sql_values)
     starts_at_attr, ends_at_attr = attributes_to_sql(record)
-    main_condition = condition_string(starts_at_attr, ends_at_attr)
-    primary_key_name = primary_key(record)
-    key = primary_key_value(primary_key_name, record)
+    main_condition = condition_string(starts_at_attr, ends_at_attr, sql_values)
     if record.new_record?
-      self.sql_conditions = main_condition
+      [main_condition, {}]
     else
-      self.sql_conditions = "#{main_condition} AND #{record_table_name(record)}.#{primary_key(record)} !="
-      self.sql_conditions +=   key.is_a?(String) ? "'#{key}'" : key.to_s
+      key = primary_key_value(primary_key(record), record)
+      ["#{main_condition} AND #{record_table_name(record)}.#{primary_key(record)} != :record_primary_key_value", { record_primary_key_value: key }]
     end
   end
 
-  # Return hash of values for overlap sql condition
+  # Return hash of values for overlap sql condition; a nil endpoint means the
+  # record's range is open-ended on that side — no value is emitted for it and
+  # condition_string drops the corresponding comparison
+  # NOTE: shifts are only applied when configured — unconditionally adding a
+  # default of 0 would raise a TypeError for non-numeric types such as String
   def generate_overlap_sql_values(record)
     starts_at_value, ends_at_value = resolve_values_from_attributes(record)
-    starts_at_value += options.fetch(:start_shift) { 0 } if starts_at_value && options
-    ends_at_value += options.fetch(:end_shift) { 0 } if ends_at_value && options
-    self.sql_values = { starts_at_value: starts_at_value || BEGIN_OF_UNIX_TIME, ends_at_value: ends_at_value || END_OF_UNIX_TIME }
+    start_shift = options && options[:start_shift]
+    end_shift = options && options[:end_shift]
+    starts_at_value += start_shift if starts_at_value && start_shift
+    ends_at_value += end_shift if ends_at_value && end_shift
+    sql_values = {}
+    sql_values[:starts_at_value] = starts_at_value if starts_at_value
+    sql_values[:ends_at_value] = ends_at_value if ends_at_value
+    sql_values
   end
 
   # Return the condition string depend on exclude_edges option.
-  def condition_string(starts_at_attr, ends_at_attr)
+  # A comparison is only emitted for endpoints the record actually has: an
+  # open-ended side matches every other record by definition, so its clause is
+  # dropped (a record with both endpoints nil overlaps everything)
+  def condition_string(starts_at_attr, ends_at_attr, sql_values)
     except_option = Array(options[:exclude_edges]).map(&:to_s)
     starts_at_sign = except_option.include?(starts_at_attr.to_s.split('.').last) ? '<' : '<='
     ends_at_sign = except_option.include?(ends_at_attr.to_s.split('.').last) ? '>' : '>='
     query = []
-    query << "(#{ends_at_attr} IS NULL OR #{ends_at_attr} #{ends_at_sign} :starts_at_value)"
-    query << "(#{starts_at_attr} IS NULL OR #{starts_at_attr} #{starts_at_sign} :ends_at_value)"
-    query.join(' AND ')
+    query << "(#{ends_at_attr} IS NULL OR #{ends_at_attr} #{ends_at_sign} :starts_at_value)" if sql_values.key?(:starts_at_value)
+    query << "(#{starts_at_attr} IS NULL OR #{starts_at_attr} #{starts_at_sign} :ends_at_value)" if sql_values.key?(:ends_at_value)
+    query.empty? ? '1 = 1' : query.join(' AND ')
   end
 
   # Add attributes and values to sql conditions.
   # helps to use with scope options, so scope can be added as this forms :scope => "user_id" or :scope => ["user_id", "place_id"]
-  def add_attributes(record, attrs)
+  # return array in form [sql_conditions, sql_values]
+  def add_attributes(record, attrs, sql_conditions, sql_values)
     if attrs.is_a?(Array)
-      attrs.each { |attr| add_attribute(record, attr) }
+      attrs.each { |attr| sql_conditions, sql_values = add_attribute(record, attr, sql_conditions, sql_values) }
     elsif attrs.is_a?(Hash)
       attrs.each do |attr_name, value|
-        add_attribute(record, attr_name, value)
+        sql_conditions, sql_values = add_attribute(record, attr_name, sql_conditions, sql_values, value)
       end
     else
-      add_attribute(record, attrs)
+      sql_conditions, sql_values = add_attribute(record, attrs, sql_conditions, sql_values)
     end
+    [sql_conditions, sql_values]
   end
 
   # Add attribute and his value to sql condition
-  def add_attribute(record, attr_name, value = nil)
+  # return array in form [sql_conditions, sql_values]
+  def add_attribute(record, attr_name, sql_conditions, sql_values, value = nil)
     _value = resolve_attribute_value(record, attr_name, value)
     operator = if _value.nil?
                  ' IS NULL'
@@ -166,8 +201,9 @@ class OverlapValidator < ActiveModel::EachValidator
                  ' = :%s'
     end
 
-    self.sql_conditions += " AND #{attribute_to_sql(attr_name, record)} #{operator}" % value_attribute_name(attr_name)
-    sql_values.merge!(:"#{value_attribute_name(attr_name)}" => _value)
+    sql_conditions += " AND #{attribute_to_sql(attr_name, record)} #{operator}" % value_attribute_name(attr_name)
+    sql_values = sql_values.merge(:"#{value_attribute_name(attr_name)}" => _value)
+    [sql_conditions, sql_values]
   end
 
   def value_attribute_name(attr_name)
@@ -182,7 +218,7 @@ class OverlapValidator < ActiveModel::EachValidator
       value = record.read_attribute(attr_name)
 
       if is_enum_attribute?(record, attr_name)
-        value = record.class.defined_enums[attr_name][value]
+        value = record.class.defined_enums[attr_name.to_s][value]
       end
 
       value
@@ -200,9 +236,11 @@ class OverlapValidator < ActiveModel::EachValidator
   # Allow to use scope, joins, includes methods before querying
   # == Example:
   # validates_overlap :date_from, :date_to, :query_options => {:includes => "visits"}
-  def add_query_options(methods)
+  # return the relation with the query options applied
+  def add_query_options(relation, methods)
     methods.each do |method_name, params|
-      self.scoped_model = scoped_model.send(method_name.to_sym, *params)
+      relation = relation.send(method_name.to_sym, *params)
     end
+    relation
   end
 end

data/lib/validates_overlap/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ValidatesOverlap
+  VERSION = '1.2.0'
+end

data/lib/validates_overlap.rb

@@ -1 +1,2 @@
-require File.join(File.dirname(__FILE__), 'validates_overlap', 'overlap_validator')
+require_relative 'validates_overlap/version'
+require_relative 'validates_overlap/overlap_validator'