activerecord-refined 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3818aa9d45162578a7a0f01eae7b45f943e2a2b1708ec689cd7ba484af9011e
-  data.tar.gz: 27674049c82ce8ba096f6a9416b603b25c97d326cb3ea78e557b43ffe76b25a0
+  metadata.gz: ba52b9c3529288eeedb0f5ca06a28284669f5a89027d2e372155108f0447ecc1
+  data.tar.gz: bb6d96021512a8891577781aa8e2abb14c2dc7cb8716423270ce0ccd074ed8c9
 SHA512:
-  metadata.gz: 6a3d6b39152e68a21a21a14abd1092484eb335137a182db8068396ef7fa98ca17bd4bb152b0b028bc3ef2e1de17e8d257dcdb03a57cf093a650f387196e22ee9
-  data.tar.gz: 5e44084905b8c8d22bdde49aad72ceab1b22b1be4e139e8f60237a134a05c258413503595af0f49409ac19923ed296ecbd3f7c075c64b20e6e61f8c2100e5dd3
+  metadata.gz: db9e3ca29892b86f19af39e59e7a52ff987b187df8cb03249ab3456f5bc16ce7d6570b7309f77f28d9600e9aeb21f3c6874b27a63e86d0efeed13bc567f07d9a
+  data.tar.gz: 3d65a461bab4a0c204702be0f532769c6fe7fafaa8106ea4e33994355b3fd3049ed2c5195f53460e9a9749007b5a133c7405ffdcd61485f3d07824e3fa686f9b

data/.github/workflows/sandbox.yml

@@ -0,0 +1,158 @@
+name: sandbox
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: sandbox-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: sandbox
+
+    steps:
+      - uses: actions/checkout@v7
+
+      # The host Ruby cannot be 4.1: ruby_wasm's native extension depends on
+      # rb-sys, which does not build against Ruby 4.1's headers.  rbwasm is
+      # only a build tool -- the Ruby it produces is the one that matters.
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '4.0'
+          bundler-cache: false
+          working-directory: sandbox
+
+      - uses: actions/setup-node@v7
+        with:
+          node-version: '24'
+
+      # The Ruby checkout and the build tree have to be cached together.  make
+      # decides by mtime, so restoring objects next to a freshly cloned Ruby
+      # would rebuild everything.
+      #
+      # The build directory is keyed on the gems that have C extensions, so
+      # Gemfile.lock covers it; RUBY_REV is pinned in bin/build-wasm, and the
+      # staged extension comes from ext/ and the sqlite3 gem.
+      #
+      # restore-keys is what keeps this worth caching -- a key change would
+      # otherwise mean a cold 16-minute build rather than two minutes -- but it
+      # also means a bad tree outlives the key that produced it, since the
+      # prefix still matches.  Editing a file in the key does not clear it;
+      # deleting the cache does.  bin/build-wasm rejects a ruby.wasm built from
+      # such a tree, so it fails the run rather than shipping.
+      - name: Restore the WASM build tree
+        uses: actions/cache@v6
+        with:
+          path: sandbox/build
+          key: wasm-${{ runner.os }}-${{ hashFiles('sandbox/Gemfile.lock', 'sandbox/bin/build-wasm', 'sandbox/ext/**') }}
+          restore-keys: wasm-${{ runner.os }}-
+
+      - run: bundle install --jobs 4
+      - run: npm ci
+
+      - name: Build ruby.wasm
+        run: ./bin/build-wasm
+
+      - name: Assemble the Ruby files served to the page
+        run: ./bin/prepare-rb
+
+      # Runs every example through the same WASI shim the page uses.  The
+      # larger stack is needed to compile ActiveRecord's relation.rb; see the
+      # note in sandbox/README.md.
+      - name: Check the examples
+        run: node --stack-size=4000 check-examples.mjs
+
+      # ruby.wasm is 40 MB, which a Cloudflare Pages asset may not be and which
+      # is nearly all of the bandwidth this page uses, so it is served from R2
+      # -- egress there is free -- and only the page itself from Pages.
+      #
+      # The key carries a hash of the binary, so a rebuild lands on a new URL
+      # and nothing has to be purged.  R2 serves what it is given and does not
+      # compress, hence gzip with the encoding recorded on the object: 40 MB
+      # becomes 12 MB on the wire.
+      #
+      # Without the secrets configured the upload is skipped and ruby.wasm
+      # rides along in the Pages artifact as before, which keeps forks working.
+      # Uploaded over R2's S3-compatible API rather than with wrangler, so that
+      # the token can be an Object Read & Write one scoped to this bucket.
+      # Those permissions exist only on the S3 API: wrangler goes through
+      # Cloudflare's REST API, which answers 403 to them and wants Admin Read &
+      # Write -- a token that can create and delete every bucket in the
+      # account, which is not what a public repository's CI should hold.
+      - name: Upload ruby.wasm to R2
+        id: r2
+        if: github.ref == 'refs/heads/master' && vars.R2_PUBLIC_URL != ''
+        env:
+          AWS_ACCESS_KEY_ID: ${{ secrets.R2_ACCESS_KEY_ID }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.R2_SECRET_ACCESS_KEY }}
+          AWS_DEFAULT_REGION: auto
+          # R2 sends no checksum headers back, which newer AWS CLIs insist on.
+          AWS_REQUEST_CHECKSUM_CALCULATION: when_required
+          AWS_RESPONSE_CHECKSUM_VALIDATION: when_required
+        run: |
+          gzip -9 -c ruby.wasm > /tmp/ruby.wasm.gz
+
+          # One key, overwritten each time, since only the newest build is of
+          # any use.  That rules out caching it as immutable: the URL no longer
+          # changes with the contents, so a long max-age would go on serving
+          # the previous binary.  Five minutes bounds how stale a visitor's
+          # copy can be just after a deploy, and revalidation costs a 304
+          # rather than 12 MB.
+          aws s3api put-object \
+            --endpoint-url "https://${{ secrets.CLOUDFLARE_ACCOUNT_ID }}.r2.cloudflarestorage.com" \
+            --bucket "${{ vars.R2_BUCKET }}" \
+            --key ruby-head.wasm \
+            --body /tmp/ruby.wasm.gz \
+            --content-type application/wasm \
+            --content-encoding gzip \
+            --cache-control "public, max-age=300" \
+            --no-cli-pager
+
+          echo '{"rubyWasmUrl":"${{ vars.R2_PUBLIC_URL }}/ruby-head.wasm"}' > config.json
+          echo "uploaded=true" >> "$GITHUB_OUTPUT"
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: sandbox
+          path: |
+            sandbox/index.html
+            sandbox/boot.rb
+            sandbox/examples.js
+            sandbox/manifest.json
+            sandbox/config.json
+            ${{ steps.r2.outputs.uploaded != 'true' && 'sandbox/ruby.wasm' || '' }}
+            sandbox/rb
+            sandbox/vendor/browser.umd.js
+          if-no-files-found: ignore
+          retention-days: 7
+
+  deploy:
+    if: github.ref == 'refs/heads/master'
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      pages: write
+      id-token: write
+    environment:
+      name: github-pages
+      url: ${{ steps.deploy.outputs.page_url }}
+
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          name: sandbox
+          path: site
+
+      - uses: actions/configure-pages@v6
+      - uses: actions/upload-pages-artifact@v5
+        with:
+          path: site
+      - id: deploy
+        uses: actions/deploy-pages@v5

data/README.md

@@ -14,6 +14,10 @@ Author.
 #   WHERE "authors"."age" BETWEEN 20 AND 40 AND "posts"."published" = TRUE
 ```
 
+**[Try it in your browser](https://shugo.github.io/activerecord-refined/)** —
+Ruby 4.1, ActiveRecord and SQLite run in the page, so the examples build real
+SQL and return real rows without a `ruby-master` build of your own.
+
 ## History
 
 This gem was formerly known as **activerecord-refinements**, created by Akira Matsuda
@@ -41,6 +45,10 @@ works again without monkey-patching `Symbol` globally.
 * Ruby 4.1 or later (for `Proc#refined`; not released yet, so a `ruby-master` build is needed for now)
 * ActiveRecord 7.0 or later
 
+The [sandbox](https://shugo.github.io/activerecord-refined/) is there to skip
+that build: it carries its own Ruby 4.1. `sandbox/` in this repository is what
+it is made of.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -118,7 +126,7 @@ collation, so it means the same thing everywhere:
 
 ```ruby
 Author.where { :name.ilike?('ma%') }        # ILIKE 'ma%' / LIKE 'ma%'
-Author.where { :name.casecmp?('Matz') }     # LOWER(name) = LOWER('Matz')
+Author.where { :name.casecmp?('Alice') }     # LOWER(name) = LOWER('Alice')
 ```
 
 `not_distinct_from?` and `distinct_from?` compare with NULL treated as a
@@ -277,18 +285,54 @@ so a misspelling is a `NoMethodError` where you wrote it, and a name Ruby also
 answers to — `rand` — means the SQL one inside a block:
 
 ```
-abs  ceil  char_length  coalesce  concat  date_trunc  exp  floor  format
-greatest  least  length  ln  log  lower  ltrim  mod  now  nullif  power  rand
-replace  round  rtrim  sqrt  substr  trim  upper
+abs  acos  asin  atan  atan2  cast  ceil  char_length  coalesce  concat
+cos  current_date  current_time  current_timestamp  date_trunc  degrees
+exp  extract  floor  format  greatest  least  length  ln  localtime
+localtimestamp  log  log10  log2  lower  ltrim  mod  now  nullif  pi
+power  radians  rand  replace  round  rtrim  sign  sin  sqrt  substr  tan
+trim  trunc  upper
 ```
 
 Most are spelled the same everywhere. Where they are not, the method names one
 meaning and each adapter gets its own spelling: `char_length`, `greatest` and
 `least` become `LENGTH`, `MAX` and `MIN` on SQLite, and `rand` is `RAND` on
-MySQL and `RANDOM` elsewhere. Where an adapter has no equivalent — `date_trunc`
-outside PostgreSQL, `now` on SQLite — the block raises `NotImplementedError`
+MySQL and `RANDOM` elsewhere, and `trunc` is `TRUNCATE` on MySQL, which
+insists on the second argument the others default to zero — SQLite's takes
+only the one. Where an adapter has no equivalent — `date_trunc` outside
+PostgreSQL, `now` and the `local*` pair on SQLite, `log2` on PostgreSQL,
+whose spelling is `log(2, x)` — the block raises `NotImplementedError`
 rather than leaving the database to reject the SQL.
 
+`current_date`, `current_time`, `current_timestamp`, `localtime` and
+`localtimestamp` come out without parentheses, as the grammar has them —
+written as calls, PostgreSQL and SQLite would reject them. What does go into
+parentheses is an optional precision — `current_timestamp(3)` — which
+`current_date` never takes and SQLite never accepts. `current_timestamp` is
+the portable spelling of what `now` means, and reaches SQLite where `now`
+does not:
+
+```ruby
+Post.where { :published_at <= current_timestamp }
+# SELECT "posts".* FROM "posts" WHERE "posts"."published_at" <= CURRENT_TIMESTAMP
+```
+
+`extract` and `cast` are grammar as well: the field and the type go where no
+value could. The field has to be a plain name, and the type has to look like
+a type — a plain name, at most parenthesized with lengths, so the adapters'
+own spellings like `double precision` or `decimal(10,2)` pass; anything else
+raises `ArgumentError`. The type is the adapter's own name for the type, and
+whether it exists is the database's to say. SQLite spells everything
+`extract` does as `strftime` formats, which no renaming carries, so `extract`
+raises there:
+
+```ruby
+Post.where { extract(:year, :created_at) == 2026 }
+# SELECT "posts".* FROM "posts" WHERE EXTRACT(YEAR FROM "posts"."created_at") = 2026
+
+Post.select { cast(:price, 'decimal(10,2)').as(:price) }
+# SELECT CAST("posts"."price" AS decimal(10,2)) AS price
+```
+
 `format` is printf formatting, and raises on MySQL, where a function of the
 same name does something else entirely: it puts separators in a number, and
 reads a printf template as the number zero rather than complaining. `fn` still

data/activerecord-refined.gemspec

@@ -12,7 +12,9 @@ Gem::Specification.new do |gem|
   gem.summary       = 'ActiveRecord + Ruby 4.1 Proc#refined'
   gem.homepage      = 'https://github.com/shugo/activerecord-refined'
 
-  gem.files         = `git ls-files`.split($/)
+  # 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/})
   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/benchmark/query_building.rb

@@ -28,10 +28,10 @@ T = User.arel_table
 # Each variant must generate equivalent SQL; sanity-print once.
 VARIANTS = {
   "simple equality" => {
-    "hash"   => -> { User.where(name: "matz").to_sql },
-    "string" => -> { User.where("name = ?", "matz").to_sql },
-    "arel"   => -> { User.where(T[:name].eq("matz")).to_sql },
-    "block"  => -> { User.where { :name == "matz" }.to_sql },
+    "hash"   => -> { User.where(name: "alice").to_sql },
+    "string" => -> { User.where("name = ?", "alice").to_sql },
+    "arel"   => -> { User.where(T[:name].eq("alice")).to_sql },
+    "block"  => -> { User.where { :name == "alice" }.to_sql },
   },
   "range (BETWEEN)" => {
     "hash"   => -> { User.where(age: 20..40).to_sql },
@@ -41,13 +41,13 @@ VARIANTS = {
   "LIKE" => {
     "string" => -> { User.where("name LIKE ?", "ma%").to_sql },
     "arel"   => -> { User.where(T[:name].matches("ma%", nil, true)).to_sql },
-    "block"  => -> { User.where { :name.like?("ma%") }.to_sql },
+    "block"  => -> { User.where { :name.like?("al%") }.to_sql },
   },
   "compound AND/OR" => {
-    "string"   => -> { User.where("age >= ? AND (name = ? OR name = ?)", 18, "matz", "nobu").to_sql },
-    "arel"     => -> { User.where(T[:age].gteq(18).and(T[:name].eq("matz").or(T[:name].eq("nobu")))).to_sql },
-    "relation" => -> { User.where(age: 18..).and(User.where(name: "matz").or(User.where(name: "nobu"))).to_sql },
-    "block"    => -> { User.where { (:age >= 18) & ((:name == "matz") | (:name == "nobu")) }.to_sql },
+    "string"   => -> { User.where("age >= ? AND (name = ? OR name = ?)", 18, "alice", "bob").to_sql },
+    "arel"     => -> { User.where(T[:age].gteq(18).and(T[:name].eq("alice").or(T[:name].eq("bob")))).to_sql },
+    "relation" => -> { User.where(age: 18..).and(User.where(name: "alice").or(User.where(name: "bob"))).to_sql },
+    "block"    => -> { User.where { (:age >= 18) & ((:name == "alice") | (:name == "bob")) }.to_sql },
   },
 }
 
@@ -97,8 +97,8 @@ context = ActiveRecord::Refined::BlockContext.new
 syntax = ActiveRecord::Refined::BlockSyntax
 
 {
-  "simple equality" => proc { :name == "matz" },
-  "compound AND/OR" => proc { (:age >= 18) & ((:name == "matz") | (:name == "nobu")) },
+  "simple equality" => proc { :name == "alice" },
+  "compound AND/OR" => proc { (:age >= 18) & ((:name == "alice") | (:name == "bob")) },
 }.each do |label, blk|
   refined = blk.refined(syntax)
   context.instance_exec(&refined) # the copy is made here, on the first call
@@ -115,7 +115,7 @@ puts "1000 more calls from the same call site copied #{iseq_count.call - before}
 
 puts
 puts "=== where the block path spends its time ==="
-block = proc { :name == "matz" }
+block = proc { :name == "alice" }
 refined_block = block.refined(ActiveRecord::Refined::BlockSyntax)
 context = ActiveRecord::Refined::BlockContext.new
 Benchmark.ips do |x|

data/examples/predicates.rb

@@ -16,11 +16,11 @@ Setup.new.up
 class Account < ActiveRecord::Base
 end
 
-Account.create!(login: 'matz',       country: 'JP', age: 60)
-Account.create!(login: 'nobu',       country: 'JP', age: 50)
-Account.create!(login: 'tenderlove', country: 'US', age: 45)
-Account.create!(login: '100%_pure',  country: nil,  age: 30)
-Account.create!(login: '1002000',    country: 'US', age: 25)
+Account.create!(login: 'alice',     country: 'JP', age: 60)
+Account.create!(login: 'bob',       country: 'JP', age: 50)
+Account.create!(login: 'carol',     country: 'US', age: 45)
+Account.create!(login: '100%_pure', country: nil,  age: 30)
+Account.create!(login: '1002000',   country: 'US', age: 25)
 
 def show(title, relation, rows)
   puts "--- #{title} ---"
@@ -63,12 +63,12 @@ show('distinct_from? keeps NULLs, != drops them',
 #    literals, so % and _ in them are escaped rather than matched as
 #    wildcards.  Note the last row matches only the literal-minded one.
 show('like? takes a pattern',
-  Account.where { :login.like?('%love') },
-  Account.where { :login.like?('%love') }.pluck(:login))
+  Account.where { :login.like?('%rol') },
+  Account.where { :login.like?('%rol') }.pluck(:login))
 
 show('start_with? takes any number of literals, like String#start_with?',
-  Account.where { :login.start_with?('ma', 'no') },
-  Account.where { :login.start_with?('ma', 'no') }.pluck(:login))
+  Account.where { :login.start_with?('al', 'bo') },
+  Account.where { :login.start_with?('al', 'bo') }.pluck(:login))
 
 # The % in the argument is escaped, so only the account whose login really
 # contains "100%" matches; the same pattern spelled with like? treats it as a
@@ -83,8 +83,8 @@ show('include? escapes wildcards; like? does not',
 # casecmp? folds both sides rather than trusting the collation, so it means
 # the same thing on every adapter.
 show('casecmp? is case-insensitive equality',
-  Account.where { :login.casecmp?('MaTz') },
-  Account.where { :login.casecmp?('MaTz') }.pluck(:login))
+  Account.where { :login.casecmp?('AlIcE') },
+  Account.where { :login.casecmp?('AlIcE') }.pluck(:login))
 
 # 4. Combining.  & | ! build the tree; Ruby's precedence puts & and | above
 #    the comparison operators, hence the parentheses around each comparison.

data/examples/subqueries.rb

@@ -24,13 +24,13 @@ class Post < ActiveRecord::Base
   def self.published = where { :published == true }
 end
 
-matz  = Author.create!(name: 'matz')
-nobu  = Author.create!(name: 'nobu')
+alice  = Author.create!(name: 'alice')
+bob  = Author.create!(name: 'bob')
 quiet = Author.create!(name: 'quiet')
 
-Post.create!(title: 'refinements', author_id: matz.id, likes: 100, published: true)
-Post.create!(title: 'parser',      author_id: matz.id, likes: 40,  published: true)
-Post.create!(title: 'draft',       author_id: nobu.id, likes: 5,   published: false)
+Post.create!(title: 'refinements', author_id: alice.id, likes: 100, published: true)
+Post.create!(title: 'parser',      author_id: alice.id, likes: 40,  published: true)
+Post.create!(title: 'draft',       author_id: bob.id, likes: 5,   published: false)
 
 def show(title, relation)
   puts "--- #{title} ---"

data/lib/active_record/refined/ast.rb

@@ -9,6 +9,9 @@ module ActiveRecord
       NAME = /[[:alpha:]_][[:alnum:]_$]*/
       ALIAS_NAME = /\A#{NAME}\z/
       FUNCTION_NAME = /\A#{NAME}(\.#{NAME})?\z/
+      # A SQL type as cast writes it: words, at most parenthesized with
+      # lengths -- double precision, decimal(10,2).
+      TYPE_NAME = /\A[[:alpha:]_][[:alnum:]_ ]*(\(\d+(, ?\d+)?\))?\z/
 
       def self.check_name(name, pattern, what)
         return name if pattern.match?(name.to_s)
@@ -218,6 +221,15 @@ module ActiveRecord
           else operand
           end
         end
+
+        # Resolves a function argument: a column or an expression as above,
+        # anything else a value to be quoted.
+        def to_arel_argument(arg, table)
+          case arg
+          when Node, Symbol then to_arel_operand(arg, table)
+          else Arel::Nodes.build_quoted(arg)
+          end
+        end
       end
 
       class Predicate < Node
@@ -351,16 +363,80 @@ module ActiveRecord
         end
 
         def to_arel(table)
-          arel_args = args.map do |arg|
-            case arg
-            when Node, Symbol then to_arel_operand(arg, table)
-            else Arel::Nodes.build_quoted(arg)
-            end
-          end
+          arel_args = args.map {|arg| to_arel_argument(arg, table) }
           Arel::Nodes::NamedFunction.new(name, arel_args)
         end
       end
 
+      # EXTRACT(field FROM expr).  The field is grammar rather than a value --
+      # a keyword the adapter reads bare -- so it has to be a plain name,
+      # which Arel upcases on the way out.
+      class Extract < Node
+        include Predications
+        include Arithmetics
+
+        attr_reader :field, :operand
+
+        def initialize(field, operand)
+          @field = AST.check_name(field, ALIAS_NAME, "extract field")
+          @operand = operand
+        end
+
+        def to_arel(table)
+          Arel::Nodes::Extract.new(to_arel_argument(operand, table), field.to_s)
+        end
+      end
+
+      # CAST(expr AS type).  The type is grammar too, written into the SQL as
+      # given -- it is the adapter's own name for the type, and whether it
+      # exists is the database's to say -- so it has to look like one:
+      # a plain name, at most parenthesized with lengths.
+      class Cast < Node
+        include Predications
+        include Arithmetics
+
+        attr_reader :operand, :sql_type
+
+        def initialize(operand, sql_type)
+          @operand = operand
+          @sql_type = AST.check_name(sql_type, TYPE_NAME, "SQL type")
+        end
+
+        def to_arel(table)
+          Arel::Nodes::NamedFunction.new(
+            "CAST",
+            [Arel::Nodes::As.new(to_arel_argument(operand, table),
+                                 Arel::Nodes::SqlLiteral.new(sql_type.to_s))])
+        end
+      end
+
+      # CURRENT_TIMESTAMP and its relatives, what the SQL grammar calls a
+      # datetime value function.  The grammar has them bare, and PostgreSQL
+      # and SQLite reject them written as calls, so unlike Function the name
+      # is emitted without parentheses.  A precision is the one thing that
+      # does go into parentheses, and it is written into the SQL as given, so
+      # only an Integer is accepted.
+      class DatetimeValueFunction < Node
+        include Predications
+        include Arithmetics
+
+        attr_reader :name, :precision
+
+        def initialize(name, precision = nil)
+          unless precision.nil? || precision.is_a?(Integer)
+            raise ArgumentError,
+              "#{precision.inspect} is not an Integer precision"
+          end
+          @name = name
+          @precision = precision
+        end
+
+        def to_arel(_table)
+          Arel::Nodes::SqlLiteral.new(
+            precision ? "#{name}(#{precision})" : name)
+        end
+      end
+
       # A plain SQL comparison. The value is passed through as it is, so a Range
       # or an Array compares against a PostgreSQL range or array column, the way
       # ActiveRecord's own force_equality? types do.

data/lib/active_record/refined.rb

@@ -55,13 +55,20 @@ module ActiveRecord
       # Availability was checked by calling each one; the SQLite figures
       # assume the math functions its build usually enables.
       SCALAR_FUNCTIONS = {
-        abs: {}, ceil: {}, coalesce: {}, concat: {}, exp: {}, floor: {},
-        length: {}, ln: {}, log: {}, lower: {}, ltrim: {}, mod: {},
-        nullif: {}, power: {}, replace: {}, round: {}, rtrim: {}, sqrt: {},
-        substr: {}, trim: {}, upper: {},
+        abs: {}, acos: {}, asin: {}, atan: {}, atan2: {}, ceil: {},
+        coalesce: {}, concat: {}, cos: {}, degrees: {}, exp: {}, floor: {},
+        length: {}, ln: {}, log: {}, log10: {}, lower: {}, ltrim: {},
+        mod: {}, nullif: {}, pi: {}, power: {}, radians: {}, replace: {},
+        round: {}, rtrim: {}, sign: {}, sin: {}, sqrt: {}, substr: {},
+        tan: {}, trim: {}, upper: {},
         char_length: {sqlite: 'LENGTH'},
         greatest: {sqlite: 'MAX'},
         least: {sqlite: 'MIN'},
+        # PostgreSQL spells log2(x) as log(2, x), which no renaming carries.
+        log2: {postgresql: nil},
+        # MySQL's TRUNCATE insists on the second argument, where the others
+        # default it to zero; SQLite's trunc takes only the one.
+        trunc: {mysql: 'TRUNCATE'},
         now: {sqlite: nil},
         date_trunc: {sqlite: nil, mysql: nil},
         # Named for Kernel#rand, which it also takes back: a block calling
@@ -83,7 +90,65 @@ module ActiveRecord
       }.freeze
 
       SCALAR_FUNCTIONS.each_key do |name|
-        define_method(name) {|*args| AST::Function.new(function_name(name), args) }
+        define_method(name) do |*args|
+          AST::Function.new(function_name(name, SCALAR_FUNCTIONS), args)
+        end
+      end
+
+      # The datetime value functions, as the SQL grammar calls them.  These
+      # the grammar has bare -- PostgreSQL and SQLite reject them written with
+      # parentheses -- and the one thing that does go into parentheses is an
+      # optional precision, current_timestamp(3), which current_date never
+      # takes and SQLite never accepts.  The table reads like
+      # SCALAR_FUNCTIONS; current_timestamp is the portable spelling of what
+      # now means, reaching SQLite where now does not.
+      DATETIME_VALUE_FUNCTIONS = {
+        current_date: {},
+        current_time: {},
+        current_timestamp: {},
+        localtime: {sqlite: nil},
+        localtimestamp: {sqlite: nil},
+      }.freeze
+
+      def current_date
+        AST::DatetimeValueFunction.new(
+          function_name(:current_date, DATETIME_VALUE_FUNCTIONS))
+      end
+
+      (DATETIME_VALUE_FUNCTIONS.keys - [:current_date]).each do |name|
+        define_method(name) do |precision = nil|
+          # Built first so that a precision of the wrong type is an
+          # ArgumentError on every adapter, before SQLite gets to say it takes
+          # none at all.
+          node = AST::DatetimeValueFunction.new(
+            function_name(name, DATETIME_VALUE_FUNCTIONS), precision)
+          if precision && adapter_family == :sqlite
+            raise NotImplementedError,
+              "#{name} takes no precision on #{@model.connection_db_config.adapter}"
+          end
+          node
+        end
+      end
+
+      # EXTRACT(field FROM expr).  The field is a keyword, not a value, so it
+      # has to be a plain name; the node checks it.  SQLite spells all of
+      # this as strftime formats, which no renaming carries, so it raises
+      # there -- after the node is built, so that a bad field is an
+      # ArgumentError on every adapter.
+      def extract(field, expr)
+        node = AST::Extract.new(field, expr)
+        if adapter_family == :sqlite
+          raise NotImplementedError,
+            "extract has no equivalent on #{@model.connection_db_config.adapter}"
+        end
+        node
+      end
+
+      # CAST(expr AS type).  The type is the adapter's own name for it,
+      # checked for shape by the node; whether it exists is the database's to
+      # say.
+      def cast(expr, type)
+        AST::Cast.new(expr, type)
       end
 
       # Escape hatch for functions without a method of their own.  The name is
@@ -101,8 +166,8 @@ module ActiveRecord
 
       private
 
-      def function_name(name)
-        spellings = SCALAR_FUNCTIONS.fetch(name)
+      def function_name(name, functions)
+        spellings = functions.fetch(name)
         return name.to_s.upcase unless spellings.key?(adapter_family)
         spellings.fetch(adapter_family) ||
           raise(NotImplementedError,

data/lib/activerecord-refined/version.rb

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

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,9 +86,9 @@ 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
@@ -115,8 +115,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 +128,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
@@ -350,11 +350,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 +421,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 +477,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
@@ -755,8 +755,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 +793,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 +826,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 +845,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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-refined
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 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