activerecord-refined 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aaf1859c70b9ca6e5c245343e664fffbd483d395266a4d442eaa0d5c4107595c
-  data.tar.gz: da1ddb190628a8a11ced1d105d0a73bf164892cf9e78dfd68db7fdf135047d95
+  metadata.gz: 3ea652837dabe0136a80b1603e2efd7a86a5ca18f966a39a112c10bb05b8f7e4
+  data.tar.gz: 791a680c4ed2d87ed61581c8c232b792ab493a9ef5bd30ddc0d1d0ca9c437ec7
 SHA512:
-  metadata.gz: 5b075b93194651859a7411d2465fec0c2d0a504eaf9da7d4d296ddea1cc91a366af68fea0b37cbea230e44da9e4bf480ecfd047571c1b49601b9bfa7c3dc2780
-  data.tar.gz: c35194020d37a97de9f5816b965f391a47c5e3d12ef7192bfd2c91ff16ea72689e122fc29daba3c6096aceac22dd7fbb535d562fe0c0ba2f3edbcbbb9904c22c
+  metadata.gz: 68bcd884eb01ab5bbc72711996e2ed96f3299b00525295c8688734f3f7110cffd2d15775b2d71c9cb78b02eb52983ddd58675ba4d80a73f76aad9042f719c479
+  data.tar.gz: f47a5b3f3f43242399e3d964c6630d08c124acdff206a9cec0cd7919e88baf9b399fe2e505e9f2296da7ddd123f0be34404646e052abad1d6a963b189d2424dd

data/README.md

@@ -723,7 +723,7 @@ three:
 
 | | PostgreSQL | SQLite | MySQL |
 | --- | --- | --- | --- |
-| `dig(: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` |
@@ -755,8 +755,11 @@ than being left to the adapters, which answer it three ways: `dig_text(:n) ==
 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.
+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
@@ -768,12 +771,14 @@ 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_text(:n)) } }
+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`.
 
@@ -796,6 +801,13 @@ 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.
 
+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:
 
@@ -818,8 +830,8 @@ 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/lib/active_record/refined/ast.rb

@@ -524,10 +524,16 @@ module ActiveRecord
       # 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.
+      # gives the value.  What bury and except give back is JSON as dig's
+      # is, and is refused the same way.
       #
       # A string against dig_text, 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|
@@ -541,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
@@ -553,7 +569,7 @@ module ActiveRecord
           return if other.is_a?(::String) && !as_json
 
           raise ArgumentError, as_json ?
-            "dig gives JSON, and comparing it with #{other.inspect} " \
+            "#{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"
@@ -567,6 +583,14 @@ 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 gives is one:
@@ -623,6 +647,11 @@ module ActiveRecord
           end
         end
 
+        private
+
+        def json_source
+          'dig'
+        end
       end
 
       # Setting a value inside a JSON document, which is what bury does to what
@@ -631,6 +660,7 @@ module ActiveRecord
       class JsonSet < Node
         include Predications
         include JsonSteps
+        include JsonComparable
 
         attr_reader :operand, :path, :value
 
@@ -640,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
@@ -664,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
@@ -686,6 +734,7 @@ module ActiveRecord
       class JsonExcept < Node
         include Predications
         include JsonSteps
+        include JsonComparable
 
         attr_reader :operand, :keys
 
@@ -694,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',
@@ -728,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.8.0'
+    VERSION = '0.8.1'
   end
 end

data/test/test_block_syntax.rb

@@ -1997,6 +1997,35 @@ class TestBlockSyntax < Minitest::Test
     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_text_from_a_qualified_column
     seed_docs
     assert_equal(['one'], Doc.where { :docs[:meta].dig_text(:a, :b) == 'deep' }.pluck(:name))
@@ -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_text(: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.8.0
+  version: 0.8.1
 platform: ruby
 authors:
   - Shugo Maeda