activerecord-refined 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba52b9c3529288eeedb0f5ca06a28284669f5a89027d2e372155108f0447ecc1
-  data.tar.gz: bb6d96021512a8891577781aa8e2abb14c2dc7cb8716423270ce0ccd074ed8c9
+  metadata.gz: 98f198f59d3bb4b6f4c51a16940d4e7ee44b890aa7e033a327a650b73cb3dfbd
+  data.tar.gz: 5fb7cdd8964b82d6bb14ffdfecf1400ea875f1c5bc12d7fa4645c431caf47d19
 SHA512:
-  metadata.gz: db9e3ca29892b86f19af39e59e7a52ff987b187df8cb03249ab3456f5bc16ce7d6570b7309f77f28d9600e9aeb21f3c6874b27a63e86d0efeed13bc567f07d9a
-  data.tar.gz: 3d65a461bab4a0c204702be0f532769c6fe7fafaa8106ea4e33994355b3fd3049ed2c5195f53460e9a9749007b5a133c7405ffdcd61485f3d07824e3fa686f9b
+  metadata.gz: 5ea7a29d21b31e3bf5f262a54eacb8e4e27590d9031f560d8de635da958cf91e6c5ef0872e77caf7b4e32907d2985f13fcd2ff8492ffbeda0edff1d8b7f658f4
+  data.tar.gz: 4949bb4ce9b0e4cd0f964e7f2759460a72707734a56d746cbf1221f80f9f7a87161c4a494c0226b880d7ad905e6c83933b29254c5ce3e59c41de415339557f56

data/.github/workflows/sandbox.yml

@@ -129,7 +129,7 @@ jobs:
             sandbox/config.json
             ${{ steps.r2.outputs.uploaded != 'true' && 'sandbox/ruby.wasm' || '' }}
             sandbox/rb
-            sandbox/vendor/browser.umd.js
+            sandbox/assets
           if-no-files-found: ignore
           retention-days: 7
 

data/README.md

@@ -87,6 +87,24 @@ Author.where { :country.in?(%w[JP US]) }    # IN
 Author.where { :country.null? }             # IS NULL
 ```
 
+`!` negates any of these. Where SQL has a negative of its own, so does the
+block, which is the same rows written the way they would be written by hand:
+
+```ruby
+Author.where { :country.not_null? }             # IS NOT NULL
+Author.where { :country.not_in?(%w[JP US]) }    # NOT IN
+Author.where { :age.not_between?(20, 40) }      # not between 20 and 40
+Author.where { :name.not_like?('A%') }          # NOT LIKE
+Author.where { :name.not_ilike?('a%') }         # NOT ILIKE / NOT LIKE
+
+Author.where { !:name.start_with?('A') }        # NOT (name LIKE 'A%')
+```
+
+Nothing turns on the choice: `NOT (country IS NULL)` and `country IS NOT NULL`
+select the same rows, NULLs included. `not_between?` is the one whose SQL
+looks unlike its name — Arel writes it as the two comparisons, `age < 20 OR
+age > 40`, which is again the same rows.
+
 `in?` also takes a relation as a subquery. Without an explicit select list the
 subquery selects the relation's primary key, the same way ActiveRecord's own
 `where(id: relation)` does:
@@ -247,23 +265,53 @@ ActiveRecord's `with` and `with_recursive` need nothing from this gem: a CTE
 is joined by name like any other table, so its `ON` clause is a block, where
 Rails' own documentation reaches for a string join.
 
-`from` takes the CTE's name as a symbol, with `as` to select it under the
-model's own table name so the model's columns resolve:
+`from_cte` takes the CTE's name and selects it under the model's own table
+name, so the model's columns resolve:
 
 ```ruby
 Node.with_recursive(
   tree: [
-    Node.where { :id == root.id },
-    Node.joins(:tree) { :nodes[:parent_id] == :tree[:id] },
+    Node.where { :id == root.id }.
+      select { [:id, :name, :parent_id, 0.as(:depth)] },
+    Node.joins(:tree) { :nodes[:parent_id] == :tree[:id] }.
+      select { [:nodes[:id], :nodes[:name], :nodes[:parent_id],
+                (:tree[:depth] + 1).as(:depth)] },
   ]
-).from(:tree, as: :nodes)
+).from_cte(:tree)
 # WITH RECURSIVE "tree" AS (
-#   SELECT "nodes".* FROM "nodes" WHERE "nodes"."id" = 1
+#   SELECT "nodes"."id", "nodes"."name", "nodes"."parent_id", 0 AS depth
+#     FROM "nodes" WHERE "nodes"."id" = 1
 #   UNION ALL
-#   SELECT "nodes".* FROM "nodes" INNER JOIN "tree" ON "nodes"."parent_id" = "tree"."id"
+#   SELECT "nodes"."id", "nodes"."name", "nodes"."parent_id",
+#          ("tree"."depth" + 1) AS depth
+#     FROM "nodes" INNER JOIN "tree" ON "nodes"."parent_id" = "tree"."id"
 # ) SELECT "nodes".* FROM "tree" AS "nodes"
 ```
 
+The anchor starts the count and the recursive member adds one, which is how
+the shape of a tree comes out of a flat table. The `0` is a value rather than
+SQL — see [`value`](#aggregates-functions-and-aliases) below for why a number
+can say `.as` directly.
+
+The alias on the last line is there for ActiveRecord's sake, not SQL's:
+written by hand that line would be `SELECT * FROM tree`. ActiveRecord goes on qualifying
+columns with the model's table name, so without the alias that name is not in
+the query and anything qualifying a column fails:
+
+```ruby
+Node.with_recursive(tree: [...]).from(:tree).where(name: 'root')
+# PG::UndefinedTable: missing FROM-clause entry for table "nodes"
+```
+
+Since the model's name is the only one that works, `from_cte` takes it from
+the model rather than asking. `from(:tree, as: :nodes)` is the same thing
+spelled out, and is what to reach for when the name wanted is not the model's.
+
+What makes this worth spelling out is how selectively it breaks. `count`,
+`order` and `select` never qualify, so they work without the alias on every
+adapter; it is `where` and `find_by` that stop. A query can therefore look
+right until the day a condition is added to it.
+
 A non-recursive CTE joins the same way:
 
 ```ruby
@@ -358,6 +406,29 @@ written into the SQL as given — so those two have to be plain names,
 optionally qualified by a schema in `fn`'s case. Anything else raises
 `ArgumentError` rather than reaching the query.
 
+One place asks for a value to be said out loud: the top of a select list.
+Everywhere else a bare literal is already a value — `where { :age > 18 }`,
+`concat(:name, '-x')` — but ActiveRecord reads a string in `select` as SQL,
+so `value` is how you ask for the other meaning. It carries the predications
+and arithmetic with it, so a literal can be compared and combined like
+anything else. Numbers have a shorthand, since nothing else could be meant by
+one:
+
+```ruby
+Node.select { [:id, value(0).as(:depth)] }
+# SELECT "nodes"."id", 0 AS depth FROM "nodes"
+
+Node.select { [:id, 0.as(:depth)] }         # the same thing
+
+Post.select { [:title, value('draft').as(:state)] }
+# SELECT "posts"."title", 'draft' AS state FROM "posts"
+```
+
+The shorthand is `Integer` and `Float` only. `String` keeps its two meanings —
+SQL in a select list, a value everywhere else — and refining it would make the
+same literal mean one thing or the other depending on whether it had been sent
+a message.
+
 `fn` reaches functions without a method of their own. Its name is emitted as
 written, so a case-sensitive one can be spelled exactly:
 

data/activerecord-refined.gemspec

@@ -13,8 +13,9 @@ Gem::Specification.new do |gem|
   gem.homepage      = 'https://github.com/shugo/activerecord-refined'
 
   # sandbox/ is a site, not part of the library: its Gemfile.lock and
-  # package-lock.json have no business in anyone's bundle.
-  gem.files         = `git ls-files`.split($/).grep_v(%r{^sandbox/})
+  # package-lock.json have no business in anyone's bundle.  CLAUDE.md is
+  # addressed to whoever is working on the repository, not to anyone using it.
+  gem.files         = `git ls-files`.split($/).grep_v(%r{^sandbox/|^CLAUDE\.md$})
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]

data/examples/ctes.rb

@@ -31,23 +31,54 @@ Product.create!(name: 'apple', category_id: groceries.id, price: 2)
 
 # 1. Recursive CTE: every category below 'electronics', itself included.
 #    The recursive member joins the CTE by name, so its ON clause is a block
-#    rather than the string join Rails' own documentation reaches for.  `from`
-#    then selects the CTE under the model's table name, which is what lets
-#    Category's own columns resolve against it.
+#    rather than the string join Rails' own documentation reaches for.
+#    `from_cte` then selects the CTE under the model's table name.
+#
+#    That alias is ActiveRecord's requirement rather than SQL's: by hand the
+#    last line would be `SELECT * FROM tree`.  ActiveRecord keeps qualifying
+#    columns with the model's table name, so without it `where` and `find_by`
+#    look for a table the query does not have.  `count`, `order` and `select`
+#    never qualify and would work either way, which makes it easy to miss.
 subtree =
   Category.with_recursive(
     tree: [
       Category.where { :id == electronics.id },
       Category.joins(:tree) { :categories[:parent_id] == :tree[:id] },
     ]
-  ).from(:tree, as: :categories)
+  ).from_cte(:tree)
 
 puts '--- 1. Recursive CTE walking a category tree ---'
 puts subtree.to_sql
 puts subtree.order { :name }.pluck(:name).inspect
 puts
 
-# 2. The same CTE as a subquery: products anywhere under 'electronics'.
+# 2. One walk over every tree, carrying down where each row started and how
+#    far it has come.  Which tree is wanted is then an ordinary `where`, asked
+#    afterwards, so the CTE is not rebuilt for each root.  0 is a value rather
+#    than SQL: at the top of a select list a bare string would be SQL, so
+#    numbers say `.as` directly and anything else says `value(...).as`.
+forest =
+  Category.with_recursive(
+    tree: [
+      Category.where { :parent_id.null? }.
+        select { [:id, :name, :parent_id, :id.as(:root_id), 0.as(:depth)] },
+      Category.joins(:tree) { :categories[:parent_id] == :tree[:id] }.
+        select { [:categories[:id], :categories[:name], :categories[:parent_id],
+                  :tree[:root_id], (:tree[:depth] + 1).as(:depth)] },
+    ]
+  ).from_cte(:tree).order { [:depth, :id] }
+
+puts '--- 2. Recursive CTE carrying the root and the depth down ---'
+puts forest.to_sql
+puts forest.map {|c| [c.name, c.root_id, c.depth] }.inspect
+
+# The alias from_cte puts on the CTE is what lets this `where` qualify
+# root_id; without it the column would be looked for in a table the query no
+# longer has.
+puts forest.where { :root_id == electronics.id }.map {|c| [c.name, c.depth] }.inspect
+puts
+
+# 3. The same CTE as a subquery: products anywhere under 'electronics'.
 #    The outer query joins the CTE by name like any other table.
 products_below =
   Product.with_recursive(
@@ -57,12 +88,12 @@ products_below =
     ]
   ).joins(:tree) { :tree[:id] == :products[:category_id] }
 
-puts '--- 2. Recursive CTE joined from the outer query ---'
+puts '--- 3. Recursive CTE joined from the outer query ---'
 puts products_below.to_sql
 puts products_below.order { :name }.pluck(:name).inspect
 puts
 
-# 3. A plain CTE, named once and used twice: categories that hold something
+# 4. A plain CTE, named once and used twice: categories that hold something
 #    expensive, and the count of products in each.
 expensive =
   Category.with(pricey: Product.where { :price >= 100 }).
@@ -76,7 +107,7 @@ expensive =
       ]
     }
 
-puts '--- 3. Plain CTE joined and aggregated ---'
+puts '--- 4. Plain CTE joined and aggregated ---'
 puts expensive.to_sql
 puts expensive.map {|c| [c.category, c.pricey_count, c.top_price] }.inspect
 puts

data/lib/active_record/refined/ast.rb

@@ -63,26 +63,50 @@ module ActiveRecord
           Match.new(self, pattern, negated: true)
         end
 
+        # `!` negates any predicate, so these are here for the four that SQL
+        # spells for itself: IS NOT NULL rather than NOT (... IS NULL), and
+        # likewise NOT IN and NOT LIKE.  They mean the same thing either way,
+        # including when the column is NULL; what they save is the reading.
         def null?
           Comparison.new(self, :==, nil)
         end
 
+        def not_null?
+          Comparison.new(self, :!=, nil)
+        end
+
         def in?(values)
           In.new(self, values)
         end
 
+        def not_in?(values)
+          In.new(self, values, negated: true)
+        end
+
         def between?(min, max)
           In.new(self, min..max)
         end
 
+        def not_between?(min, max)
+          In.new(self, min..max, negated: true)
+        end
+
         def like?(pattern)
           Like.new(self, pattern)
         end
 
+        def not_like?(pattern)
+          Like.new(self, pattern, negated: true)
+        end
+
         def ilike?(pattern)
           Like.new(self, pattern, nil, case_sensitive: false)
         end
 
+        def not_ilike?(pattern)
+          Like.new(self, pattern, nil, case_sensitive: false, negated: true)
+        end
+
         # Case-insensitive equality, folded on both sides rather than left to
         # the collation, so it means the same thing on every adapter.
         def casecmp?(value)
@@ -246,6 +270,29 @@ module ActiveRecord
         end
       end
 
+      # A literal standing where an expression would: `select { value(0).as(:depth) }`.
+      #
+      # Values reach the SQL quoted wherever they appear as an operand, but the
+      # top of a select list is ActiveRecord's, and a bare string there is SQL
+      # rather than a string.  Saying `value` is how you ask for the other
+      # meaning, and it carries the predications with it, so a literal can be
+      # compared and combined like anything else.
+      class Value < Node
+        include Predications
+        include Arithmetics
+        include Aggregations
+
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
+        end
+
+        def to_arel(_table)
+          Arel::Nodes.build_quoted(value)
+        end
+      end
+
       class Column < Node
         include Predications
         include Arithmetics
@@ -482,19 +529,21 @@ module ActiveRecord
       # IN for a list of values, BETWEEN for a range, IN (SELECT ...) for a
       # relation.
       class In < Predicate
-        attr_reader :operand, :values
+        attr_reader :operand, :values, :negated
 
-        def initialize(operand, values)
+        def initialize(operand, values, negated: false)
           @operand = operand
           @values = values
+          @negated = negated
         end
 
         def to_arel(table)
           arel_operand = to_arel_operand(operand, table)
-          case values
-          when Range then arel_operand.between(values)
-          when ActiveRecord::Relation then arel_operand.in(subquery(values))
-          else arel_operand.in(values)
+          if values.is_a?(Range)
+            arel_operand.public_send(negated ? :not_between : :between, values)
+          else
+            arg = values.is_a?(ActiveRecord::Relation) ? subquery(values) : values
+            arel_operand.public_send(negated ? :not_in : :in, arg)
           end
         end
 
@@ -555,19 +604,23 @@ module ActiveRecord
             inject {|left, right| Or.new(left, right) }
         end
 
-        attr_reader :operand, :pattern, :escape, :case_sensitive
+        attr_reader :operand, :pattern, :escape, :case_sensitive, :negated
 
-        def initialize(operand, pattern, escape = nil, case_sensitive: true)
+        def initialize(operand, pattern, escape = nil, case_sensitive: true,
+                       negated: false)
           @operand = operand
           @pattern = pattern
           @escape = escape
           @case_sensitive = case_sensitive
+          @negated = negated
         end
 
         def to_arel(table)
           # Arel matches case-insensitively unless told otherwise, which is
           # what picks ILIKE over LIKE on PostgreSQL.
-          to_arel_operand(operand, table).matches(pattern, escape, case_sensitive)
+          to_arel_operand(operand, table).
+            public_send(negated ? :does_not_match : :matches,
+                        pattern, escape, case_sensitive)
         end
       end
 

data/lib/active_record/refined.rb

@@ -22,6 +22,18 @@ module ActiveRecord
           AST::Column.new(self, column_name)
         end
       end
+
+      # Shorthand for `value(0).as(:depth)` and the like.  Numbers only: a
+      # string in a select list already means SQL rather than a string, so
+      # giving String this would make the same literal mean two things
+      # depending on whether it had been sent a message.
+      [Integer, Float].each do |klass|
+        refine klass do
+          def as(alias_name)
+            AST::As.new(AST::Value.new(self), alias_name)
+          end
+        end
+      end
     end
 
     class BlockContext
@@ -164,6 +176,17 @@ module ActiveRecord
         AST::Exists.new(relation)
       end
 
+      # A literal where an expression is expected, quoted like any other value:
+      #
+      #   select { [:id, value(0).as(:depth)] }
+      #
+      # Needed because the top of a select list is ActiveRecord's, and a bare
+      # string there is SQL rather than a string.  Numbers have a shorthand --
+      # `0.as(:depth)` -- since nothing else could be meant by one.
+      def value(literal)
+        AST::Value.new(literal)
+      end
+
       private
 
       def function_name(name, functions)
@@ -230,9 +253,8 @@ module ActiveRecord
       end
 
       # A symbol names a table, which ActiveRecord's own from only takes as a
-      # string.  With `as` it is selected under another name, which is how a
-      # CTE stands in for the model's own table:
-      # with_recursive(tree: [...]).from(:tree, as: :nodes)
+      # string.  With `as` it is selected under another name; when that name
+      # is the model's own, from_cte says the same thing without repeating it.
       def from(value, subquery_name = nil, as: nil)
         unless value.is_a?(Symbol)
           if as
@@ -245,6 +267,18 @@ module ActiveRecord
         super(arel_table, subquery_name)
       end
 
+      # Selects a CTE in place of the model's own table.  The alias is not a
+      # choice -- ActiveRecord keeps qualifying columns with the table name,
+      # so the model's is the only name that works -- which is why it is
+      # taken from the model rather than asked for:
+      # with_recursive(tree: [...]).from_cte(:tree)
+      def from_cte(name)
+        unless name.is_a?(Symbol)
+          raise ArgumentError, "from_cte takes the CTE's name as a symbol"
+        end
+        from(name, as: klass.table_name)
+      end
+
       # `as` names the table within the query, which is what makes a self
       # join expressible: joins(:employees, as: :managers) { ... }.
       def joins(*args, as: nil, &block)

data/lib/activerecord-refined/version.rb

@@ -1,5 +1,5 @@
 module Activerecord
   module Refined
-    VERSION = '0.5.0'
+    VERSION = '0.5.1'
   end
 end

data/lib/activerecord-refined.rb

@@ -5,3 +5,7 @@ require 'active_record/refined/ast'
 require 'active_record/refined'
 
 ActiveRecord::QueryMethods.prepend ActiveRecord::Refined::QueryMethods
+
+# The methods above are ActiveRecord's own, so a model already forwards them
+# to its relation.  from_cte is new, and has to be added to that list itself.
+ActiveRecord::Base.singleton_class.delegate :from_cte, to: :all

data/test/test_block_syntax.rb

@@ -91,11 +91,22 @@ class TestBlockSyntax < Minitest::Test
     assert_equal(['Alice'], User.where { :name.casecmp?('aLiCe') }.pluck(:name))
   end
 
-  def test_not_like
+  def test_bang_negates_like
     assert_sql(/WHERE NOT \("users"."name" LIKE 'tender%'\)/,
       User.where { !:name.like?('tender%') }.to_sql)
   end
 
+  def test_not_like
+    assert_sql(/WHERE "users"."name" NOT LIKE 'tender%'/,
+      User.where { :name.not_like?('tender%') }.to_sql)
+  end
+
+  def test_not_ilike
+    expected = ADAPTER == 'postgresql' ? 'ILIKE' : 'LIKE'
+    assert_sql(/WHERE "users"."name" NOT #{expected} 'tender%'/,
+      User.where { :name.not_ilike?('tender%') }.to_sql)
+  end
+
   def test_start_with
     assert_sql(/WHERE "users"."name" LIKE 'tender%' ESCAPE '\\'/,
       User.where { :name.start_with?('tender') }.to_sql)
@@ -298,11 +309,23 @@ class TestBlockSyntax < Minitest::Test
       User.where { :age.in?(18...65) }.to_sql)
   end
 
-  def test_not_between
+  def test_bang_negates_between
     assert_sql(/WHERE NOT \("users"."age" BETWEEN 18 AND 65\)/,
       User.where { !:age.between?(18, 65) }.to_sql)
   end
 
+  # Arel spells the negation as the two comparisons rather than NOT BETWEEN,
+  # which is the same set of rows, NULLs included.
+  def test_not_between
+    assert_sql(/WHERE \("users"."age" < 18 OR "users"."age" > 65\)/,
+      User.where { :age.not_between?(18, 65) }.to_sql)
+  end
+
+  def test_not_in_range
+    assert_sql(/WHERE \("users"."age" < 18 OR "users"."age" > 65\)/,
+      User.where { :age.not_in?(18..65) }.to_sql)
+  end
+
   def test_is_null
     assert_sql(/WHERE "users"."name" IS NULL/,
       User.where { :name.null? }.to_sql)
@@ -313,6 +336,36 @@ class TestBlockSyntax < Minitest::Test
       User.where { :users[:name].null? }.to_sql)
   end
 
+  def test_is_not_null
+    assert_sql(/WHERE "users"."name" IS NOT NULL/,
+      User.where { :name.not_null? }.to_sql)
+  end
+
+  def test_is_not_null_qualified
+    assert_sql(/WHERE "users"."name" IS NOT NULL/,
+      User.where { :users[:name].not_null? }.to_sql)
+  end
+
+  # The claim these methods rest on: the direct spelling is the same rows as
+  # negating the positive one, which is where a NULL would show a difference
+  # if there were one.
+  def test_the_negations_match_what_bang_selects
+    User.delete_all
+    User.create!(name: 'alice', age: 60)
+    User.create!(name: 'bob', age: 20)
+    User.create!(name: nil, age: 40)
+    [
+      [-> { :name.not_null? },          -> { !:name.null? }],
+      [-> { :age.not_in?([20, 30]) },   -> { !:age.in?([20, 30]) }],
+      [-> { :age.not_between?(20, 30) }, -> { !:age.between?(20, 30) }],
+      [-> { :name.not_like?('a%') },    -> { !:name.like?('a%') }],
+    ].each do |direct, negated|
+      assert_equal(User.where(&negated).pluck(:id).sort,
+                   User.where(&direct).pluck(:id).sort,
+                   "#{direct.source_location} did not match the ! form")
+    end
+  end
+
   def test_equal_nil_is_rejected
     e = assert_raises(ArgumentError) { User.where { :name == nil } }
     assert_match(/null\?/, e.message)
@@ -333,11 +386,21 @@ class TestBlockSyntax < Minitest::Test
       User.where { :users[:age].in?([1, 2, 3]) }.to_sql)
   end
 
-  def test_not_in
+  def test_bang_negates_in
     assert_sql(/WHERE NOT \("users"."age" IN \(1, 2, 3\)\)/,
       User.where { !:age.in?([1, 2, 3]) }.to_sql)
   end
 
+  def test_not_in
+    assert_sql(/WHERE "users"."age" NOT IN \(1, 2, 3\)/,
+      User.where { :age.not_in?([1, 2, 3]) }.to_sql)
+  end
+
+  def test_not_in_qualified
+    assert_sql(/WHERE "users"."age" NOT IN \(1, 2, 3\)/,
+      User.where { :users[:age].not_in?([1, 2, 3]) }.to_sql)
+  end
+
   # Spelled IS [NOT] DISTINCT FROM on PostgreSQL, IS / IS NOT on SQLite and
   # <=> on MySQL, so only the resulting rows are portable.
   def test_not_distinct_from_execution
@@ -547,6 +610,36 @@ class TestBlockSyntax < Minitest::Test
     assert_raises(ArgumentError) { Node.from('tree', as: :nodes) }
   end
 
+  def test_from_cte_takes_the_alias_from_the_model
+    assert_sql(/FROM "tree" (?:AS )?"nodes"/, Node.from_cte(:tree).to_sql)
+    assert_equal(Node.from(:tree, as: :nodes).to_sql, Node.from_cte(:tree).to_sql)
+  end
+
+  def test_from_cte_needs_a_symbol
+    assert_raises(ArgumentError) { Node.from_cte('tree') }
+  end
+
+  # The alias is what lets a where find its column, which is the whole reason
+  # from_cte exists; without it the SQL names a table the query does not have.
+  def test_from_cte_leaves_where_able_to_qualify
+    Node.delete_all
+    root = Node.create!(name: 'root')
+    Node.create!(name: 'child', parent_id: root.id)
+    other = Node.create!(name: 'other root')
+    Node.create!(name: 'other child', parent_id: other.id)
+    forest = Node.with_recursive(
+      tree: [
+        Node.where { :parent_id.null? }.
+          select { [:id, :name, :parent_id, :id.as(:root_id)] },
+        Node.joins(:tree) { :nodes[:parent_id] == :tree[:id] }.
+          select { [:nodes[:id], :nodes[:name], :nodes[:parent_id],
+                    :tree[:root_id]] },
+      ]
+    ).from_cte(:tree)
+    assert_equal(%w[child root],
+      forest.where { :root_id == root.id }.pluck(:name).sort)
+  end
+
   # A CTE is joined by name like any other table, so the recursive member's
   # ON clause is a block rather than the string join Rails' own docs use.
   def test_recursive_cte
@@ -1179,4 +1272,71 @@ class TestBlockSyntax < Minitest::Test
     assert_sql(/WHERE "users"."name" = 'Ruby' AND "users"."age" = 19/,
       User.where(name: 'Ruby', age: 19).to_sql)
   end
+
+  def test_value_in_a_select_list
+    assert_sql(/SELECT "users"."name", 0 AS depth/,
+      User.select { [:name, value(0).as(:depth)] }.to_sql)
+  end
+
+  # Each adapter escapes the apostrophe its own way, so what is asserted is
+  # that the string stays a value rather than reaching the SQL as written.
+  def test_value_is_quoted
+    User.delete_all
+    User.create!(name: 'alice')
+    payload = "it's a value"
+    assert_sql(/SELECT 'draft' AS state/,
+      User.select { value('draft').as(:state) }.to_sql)
+    assert_equal([payload],
+      User.select { value(payload).as(:note) }.map(&:note))
+  end
+
+  def test_a_bare_string_is_still_sql
+    assert_sql(/SELECT "users"."name", 1 \+ 1 AS two/,
+      User.select { [:name, '1 + 1 AS two'] }.to_sql)
+  end
+
+  def test_value_takes_the_predications
+    assert_sql(/WHERE 1 = "users"."age"/, User.where { value(1) == :users[:age] }.to_sql)
+    assert_sql(/WHERE 1 IS NULL/, User.where { value(1).null? }.to_sql)
+  end
+
+  def test_value_takes_the_arithmetics
+    assert_sql(/SELECT \(1 \+ "users"."age"\) AS next_year/,
+      User.select { (value(1) + :age).as(:next_year) }.to_sql)
+  end
+
+  def test_value_as_a_function_argument
+    assert_sql(/SELECT COALESCE\("users"."age", 0\)/,
+      User.select { coalesce(:age, value(0)) }.to_sql)
+  end
+
+  def test_integer_shorthand_for_value
+    assert_sql(/SELECT "users"."name", 0 AS depth/,
+      User.select { [:name, 0.as(:depth)] }.to_sql)
+  end
+
+  def test_float_shorthand_for_value
+    assert_sql(/SELECT 1\.5 AS rate/, User.select { 1.5.as(:rate) }.to_sql)
+  end
+
+  def test_numeric_shorthand_has_no_orderings
+    assert_raises(NoMethodError) { User.order { 1.asc } }
+    assert_raises(NoMethodError) { User.order { 1.desc } }
+  end
+
+  def test_value_alias_rejects_an_injected_name
+    assert_raises(ArgumentError) { User.select { value(0).as(INJECTION.to_sym) } }
+    assert_raises(ArgumentError) { User.select { 0.as(INJECTION.to_sym) } }
+  end
+
+  def test_a_value_selected_reaches_the_row
+    User.delete_all
+    User.create!(name: 'alice', age: 60)
+    assert_equal([['alice', 0]],
+      User.select { [:name, 0.as(:depth)] }.map {|u| [u.name, u.depth] })
+  end
+
+  def test_numeric_shorthand_is_confined_to_the_block
+    assert_raises(NoMethodError) { 0.as(:depth) }
+  end
 end

metadata

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