activerecord-refined 0.7.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9dec7847f9abff657ab248a17613b08464164fcef0780db94ab5f97de8727dd5
-  data.tar.gz: a544f3202bd459206ad8e94827b18f09f66d8da912c9ba1f130d75b5d1646e02
+  metadata.gz: 3ea652837dabe0136a80b1603e2efd7a86a5ca18f966a39a112c10bb05b8f7e4
+  data.tar.gz: 791a680c4ed2d87ed61581c8c232b792ab493a9ef5bd30ddc0d1d0ca9c437ec7
 SHA512:
-  metadata.gz: 821537f17ddd8cba223cb45b4e9b6f1bd1bc19cccb4c615686f0f16959cc615c8b3d10225b1a9e632dff291abb87291827bed1b62857648378f46b7d2e947463
-  data.tar.gz: ee7269d0bb16a09a7ec938557303e00133e96723c9341e8bbf58d890c2fd5dbffc6fa016a88bfd8383f78a32448a4522c982cefd68dde0e478e64de10c9b751a
+  metadata.gz: 68bcd884eb01ab5bbc72711996e2ed96f3299b00525295c8688734f3f7110cffd2d15775b2d71c9cb78b02eb52983ddd58675ba4d80a73f76aad9042f719c479
+  data.tar.gz: f47a5b3f3f43242399e3d964c6630d08c124acdff206a9cec0cd7919e88baf9b399fe2e505e9f2296da7ddd123f0be34404646e052abad1d6a963b189d2424dd

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,43 @@ 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, :b)` | `#> '{a,b}'` | `-> '$.a.b'` | `JSON_EXTRACT(…, '$.a.b')` |
+| `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.
+What `bury` and `except` give back is JSON as `dig`'s is, and is refused the
+same way. A column, a function or another dug value on the right goes through
+untouched; only a Ruby literal is refused. Arithmetic and the bit operators
+are refused outright on both sides — `dig_text(:n) + 1` is 6 on SQLite, an
+error on PostgreSQL and 6.0 on MariaDB — and `cast` settles those too.
 
 `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
@@ -763,8 +775,10 @@ Post.update_all { { meta: :meta.bury(:copy, :meta.dig(:n)) } }
 ```
 
 A whole document goes in as one — an object or an array rather than the string
-that spells it — which each adapter takes its own way round. `bury` is not a
-Ruby method; it is the name Ruby considered for the other end of `dig`, and
+that spells it — which each adapter takes its own way round, and a boolean
+goes in as JSON too, which SQLite would otherwise write as its `1`. `bury` is
+not a Ruby method; it is the name Ruby considered for the other end of `dig`,
+and
 SQL has no one name to borrow here, since PostgreSQL says `jsonb_set` where
 the others say `JSON_SET`.
 
@@ -787,31 +801,37 @@ 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:
+A key deeper in is reached through the chain: `dig` reads the part out,
+`except` takes the key from it, and `bury` puts it back:
+
+```ruby
+Post.update_all { { meta: :meta.bury(:author, :meta.dig(:author).except(:email)) } }
+```
+
+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
-built. On PostgreSQL, `contains?` and `key?` want a `jsonb` column; the
-`json` type carries neither operator.
+built. On PostgreSQL, `dig` and `dig_text` are all the `json` type carries;
+`key?`, `contains?`, `bury` and `except` want a `jsonb` column.
 
 A key that is not a plain name travels as itself rather than being refused:
 `dig(:'odd key')` becomes `'{odd key}'` or `$."odd key"`.

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,26 @@ 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 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.  What bury and except give back is JSON as dig's
+      # is, and is refused the same way.
       #
-      # 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.
+      # A string against dig_text, and anything the block itself built -- a
+      # column, a function, another dug value -- go through untouched.
       #
-      # A string against dig, and anything the block itself built -- a column,
-      # a function, another dug value -- go through untouched.
+      # Arithmetic and the bit operators are refused outright on both sides:
+      # `dig_text(:n) + 1` is 6 on SQLite, an error on PostgreSQL and 6.0 on
+      # MariaDB, and an expression on the right does not change what the
+      # dug side is.
       module JsonComparable
         %i[== != < <= > >=].each do |operator|
           define_method(operator) do |other|
@@ -540,6 +547,16 @@ module ActiveRecord
         def between?(min, max) = super(*check_each([min, max]))
         def not_between?(min, max) = super(*check_each([min, max]))
 
+        %i[+ - * / & | ^ << >>].each do |operator|
+          define_method(operator) do |_other|
+            raise ArgumentError, arithmetic_refusal(operator)
+          end
+        end
+
+        def ~
+          raise ArgumentError, arithmetic_refusal(:~)
+        end
+
         private
 
         # nil is left to the comparison itself, which says to use null?, and
@@ -552,9 +569,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 " \
+            "#{json_source} 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
 
@@ -566,20 +583,28 @@ module ActiveRecord
           end
           values
         end
+
+        def arithmetic_refusal(operator)
+          as_json ?
+            "#{json_source} gives JSON, and #{operator} on it means something " \
+            "different on every adapter; cast dig_text to the type meant" :
+            "dig_text gives text, and #{operator} on it means something " \
+            "different on every adapter; cast it to the type meant"
+        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,13 +640,18 @@ 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
         end
 
+        private
+
+        def json_source
+          'dig'
+        end
       end
 
       # Setting a value inside a JSON document, which is what bury does to what
@@ -630,6 +660,7 @@ module ActiveRecord
       class JsonSet < Node
         include Predications
         include JsonSteps
+        include JsonComparable
 
         attr_reader :operand, :path, :value
 
@@ -639,6 +670,11 @@ module ActiveRecord
           @value = value
         end
 
+        # Always JSON, which is what the comparison guard asks.
+        def as_json
+          true
+        end
+
         def to_arel(table, model)
           document = to_arel_operand(operand, table, model)
           if AST.adapter_family(model) == :postgresql
@@ -663,21 +699,34 @@ module ActiveRecord
           Arel::Nodes.build_quoted(JSON.generate(value))
         end
 
-        # The others take the value as it is, except a whole document, which
-        # they read out of a literal rather than take as a string.  MySQL casts
-        # to JSON where MariaDB, which answers to the same adapter, does not.
+        # The others take the value as it is, except a whole document or a
+        # boolean, which go in as JSON: taken as they are, a document would
+        # be the string that spells it, and a boolean SQLite's own 1.
+        # SQLite's json() marks the literal for JSON_SET; the MySQL family,
+        # which has no json(), reads it with JSON_EXTRACT.
         def other_value(table, model)
           return to_arel_operand(value, table, model) if expression?
-          return Arel::Nodes.build_quoted(value) unless value.is_a?(::Hash) || value.is_a?(::Array)
+          unless value.is_a?(::Hash) || value.is_a?(::Array) ||
+                 value == true || value == false
+            return Arel::Nodes.build_quoted(value)
+          end
 
-          Arel::Nodes::NamedFunction.new(
-            'JSON_EXTRACT',
-            [Arel::Nodes.build_quoted(JSON.generate(value)), Arel::Nodes.build_quoted('$')])
+          json = Arel::Nodes.build_quoted(JSON.generate(value))
+          if AST.adapter_family(model) == :sqlite
+            Arel::Nodes::NamedFunction.new('json', [json])
+          else
+            Arel::Nodes::NamedFunction.new(
+              'JSON_EXTRACT', [json, Arel::Nodes.build_quoted('$')])
+          end
         end
 
         def expression?
           value.is_a?(Node) || value.is_a?(::Symbol)
         end
+
+        def json_source
+          'bury'
+        end
       end
 
       # Keys taken out of a JSON document.  PostgreSQL subtracts them, the
@@ -685,6 +734,7 @@ module ActiveRecord
       class JsonExcept < Node
         include Predications
         include JsonSteps
+        include JsonComparable
 
         attr_reader :operand, :keys
 
@@ -693,10 +743,18 @@ module ActiveRecord
           @keys = check_keys(keys)
         end
 
+        def as_json
+          true
+        end
+
         def to_arel(table, model)
           document = to_arel_operand(operand, table, model)
-          return Arel::Nodes::InfixOperation.new(:-, document, key_array) if
-            AST.adapter_family(model) == :postgresql
+          if AST.adapter_family(model) == :postgresql
+            # Grouped because - binds tighter than #>: dug out of a document,
+            # the subtraction would otherwise take the path literal first.
+            return Arel::Nodes::InfixOperation.new(
+              :-, Arel::Nodes::Grouping.new(document), key_array)
+          end
 
           Arel::Nodes::NamedFunction.new(
             'JSON_REMOVE',
@@ -727,6 +785,10 @@ module ActiveRecord
           end
           keys
         end
+
+        def json_source
+          'except'
+        end
       end
 
       # JSON containment: whether the document holds what is given.

data/lib/activerecord-refined/version.rb

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

data/test/test_block_syntax.rb

@@ -1891,115 +1891,144 @@ 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
+
+  # What bury and except give back is JSON as dig's is, so the same guard
+  # covers them; an expression on the right still goes through.
+  def test_bury_and_except_refuse_a_comparison_with_a_ruby_value
+    e = assert_raises(ArgumentError) { Doc.where { :meta.bury(:a, 1) == '{"a": 1}' } }
+    assert_match(/bury gives JSON/, e.message)
+    e = assert_raises(ArgumentError) { Doc.where { :meta.except(:a) == '{"b": 2}' } }
+    assert_match(/except gives JSON/, e.message)
+    assert_raises(ArgumentError) { Doc.where { :meta.except(:a).in?(['{}']) } }
+    assert_sql(/ = /, Doc.where { :meta.except(:a) == :meta.except(:b) })
+  end
+
+  # Arithmetic is refused like a literal comparison is: text plus one is 6
+  # on SQLite, an error on PostgreSQL and 6.0 on MariaDB.  cast settles it,
+  # and an expression on the right changes nothing about the dug side.
+  def test_arithmetic_is_refused_on_a_dug_value
+    e = assert_raises(ArgumentError) { Doc.select { :meta.dig_text(:n) + 1 } }
+    assert_match(/cast it to the type meant/, e.message)
+    e = assert_raises(ArgumentError) { Doc.select { :meta.dig(:n) * 2 } }
+    assert_match(/dig gives JSON/, e.message)
+    assert_raises(ArgumentError) { Doc.select { :meta.dig_text(:n) + :name } }
+    assert_raises(ArgumentError) { Doc.select { :meta.bury(:a, 1) - 1 } }
+    assert_raises(ArgumentError) { Doc.select { ~:meta.dig(:n) } }
+    seed_docs
+    type = integer_type
+    assert_equal(6,
+      Doc.where { :name == 'one' }.
+        select { (cast(:meta.dig_text(:n), type) + 1).as(:v) }.first.v.to_i)
   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 +2051,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
 
@@ -2277,13 +2306,27 @@ class TestBlockSyntax < Minitest::Test
     assert_equal([1, 2], buried { { meta: :meta.bury(:arr, [1, 2]) } }['arr'])
   end
 
+  # A boolean goes in as JSON too: taken as it is, SQLite would write its 1.
+  def test_bury_a_boolean
+    assert_equal(true, buried { { meta: :meta.bury(:flag, true) } }['flag'])
+    assert_equal(false, buried { { meta: :meta.bury(:flag, false) } }['flag'])
+  end
+
+  def test_bury_a_null
+    document = buried { { meta: :meta.bury(:gone, nil) } }
+    assert(document.key?('gone'))
+    assert_nil(document['gone'])
+  end
+
   def test_bury_an_array_index
     assert_equal(%w[7 y], buried { { meta: :meta.bury(:tags, 0, '7') } }['tags'])
   end
 
-  # The value can be read out of the document it is going into.
+  # The value can be read out of the document it is going into: dig keeps
+  # the number a number, dig_text makes it the text of one.
   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(:n)) } }['copy'])
+    assert_equal('5', buried { { meta: :meta.bury(:copy, :meta.dig_text(:n)) } }['copy'])
   end
 
   # It is an expression, so it does not have to be written anywhere.
@@ -2306,6 +2349,13 @@ class TestBlockSyntax < Minitest::Test
       buried { { meta: :meta.except(:n) } })
   end
 
+  # A key deeper in is reached through the chain: dig reads the part out,
+  # except takes the key from it, and bury puts it back.  The dug document
+  # needs its parentheses on PostgreSQL, where - binds tighter than #>.
+  def test_except_a_nested_key_through_the_chain
+    assert_equal({}, buried { { meta: :meta.bury(:a, :meta.dig(:a).except(:b)) } }['a'])
+  end
+
   def test_except_several_keys
     assert_equal({ 'a' => { 'b' => 'deep' } },
       buried { { meta: :meta.except(:n, :tags, :'odd key') } })

metadata

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