activerecord-refined 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9dec7847f9abff657ab248a17613b08464164fcef0780db94ab5f97de8727dd5
-  data.tar.gz: a544f3202bd459206ad8e94827b18f09f66d8da912c9ba1f130d75b5d1646e02
+  metadata.gz: aaf1859c70b9ca6e5c245343e664fffbd483d395266a4d442eaa0d5c4107595c
+  data.tar.gz: da1ddb190628a8a11ced1d105d0a73bf164892cf9e78dfd68db7fdf135047d95
 SHA512:
-  metadata.gz: 821537f17ddd8cba223cb45b4e9b6f1bd1bc19cccb4c615686f0f16959cc615c8b3d10225b1a9e632dff291abb87291827bed1b62857648378f46b7d2e947463
-  data.tar.gz: ee7269d0bb16a09a7ec938557303e00133e96723c9341e8bbf58d890c2fd5dbffc6fa016a88bfd8383f78a32448a4522c982cefd68dde0e478e64de10c9b751a
+  metadata.gz: 5b075b93194651859a7411d2465fec0c2d0a504eaf9da7d4d296ddea1cc91a366af68fea0b37cbea230e44da9e4bf480ecfd047571c1b49601b9bfa7c3dc2780
+  data.tar.gz: c35194020d37a97de9f5816b965f391a47c5e3d12ef7192bfd2c91ff16ea72689e122fc29daba3c6096aceac22dd7fbb535d562fe0c0ba2f3edbcbbb9904c22c

data/README.md

@@ -706,11 +706,14 @@ Author.select { sum(case_when { :age >= 60 }.then(1).else(0)).as(:seniors) }
 ### JSON
 
 `dig` reads inside a JSON document, by the name of what `Hash` does. A string
-or symbol steps into an object, an integer into an array:
+or symbol steps into an object, an integer into an array, and what comes back
+is still JSON — the way `Hash#dig` hands back the structure itself — for a
+document to be dug into further or asked the JSON questions. `dig_text` gives
+the value as text instead, which is what a comparison wants:
 
 ```ruby
-Post.where { :meta.dig(:author, :name) == 'alice' }
-Post.select { :meta.dig(:tags, 0).as(:first_tag) }
+Post.where { :meta.dig_text(:author, :name) == 'alice' }
+Post.select { :meta.dig(:author).as(:author) }
 Post.where { :meta.key?(:draft) }
 Post.where { :meta.contains?(status: 'open') }
 ```
@@ -720,34 +723,40 @@ three:
 
 | | PostgreSQL | SQLite | MySQL |
 | --- | --- | --- | --- |
-| `dig(:a, :b)` | `#>> '{a,b}'` | `->> '$.a.b'` | `JSON_UNQUOTE(JSON_EXTRACT(…, '$.a.b'))` |
-| `dig_json(:a)` | `#> '{a}'` | `-> '$.a'` | `JSON_EXTRACT(…, '$.a')` |
+| `dig(:a)` | `#> '{a}'` | `-> '$.a'` | `JSON_EXTRACT(…, '$.a')` |
+| `dig_text(:a, :b)` | `#>> '{a,b}'` | `->> '$.a.b'` | `JSON_UNQUOTE(JSON_EXTRACT(…, '$.a.b'))` |
 | `key?(:a)` | `jsonb_exists(…, 'a')` | `json_type(…, '$.a') IS NOT NULL` | `JSON_CONTAINS_PATH(…, 'one', '$.a')` |
 | `contains?(…)` | `@>` | — | `JSON_CONTAINS` |
 
 MariaDB answers to the `mysql2` adapter and has none of `->` or `->>`, so the
 MySQL family goes through the functions, which both have.
 
-`dig` gives text everywhere. SQLite's `->>` would otherwise hand back the value
-with its type, so a comparison that worked there would fail on the other two;
-a number is compared through a `cast` on all three:
+`dig_text` gives text everywhere. SQLite's `->>` would otherwise hand back the
+value with its type, so a comparison that worked there would fail on the other
+two; a number is compared through a `cast` on all three:
 
 ```ruby
-Post.where { :meta.dig(:n) == '5' }
-Post.where { cast(:meta.dig(:n), 'integer') > 6 }   # 'signed' on MySQL
+Post.where { :meta.dig_text(:n) == '5' }
+Post.where { cast(:meta.dig_text(:n), 'integer') > 6 }   # 'signed' on MySQL
 ```
 
 The type is the adapter's own name for it, here as everywhere `cast` is used.
 
+Strings and numbers are where the adapters agree. A JSON boolean comes back as
+`"1"` on SQLite, which turns `true` into SQL's `1` before the text cast, and
+as `"true"` on the other two; a JSON `null` is SQL `NULL` everywhere but
+MariaDB, which spells it `"null"`. A key that is not there is `NULL` on all
+three.
+
 Comparing a dug value with anything but a string raises `ArgumentError` rather
-than being left to the adapters, which answer it three ways: `dig(:n) == 5` is
-true on SQLite, an error on PostgreSQL and true on MySQL, and
-`dig(:flag) == true` is true, an error and false. `cast` is what says which
-type was meant, and then all three agree. `dig_json` is refused the other way
-about — the JSON for a string carries its quotes, so `dig_json(:name) ==
-'alice'` is false, an error and true — and `dig` is the one that gives the
-value. A column, a function or another dug value on the right goes through
-untouched; only a Ruby literal is refused.
+than being left to the adapters, which answer it three ways: `dig_text(:n) ==
+5` is true on SQLite, an error on PostgreSQL and true on MySQL, and
+`dig_text(:flag) == true` is true, an error and false. `cast` is what says
+which type was meant, and then all three agree. `dig` is refused the other way
+about — the JSON for a string carries its quotes, so `dig(:name) == 'alice'`
+is false, an error and true — and `dig_text` is the one that gives the value.
+A column, a function or another dug value on the right goes through untouched;
+only a Ruby literal is refused.
 
 `bury` sets what `dig` reads: the last argument is the value and the rest are
 the path to it. The document comes back changed rather than being written
@@ -759,7 +768,7 @@ Post.update_all { { meta: :meta.bury(:author, :name, 'alice') } }
 # ...          JSON_SET("meta", '$.author.name', 'alice')   elsewhere
 
 Post.update_all { { meta: :meta.bury(:tags, ['ruby', 'sql']) } }
-Post.update_all { { meta: :meta.bury(:copy, :meta.dig(:n)) } }
+Post.update_all { { meta: :meta.bury(:copy, :meta.dig_text(:n)) } }
 ```
 
 A whole document goes in as one — an object or an array rather than the string
@@ -787,26 +796,25 @@ keys, an element by index — and an array literal written without a type is
 read as the first of them, so `"meta" - '{draft}'` takes out the key spelled
 `{draft}`, which is nothing, and says nothing about it.
 
-`dig_json` keeps the JSON, for a document to be dug into further or compared
-whole — so the JSON operations read what it gives, which is the same question
-asked of a part of the document rather than of all of it:
+What `dig` gives is a document, so the JSON operations read it — the same
+question asked of a part of the document rather than of all of it:
 
 ```ruby
-Post.where { :meta.dig_json(:author).key?(:email) }
-Post.where { :meta.dig_json(:author).dig(:name) == 'alice' }
-Post.update_all { { meta: :meta.dig_json(:author).bury(:name, 'alice') } }
+Post.where { :meta.dig(:author).key?(:email) }
+Post.where { :meta.dig(:author).dig_text(:name) == 'alice' }
+Post.update_all { { meta: :meta.dig(:author).bury(:name, 'alice') } }
 ```
 
 Containment reads it too, on the adapters that have containment at all:
 
 ```ruby
-Post.where { :meta.dig_json(:tags).contains?(['ruby']) }
+Post.where { :meta.dig(:tags).contains?(['ruby']) }
 ```
 
-Asking the same of `dig` raises `ArgumentError`: what it gives is text, and
-reading text back as a document is where the adapters part company — SQLite
-parses it, MySQL takes it as written, and PostgreSQL has no such function for
-text at all.
+Asking the same of `dig_text` raises `ArgumentError`: what it gives is text,
+and reading text back as a document is where the adapters part company —
+SQLite parses it, MySQL takes it as written, and PostgreSQL has no such
+function for text at all.
 
 `contains?` has no equivalent on SQLite and raises `NotImplementedError`
 there — later than the rest, since the adapter is only known when the SQL is

data/examples/json.rb

@@ -30,45 +30,45 @@ def show(title, relation, rows = nil)
   puts
 end
 
-# 1. Reading.  dig takes the path Hash#dig takes: a string or symbol steps
-#    into an object, an integer into an array.  What comes back is the value
-#    rather than the JSON around it, which is what a comparison wants.
-show('dig reads a value out of the document',
-  Document.select { [:name, :meta.dig(:author, :name).as(:author)] },
-  Document.select { [:name, :meta.dig(:author, :name).as(:author)] }.
+# 1. Reading.  dig_text takes the path Hash#dig takes: a string or symbol
+#    steps into an object, an integer into an array.  What comes back is the
+#    value rather than the JSON around it, which is what a comparison wants.
+show('dig_text reads a value out of the document',
+  Document.select { [:name, :meta.dig_text(:author, :name).as(:author)] },
+  Document.select { [:name, :meta.dig_text(:author, :name).as(:author)] }.
     map {|d| [d.name, d.author] })
 
 show('an integer steps into an array',
-  Document.select { [:name, :meta.dig(:tags, 0).as(:first_tag)] },
-  Document.select { [:name, :meta.dig(:tags, 0).as(:first_tag)] }.
+  Document.select { [:name, :meta.dig_text(:tags, 0).as(:first_tag)] },
+  Document.select { [:name, :meta.dig_text(:tags, 0).as(:first_tag)] }.
     map {|d| [d.name, d.first_tag] })
 
 # A dug value is an expression like any other, so it compares and orders.
-show('dig in a condition',
-  Document.where { :meta.dig(:author, :country) == 'JP' },
-  Document.where { :meta.dig(:author, :country) == 'JP' }.pluck(:name))
+show('dig_text in a condition',
+  Document.where { :meta.dig_text(:author, :country) == 'JP' },
+  Document.where { :meta.dig_text(:author, :country) == 'JP' }.pluck(:name))
 
 # A dug value is text, so a number goes through a cast.  Comparing it with
 # one instead is refused rather than left to the adapters, which answer that
 # three ways: true here, an error on PostgreSQL, true on MySQL.
 show('a number wants a cast',
-  Document.where { cast(:meta.dig(:views), 'integer') > 100 },
-  Document.where { cast(:meta.dig(:views), 'integer') > 100 }.pluck(:name))
+  Document.where { cast(:meta.dig_text(:views), 'integer') > 100 },
+  Document.where { cast(:meta.dig_text(:views), 'integer') > 100 }.pluck(:name))
 
 begin
-  Document.where { :meta.dig(:views) > 100 }
+  Document.where { :meta.dig_text(:views) > 100 }
 rescue ArgumentError => e
   puts '--- and without one it says so ---'
   puts "  #{e.message}"
   puts
 end
 
-# dig_json keeps the JSON, for a part of the document to be dug into further
-# or compared whole.  The quotes around the string are the sign of it -- and
-# the reason a Ruby value is refused on this side too.
-show('dig_json keeps the JSON',
-  Document.select { [:name, :meta.dig_json(:author).as(:author)] },
-  Document.select { [:name, :meta.dig_json(:author).as(:author)] }.
+# dig keeps the JSON, for a part of the document to be dug into further
+# or asked the JSON questions.  The quotes around the string are the sign of
+# it -- and the reason a Ruby value is refused on this side too.
+show('dig keeps the JSON',
+  Document.select { [:name, :meta.dig(:author).as(:author)] },
+  Document.select { [:name, :meta.dig(:author).as(:author)] }.
     map {|d| [d.name, d.author] })
 
 # 2. Asking whether a key is there at all, which is not the same as asking

data/lib/active_record/refined/ast.rb

@@ -217,15 +217,16 @@ module ActiveRecord
 
         # Reading inside a JSON document, by the name of what Hash does.  A
         # string or symbol steps into an object, an integer into an array, and
-        # what comes back is the value rather than the JSON, since that is what
-        # a comparison wants.  dig_json keeps it JSON, for a document to be dug
-        # into further or compared whole.
+        # what comes back is still JSON, the way Hash#dig hands back the
+        # structure itself -- for a document to be dug into further or asked
+        # the JSON questions.  dig_text gives the value as text instead,
+        # which is what a comparison wants.
         def dig(*path)
-          JsonPath.new(self, path)
+          JsonPath.new(self, path, as_json: true)
         end
 
-        def dig_json(*path)
-          JsonPath.new(self, path, as_json: true)
+        def dig_text(*path)
+          JsonPath.new(self, path)
         end
 
         # Keys taken out of a JSON document, by the name of what Hash does,
@@ -513,20 +514,20 @@ module ActiveRecord
       #
       # The path is turned into a string either way, so a key with a space or
       # a quote in it travels as itself rather than having to be refused.
-      # What a dug value may be compared with.  dig gives text on every
+      # What a dug value may be compared with.  dig_text gives text on every
       # adapter, and what a text value compared with a number means is a
-      # question the three answer three ways: `dig(:n) == 5` is true on
+      # question the three answer three ways: `dig_text(:n) == 5` is true on
       # SQLite, an error on PostgreSQL and true on MySQL, while
-      # `dig(:flag) == true` is true, an error, and false.  cast is what says
-      # which type was meant, and then all three agree.
+      # `dig_text(:flag) == true` is true, an error, and false.  cast is what
+      # says which type was meant, and then all three agree.
       #
-      # dig_json is refused the other way about: the JSON for a string carries
-      # its quotes, so `dig_json(:name) == 'alice'` is false on SQLite, an
-      # error on PostgreSQL and true on MySQL.  dig is the one that gives the
-      # value.
+      # dig is refused the other way about: the JSON for a string carries
+      # its quotes, so `dig(:name) == 'alice'` is false on SQLite, an
+      # error on PostgreSQL and true on MySQL.  dig_text is the one that
+      # gives the value.
       #
-      # A string against dig, and anything the block itself built -- a column,
-      # a function, another dug value -- go through untouched.
+      # A string against dig_text, and anything the block itself built -- a
+      # column, a function, another dug value -- go through untouched.
       module JsonComparable
         %i[== != < <= > >=].each do |operator|
           define_method(operator) do |other|
@@ -552,9 +553,9 @@ module ActiveRecord
           return if other.is_a?(::String) && !as_json
 
           raise ArgumentError, as_json ?
-            "dig_json gives JSON, and comparing it with #{other.inspect} " \
-            "means something different on every adapter; dig gives the value" :
-            "dig gives text, and comparing it with #{other.inspect} means " \
+            "dig gives JSON, and comparing it with #{other.inspect} " \
+            "means something different on every adapter; dig_text gives the value" :
+            "dig_text gives text, and comparing it with #{other.inspect} means " \
             "something different on every adapter; cast it to the type meant"
         end
 
@@ -568,18 +569,18 @@ module ActiveRecord
         end
       end
 
-      # The JSON operations read a document, and what dig_json gives is one:
-      # `dig_json(:author).key?(:email)` and `dig_json(:tags).contains?(...)`
-      # are the same question asked of a part of it, and the adapters answer
-      # them alike.  What dig gives is text, and reading that as a document
+      # The JSON operations read a document, and what dig gives is one:
+      # `dig(:author).key?(:email)` and `dig(:tags).contains?(...)` are the
+      # same question asked of a part of it, and the adapters answer them
+      # alike.  What dig_text gives is text, and reading that as a document
       # again is where they part company: SQLite parses it back and MySQL
       # takes it as written, where PostgreSQL has no such function for text.
       module JsonDocument
-        %i[dig dig_json key? contains? bury except].each do |name|
+        %i[dig dig_text key? contains? bury except].each do |name|
           define_method(name) do |*args|
             unless as_json
               raise ArgumentError,
-                "dig gives text, and #{name} reads JSON; dig_json keeps it"
+                "dig_text gives text, and #{name} reads JSON; dig keeps it"
             end
             super(*args)
           end
@@ -615,8 +616,8 @@ module ActiveRecord
             extracted = Arel::Nodes::InfixOperation.new(
               as_json ? :"->" : :"->>", document, Arel::Nodes.build_quoted(dollar_path))
             # SQLite's ->> gives back the value with its type, where the other
-            # two give text.  Cast so that `dig(:n) == '5'` means the same
-            # thing everywhere, and a number wants a cast everywhere too.
+            # two give text.  Cast so that `dig_text(:n) == '5'` means the
+            # same thing everywhere, and a number wants a cast everywhere too.
             as_json ? extracted : Arel::Nodes::NamedFunction.new(
               'CAST', [Arel::Nodes::As.new(extracted, Arel::Nodes::SqlLiteral.new('text'))])
           end

data/lib/activerecord-refined/version.rb

@@ -1,5 +1,5 @@
 module Activerecord
   module Refined
-    VERSION = '0.7.0'
+    VERSION = '0.8.0'
   end
 end

data/test/test_block_syntax.rb

@@ -1891,115 +1891,115 @@ class TestBlockSyntax < Minitest::Test
     Doc.create!(name: 'two', meta: json_document({ 'n' => 9 }))
   end
 
-  def test_dig_a_key
+  def test_dig_text_a_key
     seed_docs
-    assert_equal(%w[5 9], Doc.order(:name).select { :meta.dig(:n).as(:v) }.map(&:v))
+    assert_equal(%w[5 9], Doc.order(:name).select { :meta.dig_text(:n).as(:v) }.map(&:v))
   end
 
-  def test_dig_a_path
+  def test_dig_text_a_path
     seed_docs
     assert_equal(['deep', nil],
-      Doc.order(:name).select { :meta.dig(:a, :b).as(:v) }.map(&:v))
+      Doc.order(:name).select { :meta.dig_text(:a, :b).as(:v) }.map(&:v))
   end
 
-  def test_dig_an_array_index
+  def test_dig_text_an_array_index
     seed_docs
     assert_equal(['x', nil],
-      Doc.order(:name).select { :meta.dig(:tags, 0).as(:v) }.map(&:v))
+      Doc.order(:name).select { :meta.dig_text(:tags, 0).as(:v) }.map(&:v))
   end
 
   # A key that is not a plain name travels as itself rather than being refused.
-  def test_dig_a_key_that_needs_quoting
+  def test_dig_text_a_key_that_needs_quoting
     seed_docs
     assert_equal(['1', nil],
-      Doc.order(:name).select { :meta.dig(:'odd key').as(:v) }.map(&:v))
+      Doc.order(:name).select { :meta.dig_text(:'odd key').as(:v) }.map(&:v))
   end
 
-  # dig gives text on every adapter -- SQLite's ->> would otherwise give the
+  # dig_text gives text on every adapter -- SQLite's ->> would otherwise give the
   # value with its type -- so a number is compared through a cast.
-  def test_dig_is_text_everywhere
+  def test_dig_text_is_text_everywhere
     seed_docs
-    assert_equal(['one'], Doc.where { :meta.dig(:n) == '5' }.pluck(:name))
+    assert_equal(['one'], Doc.where { :meta.dig_text(:n) == '5' }.pluck(:name))
     type = integer_type
-    assert_equal(['two'], Doc.where { cast(:meta.dig(:n), type) > 6 }.pluck(:name))
+    assert_equal(['two'], Doc.where { cast(:meta.dig_text(:n), type) > 6 }.pluck(:name))
   end
 
-  def test_dig_json_keeps_the_json
+  def test_dig_keeps_the_json
     seed_docs
-    value = Doc.where { :name == 'one' }.select { :meta.dig_json(:tags).as(:v) }.first.v
+    value = Doc.where { :name == 'one' }.select { :meta.dig(:tags).as(:v) }.first.v
     assert_equal(%w[x y], value.is_a?(String) ? JSON.parse(value) : value)
   end
 
   # What text compared with a number means is a question the three adapters
-  # answer three ways -- `dig(:n) == 5` is true on SQLite, an error on
-  # PostgreSQL and true on MySQL, and `dig(:flag) == true` is true, an error
+  # answer three ways -- `dig_text(:n) == 5` is true on SQLite, an error on
+  # PostgreSQL and true on MySQL, and `dig_text(:flag) == true` is true, an error
   # and false -- so the comparison is refused rather than left to them.
-  def test_dig_refuses_a_comparison_with_anything_but_text
-    e = assert_raises(ArgumentError) { Doc.where { :meta.dig(:n) == 5 } }
+  def test_dig_text_refuses_a_comparison_with_anything_but_text
+    e = assert_raises(ArgumentError) { Doc.where { :meta.dig_text(:n) == 5 } }
     assert_match(/cast/, e.message)
-    assert_raises(ArgumentError) { Doc.where { :meta.dig(:n) != 5 } }
-    assert_raises(ArgumentError) { Doc.where { :meta.dig(:n) > 6 } }
-    assert_raises(ArgumentError) { Doc.where { :meta.dig(:flag) == true } }
-    assert_raises(ArgumentError) { Doc.where { :meta.dig(:n).in?([1, 2]) } }
-    assert_raises(ArgumentError) { Doc.where { :meta.dig(:n).between?(1, 9) } }
+    assert_raises(ArgumentError) { Doc.where { :meta.dig_text(:n) != 5 } }
+    assert_raises(ArgumentError) { Doc.where { :meta.dig_text(:n) > 6 } }
+    assert_raises(ArgumentError) { Doc.where { :meta.dig_text(:flag) == true } }
+    assert_raises(ArgumentError) { Doc.where { :meta.dig_text(:n).in?([1, 2]) } }
+    assert_raises(ArgumentError) { Doc.where { :meta.dig_text(:n).between?(1, 9) } }
   end
 
   # A string is what a dug value compares to; so is anything the block built
   # rather than wrote as a literal, since that is nobody's guess to make.
-  def test_dig_compares_with_text_and_with_expressions
+  def test_dig_text_compares_with_text_and_with_expressions
     seed_docs
-    assert_equal(['one'], Doc.where { :meta.dig(:n) == '5' }.pluck(:name))
-    assert_equal([], Doc.where { :meta.dig(:n) == :name }.pluck(:name))
-    assert_equal(['one'], Doc.where { :meta.dig(:n) == upper('5') }.pluck(:name))
+    assert_equal(['one'], Doc.where { :meta.dig_text(:n) == '5' }.pluck(:name))
+    assert_equal([], Doc.where { :meta.dig_text(:n) == :name }.pluck(:name))
+    assert_equal(['one'], Doc.where { :meta.dig_text(:n) == upper('5') }.pluck(:name))
     type = integer_type
-    assert_equal(['one'], Doc.where { cast(:meta.dig(:n), type) == 5 }.pluck(:name))
+    assert_equal(['one'], Doc.where { cast(:meta.dig_text(:n), type) == 5 }.pluck(:name))
   end
 
   # The JSON for a string carries its quotes, so the same comparison is
   # refused the other way about: false on SQLite, an error on PostgreSQL and
   # true on MySQL.
-  def test_dig_json_refuses_a_comparison_with_a_ruby_value
-    e = assert_raises(ArgumentError) { Doc.where { :meta.dig_json(:a) == 'deep' } }
-    assert_match(/dig gives the value/, e.message)
-    assert_raises(ArgumentError) { Doc.where { :meta.dig_json(:n) == 5 } }
+  def test_dig_refuses_a_comparison_with_a_ruby_value
+    e = assert_raises(ArgumentError) { Doc.where { :meta.dig(:a) == 'deep' } }
+    assert_match(/dig_text gives the value/, e.message)
+    assert_raises(ArgumentError) { Doc.where { :meta.dig(:n) == 5 } }
   end
 
-  # What dig_json gives is a document, so the JSON operations read it: the
+  # What dig gives is a document, so the JSON operations read it: the
   # same question asked of a part rather than of the whole.
-  def test_the_json_operations_read_what_dig_json_kept
+  def test_the_json_operations_read_what_dig_kept
     seed_docs
-    assert_equal(['one'], Doc.where { :meta.dig_json(:a).key?(:b) }.pluck(:name))
-    assert_equal(%w[one two], Doc.where { :meta.dig_json(:n).not_null? }.order(:name).pluck(:name))
+    assert_equal(['one'], Doc.where { :meta.dig(:a).key?(:b) }.pluck(:name))
+    assert_equal(%w[one two], Doc.where { :meta.dig(:n).not_null? }.order(:name).pluck(:name))
     assert_equal(['one'],
-      Doc.where { :meta.dig_json(:a).dig(:b) == 'deep' }.pluck(:name))
+      Doc.where { :meta.dig(:a).dig_text(:b) == 'deep' }.pluck(:name))
     value = Doc.where { :name == 'one' }.
-      select { :meta.dig_json(:a).bury(:b, 'x').as(:v) }.first.v
+      select { :meta.dig(:a).bury(:b, 'x').as(:v) }.first.v
     assert_equal('x', (value.is_a?(String) ? JSON.parse(value) : value)['b'])
   end
 
-  def test_containment_reads_what_dig_json_kept
+  def test_containment_reads_what_dig_kept
     skip_without_json_containment
     seed_docs
-    assert_equal(['one'], Doc.where { :meta.dig_json(:tags).contains?(['x']) }.pluck(:name))
-    assert_equal([], Doc.where { :meta.dig_json(:tags).contains?(['z']) }.pluck(:name))
+    assert_equal(['one'], Doc.where { :meta.dig(:tags).contains?(['x']) }.pluck(:name))
+    assert_equal([], Doc.where { :meta.dig(:tags).contains?(['z']) }.pluck(:name))
   end
 
   # Reading text back as a document is where the adapters part company:
   # SQLite parses it, MySQL takes it as written, PostgreSQL has no such
   # function for text at all.
   def test_the_json_operations_are_refused_on_a_dug_value
-    e = assert_raises(ArgumentError) { Doc.where { :meta.dig(:a).key?(:b) } }
-    assert_match(/dig_json keeps it/, e.message)
-    assert_raises(ArgumentError) { Doc.where { :meta.dig(:a).contains?(b: 1) } }
-    assert_raises(ArgumentError) { Doc.select { :meta.dig(:a).dig(:b) } }
-    assert_raises(ArgumentError) { Doc.select { :meta.dig(:a).dig_json(:b) } }
-    assert_raises(ArgumentError) { Doc.select { :meta.dig(:a).bury(:b, 'x') } }
-    assert_raises(ArgumentError) { Doc.select { :meta.dig(:a).except(:b) } }
+    e = assert_raises(ArgumentError) { Doc.where { :meta.dig_text(:a).key?(:b) } }
+    assert_match(/dig keeps it/, e.message)
+    assert_raises(ArgumentError) { Doc.where { :meta.dig_text(:a).contains?(b: 1) } }
+    assert_raises(ArgumentError) { Doc.select { :meta.dig_text(:a).dig_text(:b) } }
+    assert_raises(ArgumentError) { Doc.select { :meta.dig_text(:a).dig(:b) } }
+    assert_raises(ArgumentError) { Doc.select { :meta.dig_text(:a).bury(:b, 'x') } }
+    assert_raises(ArgumentError) { Doc.select { :meta.dig_text(:a).except(:b) } }
   end
 
-  def test_dig_from_a_qualified_column
+  def test_dig_text_from_a_qualified_column
     seed_docs
-    assert_equal(['one'], Doc.where { :docs[:meta].dig(:a, :b) == 'deep' }.pluck(:name))
+    assert_equal(['one'], Doc.where { :docs[:meta].dig_text(:a, :b) == 'deep' }.pluck(:name))
   end
 
   def test_key
@@ -2022,7 +2022,7 @@ class TestBlockSyntax < Minitest::Test
 
   def test_dig_needs_a_path
     assert_raises(ArgumentError) { Doc.select { :meta.dig } }
-    e = assert_raises(ArgumentError) { Doc.select { :meta.dig(1.5) } }
+    e = assert_raises(ArgumentError) { Doc.select { :meta.dig_text(1.5) } }
     assert_match(/key or an array index/, e.message)
   end
 
@@ -2283,7 +2283,7 @@ class TestBlockSyntax < Minitest::Test
 
   # The value can be read out of the document it is going into.
   def test_bury_an_expression
-    assert_equal('5', buried { { meta: :meta.bury(:copy, :meta.dig(:n)) } }['copy'].to_s)
+    assert_equal('5', buried { { meta: :meta.bury(:copy, :meta.dig_text(:n)) } }['copy'].to_s)
   end
 
   # It is an expression, so it does not have to be written anywhere.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-refined
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
   - Shugo Maeda