activerecord-refined 0.4.0 → 0.5.1

data/test/test_block_syntax.rb

@@ -2,11 +2,11 @@ require_relative 'test_helper'
 
 class TestBlockSyntax < Minitest::Test
   def test_equal
-    assert_sql(/WHERE "users"."name" = 'matz'/, User.where { :name == 'matz' }.to_sql)
+    assert_sql(/WHERE "users"."name" = 'alice'/, User.where { :name == 'alice' }.to_sql)
   end
 
   def test_not_equal
-    assert_sql(/WHERE "users"."name" != 'nobu'/, User.where { :name != 'nobu' }.to_sql)
+    assert_sql(/WHERE "users"."name" != 'bob'/, User.where { :name != 'bob' }.to_sql)
   end
 
   def test_greater_than
@@ -34,23 +34,23 @@ class TestBlockSyntax < Minitest::Test
   end
 
   def test_and
-    assert_sql(/WHERE "users"."name" = 'matz' AND "users"."age" > 18/,
-      User.where { (:name == 'matz') & (:age > 18) }.to_sql)
+    assert_sql(/WHERE "users"."name" = 'alice' AND "users"."age" > 18/,
+      User.where { (:name == 'alice') & (:age > 18) }.to_sql)
   end
 
   def test_or
-    assert_sql(/WHERE \(?\"users\".\"name\" = 'matz' OR \"users\".\"name\" = 'nobu'\)?/,
-      User.where { (:name == 'matz') | (:name == 'nobu') }.to_sql)
+    assert_sql(/WHERE \(?\"users\".\"name\" = 'alice' OR \"users\".\"name\" = 'bob'\)?/,
+      User.where { (:name == 'alice') | (:name == 'bob') }.to_sql)
   end
 
   def test_not
-    assert_sql(/WHERE NOT \(?\"users\".\"name\" = 'matz'\)?/,
-      User.where { !(:name == 'matz') }.to_sql)
+    assert_sql(/WHERE NOT \(?\"users\".\"name\" = 'alice'\)?/,
+      User.where { !(:name == 'alice') }.to_sql)
   end
 
   def test_complex_combination
-    sql = User.where { ((:name == 'matz') & (:age > 18)) | !(:name == 'nobu') }.to_sql
-    assert_sql(/"users"."name" = 'matz'/, sql)
+    sql = User.where { ((:name == 'alice') & (:age > 18)) | !(:name == 'bob') }.to_sql
+    assert_sql(/"users"."name" = 'alice'/, sql)
     assert_sql(/"users"."age" > 18/, sql)
     assert_sql(/NOT/, sql)
     assert_sql(/OR/, sql)
@@ -70,13 +70,13 @@ class TestBlockSyntax < Minitest::Test
   end
 
   def test_casecmp
-    assert_sql(/WHERE LOWER\("users"."name"\) = LOWER\('Matz'\)/,
-      User.where { :name.casecmp?('Matz') }.to_sql)
+    assert_sql(/WHERE LOWER\("users"."name"\) = LOWER\('Alice'\)/,
+      User.where { :name.casecmp?('Alice') }.to_sql)
   end
 
   def test_casecmp_qualified
-    assert_sql(/WHERE LOWER\("users"."name"\) = LOWER\('Matz'\)/,
-      User.where { :users[:name].casecmp?('Matz') }.to_sql)
+    assert_sql(/WHERE LOWER\("users"."name"\) = LOWER\('Alice'\)/,
+      User.where { :users[:name].casecmp?('Alice') }.to_sql)
   end
 
   def test_casecmp_nil_is_rejected
@@ -86,16 +86,27 @@ class TestBlockSyntax < Minitest::Test
 
   def test_casecmp_execution
     User.delete_all
-    User.create!(name: 'Matz')
-    User.create!(name: 'nobu')
-    assert_equal(['Matz'], User.where { :name.casecmp?('mAtZ') }.pluck(:name))
+    User.create!(name: 'Alice')
+    User.create!(name: 'bob')
+    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)
@@ -115,8 +126,8 @@ class TestBlockSyntax < Minitest::Test
   # of literals; matching any one of them is enough.
   def test_start_with_multiple
     assert_sql(
-      /WHERE \("users"."name" LIKE 'ma%' ESCAPE '\\' OR "users"."name" LIKE 'no%' ESCAPE '\\'\)/,
-      User.where { :name.start_with?('ma', 'no') }.to_sql)
+      /WHERE \("users"."name" LIKE 'al%' ESCAPE '\\' OR "users"."name" LIKE 'bo%' ESCAPE '\\'\)/,
+      User.where { :name.start_with?('al', 'bo') }.to_sql)
   end
 
   def test_end_with_multiple
@@ -128,8 +139,8 @@ class TestBlockSyntax < Minitest::Test
   # The OR arrives grouped, so a following & applies to the whole list.
   def test_start_with_multiple_combined
     assert_sql(
-      /WHERE \("users"."name" LIKE 'ma%' ESCAPE '\\' OR "users"."name" LIKE 'no%' ESCAPE '\\'\) AND "users"."age" > 18/,
-      User.where { :name.start_with?('ma', 'no') & (:age > 18) }.to_sql)
+      /WHERE \("users"."name" LIKE 'al%' ESCAPE '\\' OR "users"."name" LIKE 'bo%' ESCAPE '\\'\) AND "users"."age" > 18/,
+      User.where { :name.start_with?('al', 'bo') & (:age > 18) }.to_sql)
   end
 
   def test_start_with_no_arguments
@@ -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
@@ -350,11 +413,11 @@ class TestBlockSyntax < Minitest::Test
 
   def test_not_distinct_from_a_value_execution
     User.delete_all
-    User.create!(name: 'matz')
+    User.create!(name: 'alice')
     User.create!(name: nil)
-    assert_equal(['matz'], User.where { :name.not_distinct_from?('matz') }.pluck(:name))
+    assert_equal(['alice'], User.where { :name.not_distinct_from?('alice') }.pluck(:name))
     # Unlike !=, this keeps the NULL row.
-    assert_equal([nil], User.where { :name.distinct_from?('matz') }.pluck(:name))
+    assert_equal([nil], User.where { :name.distinct_from?('alice') }.pluck(:name))
   end
 
   def test_distinct_from_postgresql_syntax
@@ -421,8 +484,8 @@ class TestBlockSyntax < Minitest::Test
 
   def test_exists_combined
     assert_sql(
-      /WHERE "authors"."name" = 'matz' AND EXISTS \(SELECT "posts"\.\* FROM "posts" WHERE "posts"."title" = 'pub'\)/,
-      Author.where { (:name == 'matz') & exists?(Post.where(title: 'pub')) }.to_sql)
+      /WHERE "authors"."name" = 'alice' AND EXISTS \(SELECT "posts"\.\* FROM "posts" WHERE "posts"."title" = 'pub'\)/,
+      Author.where { (:name == 'alice') & exists?(Post.where(title: 'pub')) }.to_sql)
   end
 
   def test_exists_execution
@@ -477,8 +540,8 @@ class TestBlockSyntax < Minitest::Test
   end
 
   def test_qualified_column
-    assert_sql(/WHERE "users"."name" = 'matz'/,
-      User.where { :users[:name] == 'matz' }.to_sql)
+    assert_sql(/WHERE "users"."name" = 'alice'/,
+      User.where { :users[:name] == 'alice' }.to_sql)
   end
 
   def test_column_to_column_comparison
@@ -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
@@ -755,8 +848,8 @@ class TestBlockSyntax < Minitest::Test
   # rather than opening the condition up.
   def test_values_are_quoted
     User.delete_all
-    User.create!(name: 'matz')
-    User.create!(name: 'nobu')
+    User.create!(name: 'alice')
+    User.create!(name: 'bob')
     payload = "x' OR 1=1 --"
     assert_empty(User.where { :name == payload }.pluck(:name))
     assert_empty(User.where { :name.like?(payload) }.pluck(:name))
@@ -793,9 +886,9 @@ class TestBlockSyntax < Minitest::Test
 
   def test_scalar_functions_run
     User.delete_all
-    User.create!(name: 'matz', age: 60)
-    assert_equal(['MATZ-x'], User.select { concat(upper(:name), '-x').as(:v) }.map(&:v))
-    assert_equal([4], User.select { char_length(:name).as(:v) }.map(&:v))
+    User.create!(name: 'alice', age: 60)
+    assert_equal(['ALICE-x'], User.select { concat(upper(:name), '-x').as(:v) }.map(&:v))
+    assert_equal([5], User.select { char_length(:name).as(:v) }.map(&:v))
     assert_equal([60], User.select { greatest(:age, 18).as(:v) }.map(&:v))
   end
 
@@ -826,8 +919,8 @@ class TestBlockSyntax < Minitest::Test
       assert_raises(NotImplementedError) { User.select { format('%s!', :name) } }
     else
       User.delete_all
-      User.create!(name: 'matz')
-      assert_equal(['matz!'], User.select { format('%s!', :name).as(:v) }.map(&:v))
+      User.create!(name: 'alice')
+      assert_equal(['alice!'], User.select { format('%s!', :name).as(:v) }.map(&:v))
     end
   end
 
@@ -845,6 +938,157 @@ class TestBlockSyntax < Minitest::Test
     end
   end
 
+  # CURRENT_TIMESTAMP and its relatives are grammar rather than calls, so
+  # they come out without the parentheses PostgreSQL and SQLite reject.
+  def test_datetime_value_functions_are_emitted_bare
+    assert_sql(/SELECT CURRENT_TIMESTAMP FROM/,
+      User.select { current_timestamp }.to_sql)
+    assert_sql(/SELECT CURRENT_DATE FROM/, User.select { current_date }.to_sql)
+    assert_sql(/SELECT CURRENT_TIME FROM/, User.select { current_time }.to_sql)
+  end
+
+  def test_datetime_value_function_in_comparison_and_alias
+    assert_sql(/WHERE "users"."name" < CURRENT_TIMESTAMP/,
+      User.where { :name < current_timestamp }.to_sql)
+    assert_sql(/SELECT CURRENT_TIMESTAMP AS ts FROM/,
+      User.select { current_timestamp.as(:ts) }.to_sql)
+  end
+
+  def test_current_timestamp_runs
+    User.delete_all
+    User.create!(name: 'alice')
+    refute_nil(User.select { current_timestamp.as(:v) }.sole.v)
+  end
+
+  # The one thing that does go into the parentheses is a precision, which
+  # current_date never takes and SQLite never accepts.
+  def test_datetime_value_function_with_precision
+    if ADAPTER == 'sqlite3'
+      e = assert_raises(NotImplementedError) { User.select { current_timestamp(3) } }
+      assert_match(/precision/, e.message)
+    else
+      assert_sql(/SELECT CURRENT_TIMESTAMP\(3\) FROM/,
+        User.select { current_timestamp(3) }.to_sql)
+      assert_sql(/SELECT CURRENT_TIME\(0\) FROM/,
+        User.select { current_time(0) }.to_sql)
+      User.delete_all
+      User.create!(name: 'alice')
+      refute_nil(User.select { current_timestamp(0).as(:v) }.sole.v)
+    end
+  end
+
+  def test_current_date_takes_no_precision
+    assert_raises(ArgumentError) { User.select { current_date(0) } }
+  end
+
+  # The precision is written into the SQL as given, so only an Integer is
+  # accepted there.
+  def test_precision_must_be_an_integer
+    assert_raises(ArgumentError) do
+      User.select { current_timestamp(:'3); DROP TABLE users --') }
+    end
+  end
+
+  def test_localtime_is_unsupported_on_sqlite
+    if ADAPTER == 'sqlite3'
+      assert_raises(NotImplementedError) { User.select { localtime } }
+      assert_raises(NotImplementedError) { User.select { localtimestamp } }
+    else
+      assert_sql(/SELECT LOCALTIME FROM/, User.select { localtime }.to_sql)
+      assert_sql(/SELECT LOCALTIMESTAMP FROM/,
+        User.select { localtimestamp }.to_sql)
+    end
+  end
+
+  def test_math_functions
+    assert_sql(/SELECT SIGN\("users"."age"\)/, User.select { sign(:age) }.to_sql)
+    assert_sql(/SELECT ATAN2\("users"."age", 2\)/,
+      User.select { atan2(:age, 2) }.to_sql)
+    assert_sql(/SELECT PI\(\)/, User.select { pi }.to_sql)
+    assert_sql(/SELECT DEGREES\(RADIANS\("users"."age"\)\)/,
+      User.select { degrees(radians(:age)) }.to_sql)
+  end
+
+  def test_math_functions_run
+    User.delete_all
+    User.create!(name: 'alice', age: 60)
+    assert_equal(1, User.select { sign(:age).as(:v) }.sole.v.to_i)
+    assert_equal(60,
+      User.select { round(degrees(radians(:age))).as(:v) }.sole.v.to_i)
+  end
+
+  # PostgreSQL spells log2(x) as log(2, x), which no renaming carries.
+  def test_log2_is_unsupported_on_postgresql
+    if ADAPTER == 'postgresql'
+      assert_raises(NotImplementedError) { User.select { log2(:age) } }
+    else
+      assert_sql(/SELECT LOG2\("users"."age"\)/, User.select { log2(:age) }.to_sql)
+    end
+  end
+
+  # MySQL spells trunc TRUNCATE, and insists on the second argument the
+  # others default to zero.
+  def test_trunc
+    expected = ADAPTER == 'mysql2' ? 'TRUNCATE' : 'TRUNC'
+    assert_sql(/SELECT #{expected}\("users"."age", 0\)/,
+      User.select { trunc(:age, 0) }.to_sql)
+  end
+
+  # EXTRACT(field FROM expr): the field is a keyword rather than a value.
+  # SQLite spells all of this as strftime formats, which no renaming
+  # carries.
+  def test_extract
+    if ADAPTER == 'sqlite3'
+      e = assert_raises(NotImplementedError) { User.select { extract(:year, :name) } }
+      assert_match(/extract/, e.message)
+    else
+      assert_sql(/SELECT EXTRACT\(YEAR FROM "users"."name"\)/,
+        User.select { extract(:year, :name) }.to_sql)
+      assert_sql(/WHERE EXTRACT\(YEAR FROM "users"."name"\) = 2026/,
+        User.where { extract(:year, :name) == 2026 }.to_sql)
+    end
+  end
+
+  # A bad field is an ArgumentError on every adapter, before SQLite gets to
+  # say it has no extract at all.
+  def test_extract_rejects_an_injected_field
+    assert_raises(ArgumentError) { User.select { extract(INJECTION.to_sym, :name) } }
+  end
+
+  def test_extract_runs
+    skip "#{ADAPTER} has no extract" if ADAPTER == 'sqlite3'
+    User.delete_all
+    User.create!(name: 'alice')
+    assert_equal(2026,
+      User.select { extract(:year, cast('2026-01-05', :date)).as(:v) }.sole.v.to_i)
+  end
+
+  def test_cast
+    assert_sql(/SELECT CAST\("users"."age" AS text\)/,
+      User.select { cast(:age, :text) }.to_sql)
+  end
+
+  def test_cast_runs
+    User.delete_all
+    User.create!(name: 'alice')
+    assert_equal(12.5,
+      User.select { cast('12.5', 'decimal(10,2)').as(:v) }.sole.v.to_f)
+  end
+
+  # The type is written into the SQL as given, so it has to look like one:
+  # a plain name, at most parenthesized with lengths.  The adapters' own
+  # spellings with a space in them pass too.
+  def test_cast_type_names
+    assert_sql(/AS double precision\)/,
+      User.select { cast(:age, 'double precision') }.to_sql)
+    assert_sql(/AS decimal\(10,2\)\)/,
+      User.select { cast(:age, 'decimal(10,2)') }.to_sql)
+    assert_raises(ArgumentError) { User.select { cast(:age, INJECTION.to_sym) } }
+    assert_raises(ArgumentError) do
+      User.select { cast(:age, 'integer); DROP TABLE users --') }
+    end
+  end
+
   # A name with no method of its own is still a NoMethodError, not a
   # function call the database has to reject.
   def test_unknown_function_is_a_no_method_error
@@ -1028,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.4.0
+  version: 0.5.1
 platform: ruby
 authors:
   - Shugo Maeda
@@ -81,6 +81,7 @@ extensions: []
 extra_rdoc_files: []
 files:
   - .github/workflows/push_gem.yml
+  - .github/workflows/sandbox.yml
   - .github/workflows/test.yml
   - .gitignore
   - Gemfile