activerecord-full_text_search 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a0e395c41810e9e42ae30e3f2aca5527fe80666fd52dcfdd9913b3501b6e97f0
+  data.tar.gz: dab379e41ed0fe39a5f90e3dc42b99337d5dbf441e6e8b1b10eae93ab6f202c9
+SHA512:
+  metadata.gz: 51fc2b15b2016a7030c4fbd63c0cf0065453c1cff0d4a50007d8870e556cf8e4098008f7077a76b85c41124d865cda4e4fda3d9f0acdc38d8dbb4b7c951f32ba
+  data.tar.gz: e97e619209f362b9412ad7df74b0511f3f99b557dd1085cd8b7508ae4ee369b74e2e8f5a7ea2c4c8191ab3253ecd4432ee8c25b0c2f5d14d295c344b206198bf

data/.github/workflows/main.yml

@@ -0,0 +1,28 @@
+name: Ruby
+
+on:
+  push:
+    branches:
+      - main
+
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    name: Ruby ${{ matrix.ruby }}
+    strategy:
+      matrix:
+        ruby:
+          - "3.1.3"
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - name: Run the default task
+        run: bundle exec rake

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.vim
+.envrc
+.DS_Store
+
+# rspec failure tracking
+.rspec_status

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/standardrb/standard
+ruby_version: 3.0

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2024-11-28
+
+### Added
+
+- Support for TEXT SEARCH queries.
+- Basic support for FUNCTIONS

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in activerecord-full_text_search.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.16"
+
+gem "standard", "~> 1.3"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Codeur SAS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,47 @@
+# ActiveRecord::FullTextSearch
+
+This gem adds support for TEXT SEARCH commands in a Rails (>= 7.2) app using PostgreSQL.
+
+It is largely built using the gem [activerecord-pg_enum](https://github.com/alassek/activerecord-pg_enum). Thanks!
+
+## Usage
+
+The gem permits to use these commands:
+
+- `create_function`
+- `drop_function`
+- `create_text_search_template`
+- `rename_text_search_template`
+- `drop_text_search_template`
+- `create_text_search_parser`
+- `rename_text_search_parser`
+- `drop_text_search_parser`
+- `create_text_search_dictionary`
+- `rename_text_search_dictionary`
+- `drop_text_search_dictionary`
+- `create_text_search_configuration`
+- `rename_text_search_configuration`
+- `drop_text_search_configuration`
+- `add_text_search_configuration_mapping`
+- `change_text_search_configuration_mapping`
+- `replace_text_search_configuration_mapping`
+- `drop_text_search_configuration_mapping`
+
+## TODO
+
+- Add tests
+- Enhance (and extract?) functions support
+- Check recorder
+- Manage schema (`public` is hardcoded)
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/codeur/activerecord-full_text_search. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/codeur/activerecord-full_text_search/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the ActiveRecord::FullTextSearch project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/codeur/activerecord-full_text_search/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "standard/rake"
+
+task default: %i[test standard]

data/activerecord-full_text_search.gemspec

@@ -0,0 +1,36 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "active_record/full_text_search/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "activerecord-full_text_search"
+  spec.version = ActiveRecord::FullTextSearch::VERSION
+  spec.authors = ["Codeur SAS"]
+  spec.email = ["dev@codeur.com"]
+
+  spec.summary = "Integrate PostgreSQL's FTS configs with Rails"
+  spec.description = "Integrate PostgreSQL's Full Text Search configurations with Rails"
+  spec.homepage = "https://github.com/codeur/activerecord-full_text_search"
+  spec.license = "MIT"
+
+  spec.metadata = {
+    "bug_tracker_uri" => "https://github.com/codeur/activerecord-full_text_search/issues",
+    "changelog_uri" => "https://github.com/codeur/activerecord-full_text_search/blob/master/CHANGELOG.md",
+    "pgp_keys_uri" => "https://keybase.io/codeur/pgp_keys.asc",
+    "signatures_uri" => "https://keybase.pub/codeur/gems/"
+  }
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+
+  spec.required_ruby_version = ">= 2.2.2"
+
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "pg"
+  spec.add_dependency "activerecord", ">= 7.2.0"
+  spec.add_dependency "activesupport"
+end

data/bin/console

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "activerecord/full_text_search"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+# gem install appraisal
+# appraisal bundle install
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/active_record/full_text_search/7.2/postgresql_adapter.rb

@@ -0,0 +1,117 @@
+module ActiveRecord
+  module FullTextSearch
+    register :postgresql_adapter do
+      require "active_record/connection_adapters/postgresql_adapter"
+      ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.include ::ActiveRecord::FullTextSearch::PostgreSQLAdapter
+    end
+
+    module PostgreSQLAdapter
+      VOLATILITIES = {
+        "i" => :immutable,
+        "s" => :stable,
+        "v" => :volatile
+      }.freeze
+
+      def functions
+        # List of functions in the current schema with their argument types, return type, language,  immutability, and body.
+        # List only functions that don't depend on extensions.
+        res = exec_query(<<-SQL.strip_heredoc, "SCHEMA")
+          SELECT proname, pg_catalog.pg_get_function_arguments(p.oid) AS argtypes, pg_catalog.pg_get_function_result(p.oid) AS rettype, lanname, provolatile, prosrc
+          FROM pg_catalog.pg_proc p
+          JOIN pg_catalog.pg_namespace n ON n.oid = pronamespace
+          JOIN pg_catalog.pg_language l ON l.oid = prolang
+          LEFT JOIN pg_catalog.pg_depend d ON d.objid = p.oid AND d.deptype = 'e'
+          LEFT JOIN pg_catalog.pg_extension e ON e.oid = d.refobjid
+          WHERE n.nspname = ANY (current_schemas(false))
+            AND e.extname IS NULL;
+        SQL
+
+        res.rows.each_with_object({}) do |(name, args, ret, lang, vol, src), memo|
+          memo[name] = {arguments: args, returns: ret, language: lang, volatility: VOLATILITIES[vol], source: src}
+        end
+      end
+
+      def text_search_parsers
+        res = exec_query(<<-SQL.strip_heredoc, "SCHEMA")
+          SELECT prsname, prsstart::VARCHAR, prstoken::VARCHAR, prsend::VARCHAR, prsheadline::VARCHAR, prslextype::VARCHAR
+          FROM pg_catalog.pg_ts_parser
+          LEFT JOIN pg_catalog.pg_depend AS d ON d.objid = pg_ts_parser.oid AND d.deptype = 'e'
+          LEFT JOIN pg_catalog.pg_extension AS e ON e.oid = d.refobjid
+          WHERE prsnamespace = (SELECT oid FROM pg_catalog.pg_namespace WHERE nspname = ANY (current_schemas(false)))
+            AND e.extname IS NULL;
+        SQL
+
+        res.rows.each_with_object({}) do |(name, start, token, finish, headline, lextype), memo|
+          memo[name] = {start: start, token: token, finish: finish, headline: headline, lextype: lextype}
+        end
+      end
+
+      def text_search_templates
+        res = exec_query(<<-SQL.strip_heredoc, "SCHEMA")
+          SELECT tmplname, tmplinit::VARCHAR, tmpllexize::VARCHAR
+          FROM pg_catalog.pg_ts_template
+          LEFT JOIN pg_catalog.pg_depend AS d ON d.objid = pg_ts_template.oid AND d.deptype = 'e'
+          LEFT JOIN pg_catalog.pg_extension AS e ON e.oid = d.refobjid
+          WHERE tmplnamespace = (SELECT oid FROM pg_catalog.pg_namespace WHERE nspname = ANY (current_schemas(false)))
+            AND tmplnamespace NOT IN (SELECT extnamespace FROM pg_extension)
+            AND e.extname IS NULL;
+        SQL
+
+        res.rows.each_with_object({}) { |(name, init, lexize), memo| memo[name] = {init: init, lexize: lexize} }
+      end
+
+      def text_search_dictionaries
+        res = exec_query(<<-SQL.strip_heredoc, "SCHEMA")
+          SELECT dictname, tns.nspname || '.' || tmplname, dictinitoption
+          FROM pg_catalog.pg_ts_dict
+          LEFT JOIN pg_catalog.pg_ts_template AS t ON dicttemplate = t.oid
+          LEFT JOIN pg_catalog.pg_namespace AS tns ON t.tmplnamespace = tns.oid
+          LEFT JOIN pg_catalog.pg_depend AS d ON d.objid = dicttemplate AND d.deptype = 'e'
+          LEFT JOIN pg_catalog.pg_extension AS e ON e.oid = d.refobjid
+          WHERE dictnamespace = (SELECT oid FROM pg_catalog.pg_namespace WHERE nspname = ANY (current_schemas(false)))
+            AND e.extname IS NULL;
+        SQL
+
+        res.rows.each_with_object({}) { |(name, template, init), memo| memo[name] = options_to_hash(init).reverse_merge(template: template) }.sort_by { |k, _| k.to_s }.sort_by { |_, v| v[:dictionary].nil? ? 0 : 1 }
+      end
+
+      def text_search_configurations
+        res = exec_query(<<-SQL.strip_heredoc, "SCHEMA")
+          SELECT cfg.oid, cfgname, cfgparser, prsname
+          FROM pg_catalog.pg_ts_config AS cfg
+          LEFT JOIN pg_catalog.pg_ts_parser ON cfgparser = pg_ts_parser.oid
+          LEFT JOIN pg_catalog.pg_depend AS d ON d.objid = cfgparser AND d.deptype = 'e'
+          LEFT JOIN pg_catalog.pg_extension AS e ON e.oid = d.refobjid
+          WHERE cfgnamespace = (SELECT oid FROM pg_catalog.pg_namespace WHERE nspname = ANY (current_schemas(false)))
+            AND e.extname IS NULL;
+        SQL
+
+        res.rows.each_with_object({}) do |(oid, name, parser_oid, parser_name), memo|
+          maps = exec_query(<<-SQL.strip_heredoc, "SCHEMA")
+            SELECT t.alias AS "token", dictname AS "dict"
+            FROM pg_catalog.pg_ts_config_map
+            JOIN (SELECT * FROM ts_token_type(#{parser_oid})) AS t ON maptokentype = t.tokid
+            JOIN pg_catalog.pg_ts_dict ON mapdict = pg_ts_dict.oid
+            WHERE mapcfg = #{oid}
+            ORDER BY mapseqno;
+          SQL
+          maps = maps.rows.each_with_object({}) { |(token, dict), memo|
+            memo[token] ||= []
+            memo[token] << dict
+          }
+          maps = maps.each_with_object({}) { |(k, v), memo|
+            memo[v] ||= []
+            memo[v] << k
+          }
+          memo[name] = {parser: parser_name, maps: maps}
+        end
+      end
+
+      private
+
+      def options_to_hash(text)
+        text.split(/\s*,\s*/).map { |s| s.strip.split(/\s+=\s+/) }.to_h.transform_values { |v| v[1..-2] }.transform_keys(&:to_sym)
+      end
+    end
+  end
+end

data/lib/active_record/full_text_search/7.2/schema_dumper.rb

@@ -0,0 +1,102 @@
+module ActiveRecord
+  module FullTextSearch
+    register :schema_dumper do
+      require "active_record/connection_adapters/postgresql/schema_dumper"
+      ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaDumper.prepend SchemaDumper
+    end
+
+    module SchemaDumper
+      private
+
+      def extensions(stream)
+        super
+        functions(stream)
+        text_search_parsers(stream)
+        text_search_templates(stream)
+        text_search_dictionaries(stream)
+        text_search_configurations(stream)
+      end
+
+      def functions(stream)
+        return unless (functions = @connection.functions).any?
+
+        stream.puts "  # These are functions that must be created in order to support this database"
+
+        functions.each do |name, definition|
+          source = definition.delete(:source)
+          arguments = definition.delete(:arguments)
+          stream.puts %{  create_function "#{name}(#{arguments})", #{hash_to_string(definition)}, as: <<~SQL}
+          stream.puts source.strip.gsub(/^/, "    ").gsub(/\s+$/, "")
+          stream.puts "  SQL"
+        end
+
+        stream.puts
+      end
+
+      def text_search_parsers(stream)
+        return unless (parsers = @connection.text_search_parsers).any?
+
+        stream.puts "  # These are full-text search parsers that must be created in order to support this database"
+
+        parsers.each do |name, definition|
+          stream.puts %(  create_text_search_parser "#{name}", #{hash_to_string(definition)})
+        end
+
+        stream.puts
+      end
+
+      def text_search_templates(stream)
+        return unless (templates = @connection.text_search_templates).any?
+
+        stream.puts "  # These are full-text search templates that must be created in order to support this database"
+
+        templates.each do |name, definition|
+          stream.puts %(  create_text_search_template "#{name}", #{hash_to_string(definition)})
+        end
+        stream.puts
+      end
+
+      def text_search_dictionaries(stream)
+        return unless (dictionaries = @connection.text_search_dictionaries).any?
+
+        stream.puts "  # These are full-text search dictionaries that must be created in order to support this database"
+
+        dictionaries.each do |name, definition|
+          stream.puts %(  create_text_search_dictionary "#{name}", #{hash_to_string(definition)})
+        end
+
+        stream.puts
+      end
+
+      def text_search_configurations(stream)
+        return unless (configurations = @connection.text_search_configurations).any?
+
+        stream.puts "  # These are full-text search configurations that must be created in order to support this database"
+
+        configurations.each do |name, definition|
+          if definition[:parser] == "default"
+            stream.puts %(  create_text_search_configuration "#{name}")
+          else
+            stream.puts %(  create_text_search_configuration "#{name}", parser: "#{definition[:parser]}")
+          end
+          definition[:maps].each do |dicts, tokens|
+            stream.puts %(  add_text_search_configuration_mapping "#{name}", #{array_to_string(tokens)}, #{array_to_string(dicts)})
+          end
+        end
+        stream.puts
+      end
+
+      private
+
+      def hash_to_string(hash)
+        hash.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
+      end
+
+      def array_to_string(array)
+        return array.inspect if array.detect { |v| !v.is_a?(String) || v =~ /\s+/ }
+
+        "%w[#{array.join(" ")}]"
+      end
+    end
+  end
+end

data/lib/active_record/full_text_search/command_recorder.rb

@@ -0,0 +1,180 @@
+module ActiveRecord
+  module FullTextSearch
+    register :command_recorder do
+      require "active_record/migration/command_recorder"
+      ActiveRecord::Migration::CommandRecorder.include CommandRecorder
+    end
+
+    # ActiveRecord::Migration::CommandRecorder is a class used by reversible migrations.
+    # It captures the forward migration commands and translates them into their inverse
+    # by way of some simple metaprogramming.
+    #
+    # The Migrator class uses CommandRecorder during the reverse migration instead of
+    # the connection object. Forward migration calls are translated to their inverse
+    # where possible, and then forwarded to the connetion. Irreversible migrations
+    # raise an exception.
+    #
+    # Known schema statement methods are metaprogrammed into an inverse method like so:
+    #
+    #   create_table => invert_create_table
+    #
+    # which returns:
+    #
+    #   [:drop_table, args.first]
+    module CommandRecorder
+      def create_function(*args, &block)
+        record(:create_function, args, &block)
+      end
+
+      def drop_function(*args, &block)
+        record(:drop_function, args, &block)
+      end
+
+      def create_text_search_configuration(*args, &block)
+        record(:create_text_search_configuration, args, &block)
+      end
+
+      def drop_text_search_configuration(*args, &block)
+        record(:drop_text_search_configuration, args, &block)
+      end
+
+      def rename_text_search_configuration(*args, &block)
+        record(:rename_text_search_configuration, args, &block)
+      end
+
+      def add_text_search_configuration_mappingping(*args, &block)
+        record(:add_text_search_configuration_mappingping, args, &block)
+      end
+
+      def change_text_search_configuration_mapping(*args, &block)
+        record(:change_text_search_configuration_mapping, args, &block)
+      end
+
+      def replace_text_search_configuration_dictionary(*args, &block)
+        record(:replace_text_search_configuration_dictionary, args, &block)
+      end
+
+      def drop_text_search_configuration_mapping(*args, &block)
+        record(:drop_text_search_configuration_mapping, args, &block)
+      end
+
+      def create_text_search_dictionary(*args, &block)
+        record(:create_text_search_dictionary, args, &block)
+      end
+
+      def drop_text_search_dictionary(*args, &block)
+        record(:drop_text_search_dictionary, args, &block)
+      end
+
+      def rename_text_search_dictionary(*args, &block)
+        record(:rename_text_search_dictionary, args, &block)
+      end
+
+      def change_text_search_dictionary_option(*args, &block)
+        record(:change_text_search_dictionary_option, args, &block)
+      end
+
+      def create_text_search_parser(*args, &block)
+        record(:create_text_search_parser, args, &block)
+      end
+
+      def drop_text_search_parser(*args, &block)
+        record(:drop_text_search_parser, args, &block)
+      end
+
+      def rename_text_search_parser(*args, &block)
+        record(:rename_text_search_parser, args, &block)
+      end
+
+      def create_text_search_template(*args, &block)
+        record(:create_text_search_template, args, &block)
+      end
+
+      def drop_text_search_template(*args, &block)
+        record(:drop_text_search_template, args, &block)
+      end
+
+      def rename_text_search_template(*args, &block)
+        record(:rename_text_search_template, args, &block)
+      end
+
+      private
+
+      def invert_create_function(args)
+        [:drop_function, args]
+      end
+
+      def invert_drop_function(args)
+        [:create_function, args]
+      end
+
+      def invert_create_text_search_configuration(args)
+        [:drop_text_search_configuration, args]
+      end
+
+      def invert_drop_text_search_configuration(args)
+        [:create_text_search_configuration, args]
+      end
+
+      def invert_rename_text_search_configuration(args)
+        [:rename_text_search_configuration, [args.last[:to], to: args.first]]
+      end
+
+      def invert_add_text_search_configuration_mappingping(args)
+        [:drop_text_search_configuration_mapping, args]
+      end
+
+      def invert_change_text_search_configuration_mapping(args)
+        [:change_text_search_configuration_mapping, args]
+      end
+
+      def invert_replace_text_search_configuration_dictionary(args)
+        [:replace_text_search_configuration_dictionary, args.values_at(:to, :from)]
+      end
+
+      def invert_drop_text_search_configuration_mapping(args)
+        [:add_text_search_configuration_mappingping, args]
+      end
+
+      def invert_create_text_search_dictionary(args)
+        [:drop_text_search_dictionary, args]
+      end
+
+      def invert_drop_text_search_dictionary(args)
+        [:create_text_search_dictionary, args]
+      end
+
+      def invert_rename_text_search_dictionary(args)
+        [:rename_text_search_dictionary, [args.last[:to], to: args.first]]
+      end
+
+      def invert_change_text_search_dictionary_option(args)
+        [:change_text_search_dictionary_option, args.values_at(:option, :default)]
+      end
+
+      def invert_create_text_search_parser(args)
+        [:drop_text_search_parser, args]
+      end
+
+      def invert_drop_text_search_parser(args)
+        [:create_text_search_parser, args]
+      end
+
+      def invert_rename_text_search_parser(args)
+        [:rename_text_search_parser, [args.last[:to], to: args.first]]
+      end
+
+      def invert_create_text_search_template(args)
+        [:drop_text_search_template, args]
+      end
+
+      def invert_drop_text_search_template(args)
+        [:create_text_search_template, args]
+      end
+
+      def invert_rename_text_search_template(args)
+        [:rename_text_search_template, [args.last[:to], to: args.first]]
+      end
+    end
+  end
+end

data/lib/active_record/full_text_search/schema_statements.rb

@@ -0,0 +1,101 @@
+module ActiveRecord
+  module FullTextSearch
+    register :schema_statements do
+      require "active_record/connection_adapters/postgresql_adapter"
+      ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.include SchemaStatements
+    end
+
+    module SchemaStatements
+      def create_function(name_with_args, as:, volatility: :volatile, language: "sql", returns: "void", replace: true)
+        execute(<<-SQL)
+          CREATE #{"OR REPLACE" if replace} FUNCTION #{name_with_args}
+          RETURNS #{returns}
+          AS $$
+          #{as}
+          $$
+          LANGUAGE #{language}
+          #{volatility.to_s.upcase}
+        SQL
+      end
+
+      def drop_function(name_with_args, if_exists: false, cascade: false)
+        execute "DROP FUNCTION #{"IF EXISTS" if if_exists} #{name_with_args} #{"CASCADE" if cascade}"
+      end
+
+      def create_text_search_template(name, lexize:, init: nil)
+        options = {init: init, lexize: lexize}.compact
+        execute("CREATE TEXT SEARCH TEMPLATE public.#{name} (#{options.map { |k, v| "#{k.upcase} = #{v}" }.join(", ")})")
+      end
+
+      def rename_text_search_template(name, to)
+        execute "ALTER TEXT SEARCH TEMPLATE public.#{name} RENAME TO #{to}"
+      end
+
+      def drop_text_search_template(name, if_exists: false, cascade: :restrict)
+        execute "DROP TEXT SEARCH TEMPLATE #{"IF EXISTS" if if_exists} public.#{name} #{"CASCADE" if cascade == :cascade}"
+      end
+
+      def create_text_search_dictionary(name, options = {})
+        raise ArgumentError, "Must specify :template" unless (template = options.delete(:template))
+        execute("CREATE TEXT SEARCH DICTIONARY public.#{name} (TEMPLATE = #{template}#{options.map { |k, v| ", #{k} = '#{v}'" }.join})")
+      end
+
+      def rename_text_search_dictionary(name, to)
+        execute("ALTER TEXT SEARCH DICTIONARY public.#{name} RENAME TO #{to}")
+      end
+
+      def change_text_search_dictionary_option(name, option, value = :default)
+        execute("ALTER TEXT SEARCH DICTIONARY public.#{name} SET #{option} #{value if value != :default}")
+      end
+
+      def drop_text_search_dictionary(name, if_exists: false, cascade: :restrict)
+        execute "DROP TEXT SEARCH DICTIONARY #{"IF EXISTS" if if_exists} public.#{name} #{"CASCADE" if cascade == :cascade}"
+      end
+
+      def create_text_search_parser(name, start:, gettoken:, end:, lextypes:, headline: nil)
+        options = {start: start, gettoken: gettoken, end: binding.local_variable_get(:end), lextypes: lextypes, headline: headline}.compact
+        execute("CREATE TEXT SEARCH PARSER public.#{name} (#{options.map { |k, v| "#{k.upcase} = #{v}" }.join(", ")})")
+      end
+
+      def rename_text_search_parser(name, to)
+        execute "ALTER TEXT SEARCH PARSER public.#{name} RENAME TO #{to}"
+      end
+
+      def drop_text_search_parser(name, if_exists: false, cascade: :restrict)
+        execute "DROP TEXT SEARCH PARSER #{"IF EXISTS" if if_exists} public.#{name} #{"CASCADE" if cascade == :cascade}"
+      end
+
+      def create_text_search_configuration(name, parser: nil, copy: nil)
+        if copy
+          execute("CREATE TEXT SEARCH CONFIGURATION public.#{name} (COPY = #{copy})")
+        else
+          execute("CREATE TEXT SEARCH CONFIGURATION public.#{name} (PARSER = '#{parser || "default"}')")
+        end
+      end
+
+      def rename_text_search_configuration(name, to)
+        execute "ALTER TEXT SEARCH CONFIGURATION public.#{name} RENAME TO #{to}"
+      end
+
+      def add_text_search_configuration_mapping(name, token_types, dictionaries)
+        execute "ALTER TEXT SEARCH CONFIGURATION public.#{name} ADD MAPPING FOR #{token_types.join(", ")} WITH #{dictionaries.join(", ")}"
+      end
+
+      def change_text_search_configuration_mapping(name, token_types, dictionaries)
+        execute "ALTER TEXT SEARCH CONFIGURATION public.#{name} ALTER MAPPING FOR #{token_types.join(", ")} WITH #{dictionaries.join(", ")}"
+      end
+
+      def replace_text_search_configuration_dictionary(name, from:, to:)
+        execute "ALTER TEXT SEARCH CONFIGURATION public.#{name} ALTER MAPPING REPLACE #{from} WITH #{to}"
+      end
+
+      def drop_text_search_configuration_mapping(name, token_types, if_exists: false)
+        execute "ALTER TEXT SEARCH CONFIGURATION public.#{name} DROP MAPPING #{"IF EXISTS" if if_exists} FOR #{token_types.join(", ")}"
+      end
+
+      def drop_text_search_configuration(name, if_exists: false, cascade: :restrict)
+        execute "DROP TEXT SEARCH CONFIGURATION #{"IF EXISTS" if if_exists} public.#{name} #{"CASCADE" if cascade == :cascade}"
+      end
+    end
+  end
+end

data/lib/active_record/full_text_search/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module FullTextSearch
+    VERSION = "0.1.0"
+  end
+end

data/lib/active_record/full_text_search.rb

@@ -0,0 +1,61 @@
+require "active_record"
+require "active_support/lazy_load_hooks"
+
+module ActiveRecord
+  module FullTextSearch
+    KNOWN_VERSIONS = %w[7.2].map { |v| Gem::Version.new(v) }.freeze
+
+    class << self
+      attr_reader :enabled_version
+
+      def install(version)
+        @enabled_version = approximate_version(version)
+
+        # Don't immediately fail if we don't yet support the current version.
+        # There's at least a chance it could work.
+        if !KNOWN_VERSIONS.include?(enabled_version) && enabled_version > KNOWN_VERSIONS.last
+          @enabled_version = KNOWN_VERSIONS.last
+          warn "[FullTextSearch] Current ActiveRecord version unsupported! Falling back to: #{enabled_version}"
+        end
+
+        initialize!
+      end
+
+      def register(patch, &block)
+        monkeypatches[patch] = block
+      end
+
+      def detected_version
+        approximate_version Gem.loaded_specs["activerecord"].version
+      end
+
+      private
+
+      def monkeypatches
+        @patches ||= {}
+      end
+
+      def initialize!
+        require "active_record/full_text_search/command_recorder"
+        require "active_record/full_text_search/schema_statements"
+
+        Dir[File.join(__dir__, "full_text_search", enabled_version.to_s, "*.rb")].each { |file| require file }
+        monkeypatches.keys.each { |patch| monkeypatches.delete(patch).call }
+      end
+
+      def approximate_version(version)
+        segments = version.respond_to?(:canonical_segments) ? version.canonical_segments.dup : version.segments
+
+        segments.pop while segments.any? { |s| String === s }
+        segments.pop while segments.size > 2
+        segments.push(0) while segments.size < 2
+
+        Gem::Version.new segments.join(".")
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::FullTextSearch.install Gem.loaded_specs["activerecord"].version
+end

data/lib/activerecord/full_text_search.rb

@@ -0,0 +1 @@
+require "active_record/full_text_search"

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-full_text_search
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Codeur SAS
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-11-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Integrate PostgreSQL's Full Text Search configurations with Rails
+email:
+- dev@codeur.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/main.yml"
+- ".gitignore"
+- ".standard.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- activerecord-full_text_search.gemspec
+- bin/console
+- bin/setup
+- lib/active_record/full_text_search.rb
+- lib/active_record/full_text_search/7.2/postgresql_adapter.rb
+- lib/active_record/full_text_search/7.2/schema_dumper.rb
+- lib/active_record/full_text_search/command_recorder.rb
+- lib/active_record/full_text_search/schema_statements.rb
+- lib/active_record/full_text_search/version.rb
+- lib/activerecord/full_text_search.rb
+homepage: https://github.com/codeur/activerecord-full_text_search
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/codeur/activerecord-full_text_search/issues
+  changelog_uri: https://github.com/codeur/activerecord-full_text_search/blob/master/CHANGELOG.md
+  pgp_keys_uri: https://keybase.io/codeur/pgp_keys.asc
+  signatures_uri: https://keybase.pub/codeur/gems/
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Integrate PostgreSQL's FTS configs with Rails
+test_files: []