activerecord-multirange 1.0.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1774e8210820d1f732ce43c7032035cfe5498e415b45837b2ddb31688ca31b3a
-  data.tar.gz: 13990bece50e4ec7f3ddf537b1cfbeeca4663ac50c02aaee99a95dd3d91157e8
+  metadata.gz: 0b09cdb0717d19e40572d66ecb2e7774494057658fb3409fefdf04a67db06345
+  data.tar.gz: aa643ce5bf82da7e69b042478ee884668fd1970da0861b91e43e7a5c2e4ae3e4
 SHA512:
-  metadata.gz: 1e898a098a890acefee7b29bb59ffa545ea1f3356fb6de5ff18f6bfde0f817562c7142bd7210388125a672ca875a3ce3055cf1c71b3d0bca4acf2e915893e1bb
-  data.tar.gz: d064d47c5e57c505a0cf8f61adf09a3fbfc7f468d4c1a982bb24e7d067bae0a74cf50e4a31abf7df7e3809cd1ff8b0351fbfa374722585a1089159eb2a829f7c
+  metadata.gz: 31209bbe807b481f93275650fae69c2c23fa76518fc987890daec2c619f595571467cb55fdd8cc526e8bc4e007af68eb9f239e68d810854dc3e6977c4631d248
+  data.tar.gz: 87c60c9246d43e7b148c02798171df9747b7aa2fb5c21b40969ed77b8461064440d4f9f73840f2b5d8aa11cd47d33017d48fbfb9a9c9ad28da7ce952e713fa26

data/.rubocop.yml

@@ -1,22 +1,56 @@
 AllCops:
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 3.1.2
+  EnabledByDefault: true
+  Exclude:
+    - 'db/**/*'
+    - 'config/**/*'
+    - 'script/**/*'
+    - 'bin/{rails,rake}'
 
-Style/StringLiterals:
+require:
+  - rubocop-rails
+
+inherit_from:
+  - node_modules/@prettier/plugin-ruby/rubocop.yml
+
+Style:
+  Enabled: false
+
+Metrics:
+  Enabled: false
+
+Lint:
   Enabled: true
-  EnforcedStyle: double_quotes
 
-Style/StringLiteralsInInterpolation:
+Lint/ConstantResolution:
+  Enabled: false
+
+Lint/AssignmentInCondition:
+  Enabled: false
+
+Lint/NumberConversion:
+  Enabled: false
+
+Rails:
   Enabled: true
-  EnforcedStyle: double_quotes
 
-Style/Documentation:
+Rails/SkipsModelValidations:
   Enabled: false
 
-Naming/FileName:
+Rails/DefaultScope:
   Enabled: false
 
-Metrics/BlockLength:
+Rails/HasManyOrHasOneDependent:
   Enabled: false
 
-Layout/LineLength:
-  Max: 120
+Rails/InverseOf:
+  Enabled: false
+
+Rails/Date:
+  Enabled: false
+
+Rails/TimeZone:
+  Enabled: false
+
+Rails/RequestReferer:
+  Enabled: false

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [Unreleased]
 
-## [0.1.0] - 2023-05-29
+## [1.1.1] - 2025-06-11
+
+- Added automatic registration of multirange types in `NATIVE_DATABASE_TYPES` for Rails 8 compatibility
+- Fixed `rails db:schema:dump` support without requiring manual type registration
+- Centralized multirange type definitions in `MULTIRANGE_TYPES` constant
+
+## [1.1.0] - 2024-06-01
+
+- Minor version bump with improvements and updates
+
+## [1.0.0] - 2023-05-29
 
 - Initial release

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    activerecord-multirange (1.0.0)
+    activerecord-multirange (1.1.1)
       pg (>= 1)
       rails (>= 6)
 
@@ -116,6 +116,8 @@ GEM
     net-smtp (0.3.3)
       net-protocol
     nio4r (2.5.9)
+    nokogiri (1.15.4-arm64-darwin)
+      racc (~> 1.4)
     nokogiri (1.15.4-x86_64-darwin)
       racc (~> 1.4)
     nokogiri (1.15.4-x86_64-linux)
@@ -200,6 +202,7 @@ GEM
     zeitwerk (2.6.11)
 
 PLATFORMS
+  arm64-darwin-23
   x86_64-darwin-22
   x86_64-linux
 

data/README.md

@@ -1,5 +1,5 @@
-# Activercord Multirange 
- 
+# Activercord Multirange
+
 This gem adds full suppport of [Postgress Multiranges](https://www.postgresql.org/docs/14/rangetypes.html#RANGETYPES-BUILTIN) types.
 
 [![Gem Version](https://badge.fury.io/rb/activerecord-multirange.svg)](https://badge.fury.io/rb/activerecord-multirange)
@@ -12,30 +12,233 @@ Install the gem and add to the application's Gemfile by executing:
 
 If bundler is not being used to manage dependencies, install the gem by executing:
 
-    $ gem install activerecord-multirange 
+    $ gem install activerecord-multirange
 
 ## Usage
 
 ### Initialize it
 
-```
-# config/initializers/activerecord_multirange
+```ruby
+# config/initializers/activerecord_multirange.rb
 
 Activerecord::Multirange.add_multirange_column_type
 ```
 
 ### Migrations
 
-All multirange types are available on the migrations
+All multirange types are available in migrations. Here are examples for different multirange types:
+
+```ruby
+class CreateSchedules < ActiveRecord::Migration[7.0]
+  def change
+    create_table :schedules do |t|
+      t.string :name
+      t.tsmultirange :available_times # Timestamp multirange
+      t.tstzmultirange :available_times_tz # Timestamp with timezone multirange
+      t.datemultirange :available_dates # Date multirange
+      t.nummultirange :price_ranges # Numeric multirange
+      t.int8multirange :id_ranges # Bigint multirange
+      t.int4multirange :quantity_ranges # Integer multirange
+
+      t.timestamps
+    end
+  end
+end
+```
+
+```ruby
+class CreateBookings < ActiveRecord::Migration[7.0]
+  def change
+    create_table :bookings do |t|
+      t.string :title
+      t.tstzmultirange :booked_periods
+      t.datemultirange :blackout_dates
+
+      t.timestamps
+    end
+  end
+end
+```
+
+### Models
+
+Define your models to work with multirange columns:
+
+```ruby
+class Schedule < ApplicationRecord
+  # Multirange columns are automatically handled by ActiveRecord
+  # No special configuration needed
+end
+
+class Booking < ApplicationRecord
+  validates :title, presence: true
+
+  scope :overlapping_with, ->(time_range) { where('booked_periods && ?', time_range) }
+end
+```
+
+### Creating and Working with Multirange Data
+
+#### Creating Records with Multirange Values
+
+```ruby
+# Using timestamp multiranges for scheduling
+schedule =
+  Schedule.create!(
+    name: 'Conference Room A',
+    available_times: [
+      Time.parse('2024-01-15 09:00')..Time.parse('2024-01-15 12:00'),
+      Time.parse('2024-01-15 14:00')..Time.parse('2024-01-15 17:00')
+    ]
+  )
+
+# Using date multiranges for availability periods
+booking =
+  Booking.create!(
+    title: 'Annual Maintenance',
+    booked_periods: [
+      Time.zone.parse('2024-03-01 00:00')..Time.zone.parse('2024-03-03 23:59'),
+      Time.zone.parse('2024-06-15 00:00')..Time.zone.parse('2024-06-17 23:59')
+    ],
+    blackout_dates: [
+      Date.parse('2024-12-24')..Date.parse('2024-12-26'),
+      Date.parse('2024-12-31')..Date.parse('2024-01-01')
+    ]
+  )
+
+# Using numeric multiranges for pricing tiers
+product = Product.create!(name: 'Premium Service', price_ranges: [10.0..50.0, 100.0..500.0, 1000.0..5000.0])
+```
+
+#### Reading and Manipulating Multirange Data
+
+```ruby
+schedule = Schedule.find(1)
+
+# Access multirange values
+puts schedule.available_times
+# => [2024-01-15 09:00:00 UTC..2024-01-15 12:00:00 UTC, 2024-01-15 14:00:00 UTC..2024-01-15 17:00:00 UTC]
+
+# Check if multirange contains a specific value
+morning_slot = Time.parse('2024-01-15 10:30')
+puts schedule.available_times.any? { |range| range.cover?(morning_slot) }
+# => true
+
+# Add new time ranges
+schedule.available_times += [Time.parse('2024-01-15 18:00')..Time.parse('2024-01-15 20:00')]
+schedule.save!
 
+# Working with individual ranges
+schedule.available_times.each { |time_range| puts "Available from #{time_range.begin} to #{time_range.end}" }
+```
+
+### Querying Multirange Columns
+
+#### Overlap Queries
+
+```ruby
+# Find schedules that overlap with a specific time range
+search_range = Time.parse('2024-01-15 10:00')..Time.parse('2024-01-15 11:00')
+overlapping_schedules = Schedule.where('available_times && ?', search_range)
+
+# Find bookings that don't overlap with a date range
+available_dates = Date.parse('2024-03-01')..Date.parse('2024-03-05')
+non_conflicting_bookings = Booking.where('NOT (blackout_dates && ?)', available_dates)
+```
+
+#### Contains Queries
+
+```ruby
+# Find schedules that contain a specific timestamp
+specific_time = Time.parse('2024-01-15 10:30')
+containing_schedules = Schedule.where('available_times @> ?', specific_time)
+
+# Find products within a specific price range
+price_point = 75.0
+products_in_range = Product.where('price_ranges @> ?', price_point)
+```
+
+#### Other Useful Queries
+
+```ruby
+# Check if multirange is contained within another range
+broad_range = Time.parse('2024-01-15 08:00')..Time.parse('2024-01-15 18:00')
+fully_contained = Schedule.where('available_times <@ ?', broad_range)
+
+# Find records where multiranges are strictly left of a range
+cutoff_time = Time.parse('2024-01-15 12:00')..Time.parse('2024-01-15 24:00')
+morning_only = Schedule.where('available_times << ?', cutoff_time)
 
+# Find records where multiranges are strictly right of a range
+start_time = Time.parse('2024-01-15 00:00')..Time.parse('2024-01-15 12:00')
+afternoon_only = Schedule.where('available_times >> ?', start_time)
 ```
-  t.tsmultirange :column
-  t.tstzmultirange :column_tz
-  t.datemultirange :column_date
-  t.nummultirange :column_num
-  t.int8multirange :column_int8
-  t.int4multirange :column_int4
+
+### Practical Examples
+
+#### Availability Scheduling System
+
+```ruby
+class Room < ApplicationRecord
+  def available_during?(time_range)
+    available_times.any? { |range| range.cover?(time_range) }
+  end
+
+  def book_time!(time_range)
+    # Remove the booked time from available times
+    new_availability = []
+    available_times.each do |available_range|
+      if available_range.overlaps?(time_range)
+        # Split the range if needed
+        if available_range.begin < time_range.begin
+          new_availability << (available_range.begin...time_range.begin)
+        end
+        if time_range.end < available_range.end
+          new_availability << (time_range.end...available_range.end)
+        end
+      else
+        new_availability << available_range
+      end
+    end
+
+    update!(available_times: new_availability)
+  end
+end
+
+# Usage
+room = Room.find(1)
+booking_time = Time.parse('2024-01-15 10:00')..Time.parse('2024-01-15 11:00')
+
+if room.available_during?(booking_time)
+  room.book_time!(booking_time)
+  puts 'Room booked successfully!'
+else
+  puts 'Room not available during requested time'
+end
+```
+
+#### Price Range Management
+
+```ruby
+class Product < ApplicationRecord
+  def price_tier_for(quantity)
+    price_ranges.each_with_index do |range, index|
+      if range.cover?(quantity)
+        return index + 1
+      end
+    end
+    nil
+  end
+
+  def applies_to_quantity?(quantity)
+    quantity_ranges.any? { |range| range.cover?(quantity) }
+  end
+end
+
+# Usage
+product = Product.find(1)
+puts "Quantity 25 is in tier: #{product.price_tier_for(25)}"
+puts "Product applies to quantity 150: #{product.applies_to_quantity?(150)}"
 ```
 
 ## Development

data/lib/activerecord-multirange/adapter.rb

@@ -8,28 +8,33 @@ module Activerecord
         load_multirange_types
       end
 
-      def native_database_types
-        super.merge({
-                      datemultirange: { name: "datemultirange" },
-                      nummultirange: { name: "nummultirange" },
-                      tsmultirange: { name: "tsmultirange" },
-                      tstzmultirange: { name: "tstzmultirange" },
-                      int4multirange: { name: "int4multirange" },
-                      int8multirange: { name: "int8multirange" }
-                    })
+      def self.native_database_types
+        super.merge(Activerecord::Multirange::MULTIRANGE_TYPES)
       end
 
       def load_multirange_types
-        initializer = ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::OID::TypeMapInitializer.new(type_map)
-        query = <<-QUERY
-            SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype
-            FROM pg_type as t
-            JOIN pg_range as r ON oid = "rngmultitypid";
+        initializer =
+          ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::OID::TypeMapInitializer
+            .new(type_map)
+        
+        # Query for multirange types and their corresponding base types (not range types)
+        # We need to get the range's subtype (e.g., date) not the range type itself
+        query = <<-QUERY.squish
+          SELECT m.oid, m.typname, m.typelem, m.typdelim, m.typinput, 
+                 pr.rngsubtype, m.typtype, m.typbasetype
+          FROM pg_type m 
+          JOIN pg_type r ON REPLACE(m.typname, 'multirange', 'range') = r.typname
+          JOIN pg_range pr ON r.oid = pr.rngtypid
+          WHERE m.typtype = 'm';
         QUERY
 
-        execute_and_clear(query, "SCHEMA", []) do |records|
-          initializer.register_multirange_type(records)
+        # Use exec_query for all Rails versions since execute_and_clear is private
+        result = exec_query(query, 'SCHEMA', [])
+        # Convert rows to hash format with column names as keys
+        records = result.rows.map do |row|
+          result.columns.zip(row).to_h
         end
+        initializer.register_multirange_type(records)
       end
     end
   end

data/lib/activerecord-multirange/oid/multi_range.rb

@@ -78,6 +78,8 @@ module Activerecord
         # * https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-IO
         # * https://www.postgresql.org/docs/current/rowtypes.html#ROWTYPES-IO-SYNTAX
         def unquote(value)
+          return value if value.nil?
+          
           if value.start_with?('"') && value.end_with?('"')
             unquoted_value = value[1..-2]
             unquoted_value.gsub!('""', '"')
@@ -89,15 +91,21 @@ module Activerecord
         end
 
         def parse_lower(value)
-          return infinity_value(value, negative: true) if ["", "-infinity"].include?(value)
+          return infinity_value(value, negative: true) if value.nil? || ["", "-infinity"].include?(value)
 
-          @subtype.deserialize(unquote(value))
+          unquoted = unquote(value)
+          return nil if unquoted.nil?
+          
+          @subtype.deserialize(unquoted)
         end
 
         def parse_upper(value)
-          return infinity_value(value) if ["", "infinity"].include?(value)
+          return infinity_value(value) if value.nil? || ["", "infinity"].include?(value)
 
-          @subtype.deserialize(unquote(value))
+          unquoted = unquote(value)
+          return nil if unquoted.nil?
+          
+          @subtype.deserialize(unquoted)
         end
 
         def extract_range_data(value)

data/lib/activerecord-multirange/schema_statements.rb

@@ -4,14 +4,7 @@ module Activerecord
   module Multirange
     module SchemaStatements
       def native_database_types
-        super.merge({
-                      tsmultirange: { name: "tsmultirange" },
-                      datemultirange: { name: "datemultirange" },
-                      tstzmultirange: { name: "tstzmultirange" },
-                      nummultirange: { name: "nummultirange" },
-                      int8multirange: { name: "int8multirange" },
-                      int4multirange: { name: "int4multirange" }
-                    })
+        super.merge(Activerecord::Multirange::MULTIRANGE_TYPES)
       end
     end
   end

data/lib/activerecord-multirange/type_map.rb

@@ -1,15 +1,27 @@
 # frozen_string_literal: true
 
-require "activerecord-multirange/oid/multi_range"
+require 'activerecord-multirange/oid/multi_range'
 
 module Activerecord
   module Multirange
     module TypeMap
       def register_multirange_type(records)
         records.each do |row|
-          register_with_subtype(row["oid"], row["rngsubtype"].to_i) do |subtype|
-            Activerecord::Multirange::OID::MultiRange.new(subtype, row["typname"].to_sym)
-          end
+          multirange_oid = row['oid']
+          range_oid = row['rngsubtype'] 
+          type_name = row['typname']
+          
+          # Get the range subtype from the type map
+          range_type = @store.lookup(range_oid)
+          next unless range_type
+          
+          # Create and register the multirange type
+          multirange_type = Activerecord::Multirange::OID::MultiRange.new(
+            range_type,
+            type_name.to_sym
+          )
+          
+          register(multirange_oid, multirange_type)
         end
       end
     end

data/lib/activerecord-multirange/version.rb

@@ -2,6 +2,6 @@
 
 module Activerecord
   module Multirange
-    VERSION = "1.0.0"
+    VERSION = '1.1.1'
   end
 end

data/lib/activerecord-multirange.rb

@@ -1,24 +1,65 @@
 # frozen_string_literal: true
 
-require "activerecord-multirange/version"
-require "activerecord-multirange/adapter"
-require "activerecord-multirange/quoting"
-require "activerecord-multirange/schema_statements"
-require "activerecord-multirange/table_definition"
-require "activerecord-multirange/type_map"
-require "active_record"
+require 'activerecord-multirange/version'
+require 'activerecord-multirange/adapter'
+require 'activerecord-multirange/quoting'
+require 'activerecord-multirange/schema_statements'
+require 'activerecord-multirange/table_definition'
+require 'activerecord-multirange/type_map'
+require 'active_record'
 
 module Activerecord
   module Multirange
-    class Error < StandardError; end
+    class Error < StandardError
+    end
+
+    # Multirange types that need to be registered
+    MULTIRANGE_TYPES = {
+      tsmultirange: { name: "tsmultirange" },
+      datemultirange: { name: "datemultirange" },
+      tstzmultirange: { name: "tstzmultirange" },
+      nummultirange: { name: "nummultirange" },
+      int8multirange: { name: "int8multirange" },
+      int4multirange: { name: "int4multirange" }
+    }.freeze
 
     def self.add_multirange_column_type
       ActiveSupport.on_load(:active_record) do
+        # Register multirange types in NATIVE_DATABASE_TYPES for Rails 8 compatibility
+        Activerecord::Multirange.register_native_database_types
+
         ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(Adapter)
-        ActiveRecord::ConnectionAdapters::PostgreSQL::OID::TypeMapInitializer.prepend(TypeMap)
+        ActiveRecord::ConnectionAdapters::PostgreSQL::OID::TypeMapInitializer
+          .prepend(TypeMap)
         ActiveRecord::ConnectionAdapters::PostgreSQL::Quoting.prepend(Quoting)
-        ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements.prepend(SchemaStatements)
-        ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition.prepend(TableDefinition)
+        ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements.prepend(
+          SchemaStatements
+        )
+        ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition.prepend(
+          TableDefinition
+        )
+      end
+    end
+
+    def self.register_native_database_types
+      # Ensure the PostgreSQL adapter is loaded
+      return unless defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+
+      adapter_class = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+
+      # Check if NATIVE_DATABASE_TYPES is already defined and modifiable
+      if adapter_class.const_defined?(:NATIVE_DATABASE_TYPES)
+        current_types = adapter_class::NATIVE_DATABASE_TYPES
+        
+        # Only modify if our types aren't already registered
+        unless current_types.key?(:tsmultirange)
+          # Create a new hash with existing types plus our multirange types
+          new_types = current_types.merge(MULTIRANGE_TYPES)
+          
+          # Replace the constant with the updated hash
+          adapter_class.send(:remove_const, :NATIVE_DATABASE_TYPES)
+          adapter_class.const_set(:NATIVE_DATABASE_TYPES, new_types.freeze)
+        end
       end
     end
   end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-multirange
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Gustavo Warmling Teixeira
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-30 00:00:00.000000000 Z
+date: 2025-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -139,7 +138,6 @@ licenses:
 metadata:
   homepage_uri: https://github.com/gustavowt/activerecord-multirange
   source_code_uri: https://github.com/gustavowt/activerecord-multirange
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -154,8 +152,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 3.6.6
 specification_version: 4
 summary: PostgreSQL multiranges support
 test_files: []