runestone 2.0.0 → 2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c069ec88ae02b52e3cb0a155efe7d17b0cb3d0f9b248e74deec97cb1ed752e0
-  data.tar.gz: 4e627b4879f88ae65b8b56090604e7e8fe0379f93f5a72b4142d76d5eabf08f7
+  metadata.gz: 96c3c19ecdb5ba5e58fae758af825532f6dedd8a9ace5291a0e70ad3b28e2436
+  data.tar.gz: eab646d44fb2e24cd14ee1f98fcbbba7944fba4907cb2bb0de452dbdb21554cc
 SHA512:
-  metadata.gz: 7f3f103de6f864ce9d8047232023f1c6db98867be4a7015d899c088875b830d9ee34e84c31d23b18bbdb88fc9058efe7a455891958d5adbb6b3600aed0ff4552
-  data.tar.gz: 014ab3c81cb2c6df0473cd5ec0c65a35a6aa46a41c7f351962b26a97abc32eac74820738bcccddfa0d67b5a3b8c715d8ed5a6d1810d1099be1f134d85ac54679
+  metadata.gz: d728fbc86eedba51c8fc230ca6a49960d7e63a4f7f95af31a5c28cb619df55385c505ac874ca23f53c89b9bba7a2e23d4279ef5583580df05e866b55d145c001
+  data.tar.gz: 8a536c404142691627e26d6d6a74f3434df09a34ae326df390cfb5621e563433dae7f0123985ec0ec4f9168239e0a45b0d942dc12e0f50c59baa60a146a13f62

data/.github/workflows/main.yml

@@ -0,0 +1,45 @@
+name: Test Suite
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-22.04
+    strategy:
+      matrix:
+        rails-version:
+          - 7.0.8
+          - 7.1.2
+        ruby-version:
+          - 3.0
+          - 3.1
+          - 3.2
+        postgres-version:
+          - 15
+
+    steps:
+      - name: Install Postgresql
+        run: |
+          sudo apt-get -y --purge remove $(sudo apt list --installed | grep postgresql | awk '{print $1}')
+          sudo apt-get install curl ca-certificates gnupg
+          curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -
+          sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
+          sudo apt-get update
+          sudo apt-get -y install postgresql-${{ matrix.postgres-version }}-postgis-3
+          sudo systemctl start postgresql@${{ matrix.postgres-version }}-main.service
+          sudo systemctl status postgresql@${{ matrix.postgres-version }}-main.service
+          sudo pg_lsclusters
+          sudo -u postgres createuser runner --superuser
+          sudo -u postgres psql -c "ALTER USER runner WITH PASSWORD 'runner';"
+
+      - uses: actions/checkout@v4
+
+      - run: |
+          echo 'gem "activerecord", "${{ matrix.rails-version }}"' >> Gemfile
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+
+      - name: Run Test Suite
+        run: bundle exec rake test

data/.gitignore

@@ -2,3 +2,4 @@ coverage
 .byebug_history
 *.gem
 Gemfile.lock
+.DS_Store

data/README.md

@@ -51,7 +51,40 @@ class Building < ApplicationRecord
 end
 ```
 
-When searching the attribute(s) will be available in `data` on the result(s), but only the attributes specified by `index` will indexed and used for searching.
+When searching the attribute(s) will be available in `data` on the result(s),
+but only the attributes specified by `index` will indexed and used for searching.
+
+Generally Runestone will automatically update the search index if changes are
+made. This is done by seeing if the corresponding column or association has
+changed. If your search attribute is generated you need to define on the columns
+or associations it depends on.
+
+```ruby
+class User < ApplicationRecord
+  runestone do
+    # The attribute `:name` is generated from the `name_en` column
+    attribute(:name, :name_en) { name_en }
+  end
+end
+
+class Building < ApplicationRecord
+  runestone do
+    # The attribute `:address_numbers` is generated from the association `addresses`
+    attribute(:address_numbers, :addresses) { addresses.map{ |a| a.number } }
+  end
+end
+
+class User < ActiveRecord::Base
+  runestone do
+    index 'name'
+    
+    # The attribute `:name` is updated when the custom logic proc returns true
+    attribute :name, -> () { ...custom logic... } do
+      name
+    end
+  end
+end
+```
 
 ### Searching
 
@@ -93,7 +126,17 @@ is the `simple` dictionary in PostgreSQL with `unaccent` to tranliterate some
 characters to the ASCII equivlent.
 
 ```ruby
-Runestone.dictionary = :runesonte
+module RailsApplicationName
+  class Application < Rails::Application
+    config.runestone.dictionary = :runestone
+  end
+end
+```
+
+If you are not using Rails, you can use the following:
+
+```ruby
+Runestone.dictionary = :runestone
 ```
 
 #### normalization for ranking
@@ -102,7 +145,17 @@ Ranking can be configured to use the `normalization` paramater as described
 in the [PostgreSQL documentation][3]. The default is `16`
 
 ```ruby
-Runestone.dictionary = 16
+module RailsApplicationName
+  class Application < Rails::Application
+    config.runestone.normalization = 1|16
+  end
+end
+```
+
+If you are not using Rails, you can use the following:
+
+```ruby
+Runestone.normalization = 16
 ```
 
 [1]: http://rachbelaid.com/postgres-full-text-search-is-good-enough/

data/lib/runestone/active_record/base_methods.rb

@@ -51,13 +51,13 @@ module Runestone::ActiveRecord
             AND #{model_table}.id IS NULL;
         SQL
 
-        find_each(&:update_runestones!)
+        find_each { |r| r.update_runestones!(false) }
       end
 
       def highlights(name: :default, dictionary: nil)
         dictionary ||= Runestone.dictionary
 
-        rsettings = self.runestone_settings[name].find { |s| s.dictionary.to_s == dictionary.to_s}
+        rsettings = self.runestone_settings[name].find { |s| s.dictionary.to_s == dictionary.to_s }
         @highlights ||= highlight_indexes(rsettings.indexes.values.flatten.map{ |i| i.to_s.split('.') })
       end
 
@@ -106,10 +106,11 @@ module Runestone::ActiveRecord
       Runestone::IndexingJob.preform_later(self, :update_runestones!)
     end
     
-    def update_runestones!
+    def update_runestones!(if_changed = true)
       conn = Runestone::Model.connection
       self.runestone_settings.each do |index_name, settings|
         settings.each do |setting|
+          next if if_changed && !setting.changed?(self)
           rdata = setting.extract_attributes(self)
 
           if conn.execute(<<-SQL).cmd_tuples == 0

data/lib/runestone/engine.rb

@@ -1,11 +1,11 @@
 class Runestone::Engine < Rails::Engine
   config.runestone = ActiveSupport::OrderedOptions.new
 
-  initializer :append_migrations do |app|
-    unless app.root.to_s.match root.to_s
-      config.paths["db/migrate"].expanded.each do |expanded_path|
-        app.config.paths["db/migrate"] << expanded_path
-      end
+  initializer :runestone do |app|
+    ActiveSupport.on_load(:active_record) do
+      require 'active_record/connection_adapters/postgresql/schema_dumper'
+      ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaDumper.prepend(Runestone::PsqlSchemaDumper)
+      ActiveRecord::Tasks::DatabaseTasks.migrations_paths << File.expand_path('../../../db/migrate', __FILE__)
     end
   end
   
@@ -14,8 +14,8 @@ class Runestone::Engine < Rails::Engine
 
     Runestone.runner = options.runner if options.runner
     Runestone.dictionary = options.dictionary if options.dictionary
+    Runestone.normalization = options.normalization if options.normalization
     Runestone.job_queue = options.job_queue if options.job_queue
     Runestone.typo_tolerances = options.typo_tolerances if options.typo_tolerances
   end
-  
 end

data/lib/runestone/psql_schema_dumper.rb

@@ -0,0 +1,17 @@
+module Runestone::PsqlSchemaDumper
+
+  def extensions(stream)
+    super(stream)
+    stream.puts <<-RB
+  ## Install the default dictionary for Runestone in the database
+  execute <<-SQL
+    CREATE TEXT SEARCH CONFIGURATION runestone (COPY = simple);
+    ALTER TEXT SEARCH CONFIGURATION runestone
+      ALTER MAPPING FOR hword, hword_part, word
+      WITH unaccent, simple;
+  SQL
+    RB
+    stream
+  end
+  
+end

data/lib/runestone/settings.rb

@@ -14,11 +14,16 @@ class Runestone::Settings
   end
 
   def attribute(*names, &block)
-    raise ArgumentError.new('Cannot pass multiple attribute names if block given') if block_given? and names.length > 1
+    deps = if block_given? and names.length > 2
+      raise ArgumentError.new('Cannot pass multiple attribute names if block given')
+    else
+      names.length > 1 ? names.pop : names.first
+    end
+    deps = deps.to_s if !deps.is_a?(Proc)
 
     @attributes ||= {}
     names.each do |name|
-      @attributes[name.to_sym] = block ? block : nil
+      @attributes[name.to_sym] = [block ? block : nil, deps]
     end
   end
   alias :attributes :attribute
@@ -27,8 +32,8 @@ class Runestone::Settings
     attributes = {}
 
     @attributes.each do |name, value|
-      attributes[name] = if value.is_a?(Proc)
-        record.instance_exec(&value)
+      attributes[name] = if value[0].is_a?(Proc)
+        record.instance_exec(&value[0])
       else
         rv = record.send(name)
       end
@@ -37,6 +42,18 @@ class Runestone::Settings
     remove_nulls(attributes)
   end
 
+  def changed?(record)
+    @attributes.detect do |name, value|
+      if value[1].is_a?(Proc)
+        record.instance_exec(&value[1])
+      elsif record.attribute_names.include?(value[1])
+        record.previous_changes.has_key?(value[1])
+      elsif record._reflections[value[1]] && association = record.association(value[1])
+        association.loaded? && association.changed_for_autosave?
+      end
+    end
+  end
+  
   def vectorize(data)
     conn = Runestone::Model.connection
     tsvector = []

data/lib/runestone/version.rb

@@ -1,3 +1,3 @@
 module Runestone
-  VERSION = '2.0.0'
+  VERSION = '2.1'
 end

data/lib/runestone.rb

@@ -5,6 +5,7 @@ module Runestone
   autoload :Settings, "#{File.dirname(__FILE__)}/runestone/settings"
   autoload :WebSearch, "#{File.dirname(__FILE__)}/runestone/web_search"
   autoload :IndexingJob, "#{File.dirname(__FILE__)}/runestone/indexing_job"
+  autoload :PsqlSchemaDumper, "#{File.dirname(__FILE__)}/runestone/psql_schema_dumper"
   
   mattr_accessor :dictionary, default: :runestone
   mattr_accessor :normalization, default: 16
@@ -16,37 +17,6 @@ module Runestone
     { }
   end
   
-  DEFAULT_APPROXIMATIONS = {
-    "À"=>"A", "Á"=>"A", "Â"=>"A", "Ã"=>"A", "Ä"=>"A", "Å"=>"A", "Æ"=>"AE",
-    "Ç"=>"C", "È"=>"E", "É"=>"E", "Ê"=>"E", "Ë"=>"E", "Ì"=>"I", "Í"=>"I",
-    "Î"=>"I", "Ï"=>"I", "Ð"=>"D", "Ñ"=>"N", "Ò"=>"O", "Ó"=>"O", "Ô"=>"O",
-    "Õ"=>"O", "Ö"=>"O", "×"=>"x", "Ø"=>"O", "Ù"=>"U", "Ú"=>"U", "Û"=>"U",
-    "Ü"=>"U", "Ý"=>"Y", "Þ"=>"Th", "ß"=>"ss", "à"=>"a", "á"=>"a", "â"=>"a",
-    "ã"=>"a", "ä"=>"a", "å"=>"a", "æ"=>"ae", "ç"=>"c", "è"=>"e", "é"=>"e",
-    "ê"=>"e", "ë"=>"e", "ì"=>"i", "í"=>"i", "î"=>"i", "ï"=>"i", "ð"=>"d",
-    "ñ"=>"n", "ò"=>"o", "ó"=>"o", "ô"=>"o", "õ"=>"o", "ö"=>"o", "ø"=>"o",
-    "ù"=>"u", "ú"=>"u", "û"=>"u", "ü"=>"u", "ý"=>"y", "þ"=>"th", "ÿ"=>"y",
-    "Ā"=>"A", "ā"=>"a", "Ă"=>"A", "ă"=>"a", "Ą"=>"A", "ą"=>"a", "Ć"=>"C",
-    "ć"=>"c", "Ĉ"=>"C", "ĉ"=>"c", "Ċ"=>"C", "ċ"=>"c", "Č"=>"C", "č"=>"c",
-    "Ď"=>"D", "ď"=>"d", "Đ"=>"D", "đ"=>"d", "Ē"=>"E", "ē"=>"e", "Ĕ"=>"E",
-    "ĕ"=>"e", "Ė"=>"E", "ė"=>"e", "Ę"=>"E", "ę"=>"e", "Ě"=>"E", "ě"=>"e",
-    "Ĝ"=>"G", "ĝ"=>"g", "Ğ"=>"G", "ğ"=>"g", "Ġ"=>"G", "ġ"=>"g", "Ģ"=>"G",
-    "ģ"=>"g", "Ĥ"=>"H", "ĥ"=>"h", "Ħ"=>"H", "ħ"=>"h", "Ĩ"=>"I", "ĩ"=>"i",
-    "Ī"=>"I", "ī"=>"i", "Ĭ"=>"I", "ĭ"=>"i", "Į"=>"I", "į"=>"i", "İ"=>"I",
-    "ı"=>"i", "IJ"=>"IJ", "ij"=>"ij", "Ĵ"=>"J", "ĵ"=>"j", "Ķ"=>"K", "ķ"=>"k",
-    "ĸ"=>"k", "Ĺ"=>"L", "ĺ"=>"l", "Ļ"=>"L", "ļ"=>"l", "Ľ"=>"L", "ľ"=>"l",
-    "Ŀ"=>"L", "ŀ"=>"l", "Ł"=>"L", "ł"=>"l", "Ń"=>"N", "ń"=>"n", "Ņ"=>"N",
-    "ņ"=>"n", "Ň"=>"N", "ň"=>"n", "ʼn"=>"'n", "Ŋ"=>"NG", "ŋ"=>"ng",
-    "Ō"=>"O", "ō"=>"o", "Ŏ"=>"O", "ŏ"=>"o", "Ő"=>"O", "ő"=>"o", "Œ"=>"OE",
-    "œ"=>"oe", "Ŕ"=>"R", "ŕ"=>"r", "Ŗ"=>"R", "ŗ"=>"r", "Ř"=>"R", "ř"=>"r",
-    "Ś"=>"S", "ś"=>"s", "Ŝ"=>"S", "ŝ"=>"s", "Ş"=>"S", "ş"=>"s", "Š"=>"S",
-    "š"=>"s", "Ţ"=>"T", "ţ"=>"t", "Ť"=>"T", "ť"=>"t", "Ŧ"=>"T", "ŧ"=>"t",
-    "Ũ"=>"U", "ũ"=>"u", "Ū"=>"U", "ū"=>"u", "Ŭ"=>"U", "ŭ"=>"u", "Ů"=>"U",
-    "ů"=>"u", "Ű"=>"U", "ű"=>"u", "Ų"=>"U", "ų"=>"u", "Ŵ"=>"W", "ŵ"=>"w",
-    "Ŷ"=>"Y", "ŷ"=>"y", "Ÿ"=>"Y", "Ź"=>"Z", "ź"=>"z", "Ż"=>"Z", "ż"=>"z",
-    "Ž"=>"Z", "ž"=>"z"
-  }.freeze
-
   def self.normalize(string)
     string = string.downcase
     string = string.unicode_normalize!
@@ -61,10 +31,6 @@ module Runestone
   rescue Encoding::CompatibilityError
   end
 
-  def transliterate(string)
-    string.gsub(/[^\x00-\x7f]/u) { |char| approximations[char] || char }
-  end
-
   def self.add_synonyms(dictionary)
     dictionary.each do |k, v|
       add_synonym(k, *v)

data/runestone.gemspec

@@ -24,9 +24,9 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'byebug'
   s.add_development_dependency 'faker'
   s.add_development_dependency 'simplecov'
-  s.add_development_dependency 'activejob', '>= 6.0'
+  s.add_development_dependency 'activejob', '>= 7.0'
 
   # Runtime
-  s.add_runtime_dependency 'arel-extensions', '>= 6.0.0.9'
-  s.add_runtime_dependency 'activerecord', '>= 6.0'
+  s.add_runtime_dependency 'arel-extensions', '>= 7.0.0'
+  s.add_runtime_dependency 'activerecord', '>= 7.0'
 end

data/test/database.rb

@@ -1,18 +1,16 @@
 GlobalID.app = 'TestApp'
 
-task = ActiveRecord::Tasks::PostgreSQLDatabaseTasks.new({
-  'adapter' => 'postgresql',
-  'database' => "arel-extensions-test"
-})
-task.drop
-task.create
-
 ActiveRecord::Base.establish_connection({
   adapter:  "postgresql",
   database: "arel-extensions-test",
   encoding: "utf8"
 })
 
+db_config = ActiveRecord::Base.connection_db_config
+task = ActiveRecord::Tasks::PostgreSQLDatabaseTasks.new(db_config)
+task.drop
+task.create
+
 ActiveRecord::Migration.suppress_messages do
   ActiveRecord::Schema.define do
     enable_extension 'pgcrypto'
@@ -22,21 +20,29 @@ ActiveRecord::Migration.suppress_messages do
 
     create_table :addresses, id: :uuid, force: :cascade do |t|
       t.string  "name"
+      t.string  "metadata"
       t.uuid    "property_id"
     end
     
     create_table :properties, id: :uuid, force: :cascade do |t|
-      t.string   "name",                 limit: 255
+      t.string  "name",                 limit: 255
+      t.string  "metadata"
     end
 
     create_table :regions, id: :uuid, force: :cascade do |t|
       t.string   "name",                 limit: 255
+      t.boolean   "pooblic",              default: true
     end
 
     create_table :buildings, id: :uuid, force: :cascade do |t|
       t.string   "name_en",              limit: 255
       t.string   "name_ru",              limit: 255
     end
+    
+    create_table :people, id: :uuid, force: :cascade do |t|
+      t.string   "name",                 limit: 255
+      t.boolean   "pooblic",              default: true
+    end
 
     create_table :runestones, id: :uuid, force: :cascade do |t|
       t.string    :record_type,     null: false
@@ -51,10 +57,9 @@ ActiveRecord::Migration.suppress_messages do
     add_index :runestones, :vector, using: :gin
     
     execute <<-SQL
-    CREATE TABLE runestone_corpus ( word varchar, CONSTRAINT word UNIQUE(word) );
-
-    CREATE INDEX runestone_corpus_trgm_idx ON runestone_corpus USING GIN (word gin_trgm_ops);
+      CREATE TABLE runestone_corpus ( word varchar, CONSTRAINT word UNIQUE(word) );
 
+      CREATE INDEX runestone_corpus_trgm_idx ON runestone_corpus USING GIN (word gin_trgm_ops);
 
       CREATE TEXT SEARCH CONFIGURATION runestone (COPY = simple);
       ALTER TEXT SEARCH CONFIGURATION runestone
@@ -90,7 +95,7 @@ end
 
 class Property < ActiveRecord::Base
   
-  has_many :addresses
+  has_many :addresses, autosave: true
 
   runestone do
     index :name
@@ -107,7 +112,7 @@ class Building < ActiveRecord::Base
   runestone dictionary: 'english' do
     index :name
 
-    attribute(:name) { name_en }
+    attribute(:name, :name_en) { name_en }
   end
   
   runestone dictionary: 'russian' do
@@ -116,4 +121,16 @@ class Building < ActiveRecord::Base
     attribute(:name) { name_ru }
   end
 
+end
+
+class Person < ActiveRecord::Base
+
+  runestone do
+    index 'name'
+    
+    attribute :name, -> () { pooblic } do
+      name
+    end
+  end
+
 end

data/test/indexing_test.rb

@@ -84,7 +84,7 @@ class IndexingTest < ActiveSupport::TestCase
     assert_corpus('address', 'name')
   end
 
-  test 'index gets updated on Model.create' do
+  test 'index gets updated on Model.update' do
     address = Address.create(name: 'Address name')
     assert_no_difference 'Runestone::Model.count' do
       address.update!(name: 'Address name two')
@@ -106,6 +106,175 @@ class IndexingTest < ActiveSupport::TestCase
     assert_corpus('address', 'name', 'two')
   end
 
+  test 'index doesnt update on Model.update when updates dont affect index (column for attribute, depends on itself)' do
+    address = Address.create(name: 'Address name')
+    assert_no_difference 'Runestone::Model.count' do
+      assert_no_sql("UPDATE runestones SET data") do
+        address.update!(metadata: 'extra info not used in index')
+      end
+    end
+
+    assert_equal([[
+      'Address', address.id,
+      {"name" => "Address name"},
+      "'address':1A 'name':2A"
+    ]], address.runestones.map { |runestone|
+      [
+        runestone.record_type,
+        runestone.record_id,
+        runestone.data,
+        runestone.vector
+      ]
+    })
+    
+    assert_corpus('address', 'name')
+  end
+
+  test 'index doesnt update on Model.update when updates dont affect index (proc for attribute, depends on relation)' do
+    property = Property.create(name: 'Property name', addresses: [
+      Address.create(name: 'Address 1'),
+      Address.create(name: 'Address 2')
+    ])
+    
+    assert_no_difference 'Runestone::Model.count' do
+      assert_no_sql("UPDATE runestones SET data") do
+        property.update!(metadata: 'extra info not used in index')
+      end
+    end
+
+    assert_equal([[
+      'Property', property.id,
+      {"name"=>"Property name", "addresses"=>[
+        {"id"=> property.addresses[0].id, "name"=>"Address 1"},
+        {"id"=> property.addresses[1].id, "name"=>"Address 2"}
+      ]},
+      "'1':4C '2':6C 'address':3C,5C 'name':2A 'property':1A"
+    ]], property.runestones.map { |runestone|
+      [
+        runestone.record_type,
+        runestone.record_id,
+        runestone.data,
+        runestone.vector
+      ]
+    })
+
+    assert_corpus("1", "2", "address", "name", "property")
+  end
+  
+  test 'index updates on Model.update when relation is load/changed (proc for attribute, depends on relation)' do
+    property = Property.create(name: 'Property name', addresses: [
+      Address.create(name: 'Address 1'),
+      Address.create(name: 'Address 2')
+    ])
+    
+    assert_no_difference 'Runestone::Model.count' do
+      assert_sql("UPDATE runestones SET data") do
+        property.addresses.first.name = 'Address rename 1'
+        property.save
+      end
+    end
+
+    assert_equal([[
+      'Property', property.id,
+      {"name"=>"Property name", "addresses"=>[
+        {"id"=> property.addresses[0].id, "name"=>"Address 1"},
+        {"id"=> property.addresses[1].id, "name"=>"Address 2"}
+      ]},
+      "'1':4C '2':6C 'address':3C,5C 'name':2A 'property':1A"
+    ]], property.runestones.map { |runestone|
+      [
+        runestone.record_type,
+        runestone.record_id,
+        runestone.data,
+        runestone.vector
+      ]
+    })
+
+    assert_corpus("1", "2", "address", "name", "property", "rename")
+  end
+
+  test 'index doesnt update on Model.update when updates dont affect index (block for attribute, depends on attribute)' do
+    building = Building.create(name_en: 'name', name_ru: 'имя')
+    
+    assert_no_difference 'Runestone::Model.count' do
+      assert_no_sql(/UPDATE runestones\s+SET\s+data = '{"name":"имя"}/i) do
+        building.update!(name_en: 'name 2')
+      end
+    end
+
+    assert_equal([[
+        'Building', building.id,
+        {"name"=>"name 2"},
+        "'2':2A 'name':1A"
+      ], [
+        'Building', building.id,
+        {"name"=>"имя"},
+        "'имя':1A"
+      ]
+    ], building.runestones.map { |runestone|
+      [
+        runestone.record_type,
+        runestone.record_id,
+        runestone.data,
+        runestone.vector
+      ]
+    })
+    
+    assert_corpus('2', 'name', 'м')
+  end
+  
+  test 'index doesnt update on Model.update when updates dont affect index (block for attribute, block for depends)' do
+    record = Person.create(name: 'person')
+    
+    assert_no_difference 'Runestone::Model.count' do
+      assert_no_sql("UPDATE runestones SET data") do
+        record.update!(name: 'ghost', pooblic: false)
+      end
+    end
+
+    assert_equal([[
+        'Person', record.id,
+        {"name"=>"person"},
+        "'person':1A"
+      ]
+    ], record.runestones.map { |runestone|
+      [
+        runestone.record_type,
+        runestone.record_id,
+        runestone.data,
+        runestone.vector
+      ]
+    })
+    
+    assert_corpus('person')
+  end
+  
+  test 'index updates on Model.update when updates affect index (block for attribute, block for depends)' do
+    record = Person.create(name: 'person')
+    
+    assert_no_difference 'Runestone::Model.count' do
+      assert_sql("UPDATE runestones SET data") do
+        record.update!(name: 'physical', pooblic: true)
+      end
+    end
+
+    assert_equal([[
+        'Person', record.id,
+        {"name"=>"physical"},
+        "'physical':1A"
+      ]
+    ], record.runestones.map { |runestone|
+      [
+        runestone.record_type,
+        runestone.record_id,
+        runestone.data,
+        runestone.vector
+      ]
+    })
+    
+    assert_corpus('person', 'physical')
+  end
+
   test 'index gets deleted on Model.destroy' do
     address = Address.create(name: 'Address name')
     assert_difference 'Runestone::Model.count', -1 do

data/test/test_helper.rb

@@ -63,50 +63,70 @@ class ActiveSupport::TestCase
     ActiveRecord::Base.logger = nil
     $debugging = false
   end
+  
+  def assert_sql(*expected)
+    return_value = nil
+    
+    queries_ran = if block_given?
+      queries_ran = SQLLogger.log.size
+      return_value = yield if block_given?
+      SQLLogger.log[queries_ran...]
+    else
+      [expected.pop]
+    end
 
-  def capture_sql
-    # ActiveRecord::Base.connection.materialize_transactions
-    SQLLogger.clear_log
-    yield
-    SQLLogger.log_all.dup
+    failed_patterns = []
+
+    expected.each do |pattern|
+      failed_patterns << pattern unless queries_ran.any?{ |sql| sql_equal(pattern, sql) }
+    end
+
+    assert failed_patterns.empty?, <<~MSG
+      Query pattern(s) not found:
+        - #{failed_patterns.map(&:inspect).join('\n  - ')}
+
+      Queries Ran (queries_ran.size):
+        - #{queries_ran.map{|l| l.gsub(/\n\s*/, "\n    ")}.join("\n  - ")}
+    MSG
+    
+    return_value
   end
 
-  def assert_sql(*patterns_to_match)
-    if patterns_to_match.all? { |s| s.is_a?(String) }
-      assert_equal(*patterns_to_match.take(2).map { |sql| sql.gsub(/( +|\n\s*|\s+)/, ' ').strip })
-    else
-      begin
-        ret_value = nil
-        capture_sql { ret_value = yield }
-        ret_value
-      ensure
-        failed_patterns = []
-        patterns_to_match.each do |pattern|
-          failed_patterns << pattern unless SQLLogger.log_all.any?{ |sql| pattern === sql }
-        end
-        assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map(&:inspect).join(', ')} not found.#{SQLLogger.log.size == 0 ? '' : "\nQueries:\n#{SQLLogger.log.join("\n")}"}"
-      end
+  def assert_no_sql(*not_expected)
+    return_value = nil
+    queries_ran = block_given? ? SQLLogger.log.size : 0
+
+    return_value = yield if block_given?
+
+  ensure
+    failed_patterns = []
+    queries_ran = SQLLogger.log[queries_ran...]
+
+    not_expected.each do |pattern|
+      failed_patterns << pattern if queries_ran.any?{ |sql| sql_equal(pattern, sql) }
     end
+
+    assert failed_patterns.empty?, <<~MSG
+      Unexpected Query pattern(s) found:
+        - #{failed_patterns.map(&:inspect).join('\n  - ')}
+
+      Queries Ran (queries_ran.size):
+        - #{queries_ran.map{|l| l.gsub(/\n\s*/, "\n    ")}.join("\n  - ")}
+    MSG
+    
+    return_value
   end
 
-  def assert_no_sql(*patterns_to_match)
-    if patterns_to_match.all? { |s| s.is_a?(String) }
-      assert_not_equal(*patterns_to_match.take(2).map { |sql| sql.gsub(/( +|\n\s*|\s+)/, ' ').strip })
-    else
-      begin
-        ret_value = nil
-        capture_sql { ret_value = yield }
-        ret_value
-      ensure
-        failed_patterns = []
-        patterns_to_match.each do |pattern|
-          failed_patterns << pattern unless SQLLogger.log_all.any?{ |sql| pattern === sql }
-        end
-        assert !failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map(&:inspect).join(', ')} found.#{SQLLogger.log.size == 0 ? '' : "\nQueries:\n#{SQLLogger.log.join("\n")}"}"
-      end
+  def sql_equal(expected, sql)
+    sql = sql.strip.gsub(/"(\w+)"/, '\1').gsub(/\(\s+/, '(').gsub(/\s+\)/, ')').gsub(/[\s|\n]+/, ' ')
+    if expected.is_a?(String)
+      expected = Regexp.new(Regexp.escape(expected.strip.gsub(/"(\w+)"/, '\1').gsub(/\(\s+/, '(').gsub(/\s+\)/, ')').gsub(/[\s|\n]+/, ' ')), Regexp::IGNORECASE)
     end
+    
+    expected.match(sql)
   end
   
+
   def corpus
     Runestone::Model.connection.execute('SELECT word FROM runestone_corpus ORDER BY word').values.flatten
   end
@@ -157,7 +177,7 @@ class ActiveSupport::TestCase
       self.class.log_all << sql
       unless ignore =~ sql
         if $debugging
-        puts caller.select { |l| l.starts_with?(File.expand_path('../../lib', __FILE__)) }
+        puts caller.select { |l| l.start_with?(File.expand_path('../../lib', __FILE__)) }
         puts "\n\n" 
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: runestone
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: '2.1'
 platform: ruby
 authors:
 - Jon Bracy
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-25 00:00:00.000000000 Z
+date: 2024-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -128,42 +128,42 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: arel-extensions
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0.9
+        version: 7.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0.9
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
 description: PostgreSQL Full Text Search for Active Record and Rails
 email:
 - jonbracy@gmail.com
@@ -171,6 +171,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/main.yml"
 - ".gitignore"
 - ".tm_properties"
 - Gemfile
@@ -185,6 +186,7 @@ files:
 - lib/runestone/engine.rb
 - lib/runestone/indexing_job.rb
 - lib/runestone/model.rb
+- lib/runestone/psql_schema_dumper.rb
 - lib/runestone/settings.rb
 - lib/runestone/version.rb
 - lib/runestone/web_search.rb
@@ -223,7 +225,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.5.4
 signing_key:
 specification_version: 4
 summary: Full Text Search for Active Record / Rails