activerecord-refined 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4c6743021d5bc3d9aa3f3951ba64de77efcb51ed451aa338858d360ea1714b07
+  data.tar.gz: 3b2521ec7a2f0ccbbd68cf3e134461076a3ce77f3e7d545a9c27ba7d38860ca8
+SHA512:
+  metadata.gz: 344141c84a629959a125ba4a6513274faa548f56de4442ed5333ae5346fa15256c1020ba834ec9713ee0b366fd1dda1371ba211bd6bbfbf5f2a5b705ed52c429
+  data.tar.gz: 29f9d6ac4ad68e031960e297fe3c9d30a50cab8f288d3599deb0f5607198238e61badf2e0e961dc78bceac3c3306d7577e7caba4e1224adea279ac741a7c37f7

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in activerecord-refined.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Akira Matsuda
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,130 @@
+# ActiveRecord::Refined
+
+Adding clean and powerful query syntax on ActiveRecord using refinements.
+
+```ruby
+Author.
+  joins(:posts) { :posts[:author_id] == :authors[:id] }.
+  where { (:authors[:age] == (20..40)) & (:posts[:published] == true) }
+# SELECT "authors".* FROM "authors"
+#   INNER JOIN "posts" ON "posts"."author_id" = "authors"."id"
+#   WHERE "authors"."age" BETWEEN 20 AND 40 AND "posts"."published" = TRUE
+```
+
+## History
+
+This gem was formerly known as **activerecord-refinements**, created by Akira Matsuda
+to experiment with the initial implementation of Ruby 2.0 Refinements. Because of the
+Refinements' spec change, that implementation stopped working on Ruby 2.0.0 stable, and
+the project was left dormant for a long time.
+
+It has now been renamed to **activerecord-refined** and reimplemented on top of
+`Proc#refined`, which will be introduced in Ruby 4.1. `Proc#refined` returns a new proc that
+is evaluated with the given refinements activated, so a block written by the caller can
+be re-interpreted under the query DSL's refinements:
+
+```ruby
+def evaluate_block(&block)
+  refined_block = block.refined(ActiveRecord::Refined::BlockSyntax)
+  BlockContext.new.instance_exec(&refined_block)
+end
+```
+
+This is exactly what the old implementation needed and could not do, so the query syntax
+works again without monkey-patching `Symbol` globally.
+
+## Requirements
+
+* 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
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'activerecord-refined'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install activerecord-refined
+
+## Usage
+
+Just require the gem, and `where`, `select`, `joins`, `left_outer_joins`, `having`,
+`order` and `group` will accept a block.
+
+```ruby
+require 'activerecord-refined'
+```
+
+Inside the block, symbols denote columns of the receiver's table, and `:table[:column]`
+denotes a qualified column.
+
+### Conditions
+
+```ruby
+Author.where { :age >= 18 }
+Author.where { :name =~ 'A%' }              # LIKE
+Author.where { :name !~ '%test%' }          # NOT LIKE
+Author.where { :age == (20..40) }           # BETWEEN
+Author.where { :country == %w[JP US] }      # IN
+Author.where { :country != %w[JP US] }      # NOT IN
+Author.where { :country.null? }             # IS NULL
+```
+
+Combine predicates with `&`, `|` and `!`. Ruby's operator precedence makes the
+parentheses around each comparison necessary:
+
+```ruby
+Author.where { (:age >= 18) & ((:country == 'JP') | (:country == 'US')) }
+Author.where { !((:age == (0..17)) | :country.null?) }
+```
+
+### Joins
+
+The block is the `ON` clause:
+
+```ruby
+Author.
+  joins(:posts) { :posts[:author_id] == :authors[:id] }.
+  joins(:comments) { :comments[:post_id] == :posts[:id] }
+
+Author.left_outer_joins(:posts) { :posts[:author_id] == :authors[:id] }
+```
+
+### Aggregates, functions and aliases
+
+`count`, `sum`, `avg`, `min` and `max` are available as methods, as are the scalar
+functions `upper`, `lower`, `length`, `trim`, `coalesce`, `abs` and `round`. Use `.as`
+for a column alias, and `.asc` / `.desc` for the sort direction. Return an array to
+select or order by multiple expressions.
+
+```ruby
+Author.
+  joins(:posts) { :posts[:author_id] == :authors[:id] }.
+  where { :posts[:published] == true }.
+  group { :authors[:id] }.
+  having { count(:posts[:id]) > 1 }.
+  order { count(:posts[:id]).desc }.
+  select {
+    [
+      upper(:authors[:name]).as(:author),
+      count(:posts[:id]).as(:post_count),
+      avg(:posts[:likes]).as(:avg_likes),
+    ]
+  }
+```
+
+See `examples/` for complete, runnable scripts.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/test_*.rb']
+end
+
+task default: :test

data/activerecord-refined.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'activerecord-refined/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "activerecord-refined"
+  gem.version       = Activerecord::Refined::VERSION
+  gem.authors       = ["Shugo Maeda"]
+  gem.email         = ["shugo@ruby-lang.org"]
+  gem.description   = 'Adding clean and powerful query syntax on AR using refinements'
+  gem.summary       = 'ActiveRecord + Ruby 2.0 refinements'
+  gem.homepage      = 'https://github.com/shugo/activerecord-refined'
+
+  gem.files         = `git ls-files`.split($/)
+  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"]
+
+  # Proc#refined is available since Ruby 4.1. 4.1.0.dev is required to allow
+  # ruby-master builds, which sort before the 4.1.0 release.
+  gem.required_ruby_version = '>= 4.1.0.dev'
+
+  gem.add_dependency 'activerecord', ['>= 7.0']
+  gem.add_development_dependency 'sqlite3', ['>= 0']
+  gem.add_development_dependency 'minitest', ['>= 0']
+  gem.add_development_dependency 'rake', ['>= 0']
+end

data/lib/active_record/refined/ast.rb

@@ -0,0 +1,219 @@
+module ActiveRecord
+  module Refined
+    module AST
+      class Node
+        def to_arel(table)
+          raise ScriptError, "subclass must override this method"
+        end
+
+        def as(alias_name)
+          As.new(self, alias_name)
+        end
+
+        def asc
+          Ordering.new(self, :asc)
+        end
+
+        def desc
+          Ordering.new(self, :desc)
+        end
+      end
+
+      class Predicate < Node
+        def &(other)
+          And.new(self, other)
+        end
+
+        def |(other)
+          Or.new(self, other)
+        end
+
+        def !
+          Not.new(self)
+        end
+      end
+
+      class Column < Node
+        attr_reader :table_name, :column_name
+
+        def initialize(table_name, column_name)
+          @table_name = table_name
+          @column_name = column_name
+        end
+
+        def to_arel(_table)
+          Arel::Table.new(table_name)[column_name]
+        end
+
+        %i[== != =~ !~ > >= < <=].each do |op|
+          define_method(op) {|val| Comparison.new(self, op, val) }
+        end
+
+        def null?
+          Comparison.new(self, :==, nil)
+        end
+
+        %i[count sum average maximum minimum].each do |func|
+          define_method(func) { Aggregate.new(self, func) }
+        end
+      end
+
+      class Aggregate < Node
+        attr_reader :operand, :function
+
+        def initialize(operand, function)
+          @operand = operand
+          @function = function
+        end
+
+        def to_arel(table)
+          arel_operand = case operand
+                         when Node then operand.to_arel(table)
+                         else table[operand]
+                         end
+          arel_operand.public_send(function)
+        end
+
+        %i[== != =~ !~ > >= < <=].each do |op|
+          define_method(op) {|val| Comparison.new(self, op, val) }
+        end
+      end
+
+      class As < Node
+        attr_reader :operand, :alias_name
+
+        def initialize(operand, alias_name)
+          @operand = operand
+          @alias_name = alias_name
+        end
+
+        def to_arel(table)
+          arel_operand = case operand
+                         when Node then operand.to_arel(table)
+                         when Symbol then table[operand]
+                         else operand
+                         end
+          arel_operand.as(alias_name.to_s)
+        end
+      end
+
+      class Ordering < Node
+        attr_reader :operand, :direction
+
+        def initialize(operand, direction)
+          @operand = operand
+          @direction = direction
+        end
+
+        def to_arel(table)
+          arel_operand = case operand
+                         when Node then operand.to_arel(table)
+                         when Symbol then table[operand]
+                         else operand
+                         end
+          arel_operand.public_send(direction)
+        end
+      end
+
+      class Function < Node
+        attr_reader :name, :args
+
+        def initialize(name, args)
+          @name = name
+          @args = args
+        end
+
+        def to_arel(table)
+          arel_args = args.map do |arg|
+            case arg
+            when Node then arg.to_arel(table)
+            when Symbol then table[arg]
+            else Arel::Nodes.build_quoted(arg)
+            end
+          end
+          Arel::Nodes::NamedFunction.new(name, arel_args)
+        end
+
+        %i[== != =~ !~ > >= < <=].each do |op|
+          define_method(op) {|val| Comparison.new(self, op, val) }
+        end
+      end
+
+      class Comparison < Predicate
+        OPERATOR_MAP = {
+          :== => :eq, :!= => :not_eq, :=~ => :matches, :!~ => :does_not_match,
+          :> => :gt, :>= => :gteq, :< => :lt, :<= => :lteq
+        }.freeze
+
+        attr_reader :column, :operator, :value
+
+        def initialize(column, operator, value)
+          @column = column
+          @operator = operator
+          @value = value
+        end
+
+        def to_arel(table)
+          arel_column = case column
+                        when Node then column.to_arel(table)
+                        else table[column]
+                        end
+          arel_value = case value
+                       when Node then value.to_arel(table)
+                       else value
+                       end
+          case
+          when operator == :== && Range === value
+            arel_column.between(value)
+          when operator == :!= && Range === value
+            arel_column.not_between(value)
+          when operator == :== && Array === value
+            arel_column.in(value)
+          when operator == :!= && Array === value
+            arel_column.not_in(value)
+          else
+            arel_column.public_send(OPERATOR_MAP.fetch(operator), arel_value)
+          end
+        end
+      end
+
+      class And < Predicate
+        attr_reader :left, :right
+
+        def initialize(left, right)
+          @left = left
+          @right = right
+        end
+
+        def to_arel(table)
+          left.to_arel(table).and(right.to_arel(table))
+        end
+      end
+
+      class Or < Predicate
+        attr_reader :left, :right
+
+        def initialize(left, right)
+          @left = left
+          @right = right
+        end
+
+        def to_arel(table)
+          left.to_arel(table).or(right.to_arel(table))
+        end
+      end
+
+      class Not < Predicate
+        attr_reader :operand
+
+        def initialize(operand)
+          @operand = operand
+        end
+
+        def to_arel(table)
+          Arel::Nodes::Not.new(operand.to_arel(table))
+        end
+      end
+    end
+  end
+end

data/lib/active_record/refined.rb

@@ -0,0 +1,138 @@
+module ActiveRecord
+  module Refined
+    module BlockSyntax
+      refine Symbol do
+        %i[== != =~ !~ > >= < <=].each do |op|
+          define_method(op) {|val| AST::Comparison.new(self, op, val) }
+        end
+
+        def null?
+          AST::Comparison.new(self, :==, nil)
+        end
+
+        %i[count sum average maximum minimum].each do |func|
+          define_method(func) { AST::Aggregate.new(self, func) }
+        end
+
+        def as(alias_name)
+          AST::As.new(self, alias_name)
+        end
+
+        def asc
+          AST::Ordering.new(self, :asc)
+        end
+
+        def desc
+          AST::Ordering.new(self, :desc)
+        end
+
+        def [](column_name)
+          AST::Column.new(self, column_name)
+        end
+      end
+    end
+
+    class BlockContext
+      AGGREGATE_FUNCTIONS = {
+        count: :count, sum: :sum, avg: :average, min: :minimum, max: :maximum,
+      }.freeze
+
+      AGGREGATE_FUNCTIONS.each do |name, arel_func|
+        define_method(name) {|column| AST::Aggregate.new(column, arel_func) }
+      end
+
+      SCALAR_FUNCTIONS = %i[upper lower length trim coalesce abs round].freeze
+
+      SCALAR_FUNCTIONS.each do |name|
+        define_method(name) {|*args| AST::Function.new(name.to_s.upcase, args) }
+      end
+    end
+
+    module QueryMethods
+      def where(opts = nil, *rest, &block)
+        if block
+          super(evaluate_block(&block).to_arel(table))
+        else
+          super
+        end
+      end
+
+      def select(*fields, &block)
+        if block
+          result = evaluate_block(&block)
+          arel = Array(result).map {|node| to_arel_field(node) }
+          super(*arel, &nil)
+        else
+          super
+        end
+      end
+
+      def having(opts = nil, *rest, &block)
+        if block
+          super(evaluate_block(&block).to_arel(table))
+        else
+          super
+        end
+      end
+
+      def order(*args, &block)
+        if block
+          result = evaluate_block(&block)
+          arel = Array(result).map {|node| to_arel_field(node) }
+          super(*arel, &nil)
+        else
+          super
+        end
+      end
+
+      def group(*args, &block)
+        if block
+          result = evaluate_block(&block)
+          arel = Array(result).map {|node| to_arel_field(node) }
+          super(*arel, &nil)
+        else
+          super
+        end
+      end
+
+      def joins(*args, &block)
+        if block
+          super(build_join_node(args.first, Arel::Nodes::InnerJoin, &block))
+        else
+          super
+        end
+      end
+
+      def left_outer_joins(*args, &block)
+        if block
+          joins(build_join_node(args.first, Arel::Nodes::OuterJoin, &block))
+        else
+          super
+        end
+      end
+
+      private
+
+      def evaluate_block(&block)
+        refined_block = block.refined(ActiveRecord::Refined::BlockSyntax)
+        BlockContext.new.instance_exec(&refined_block)
+      end
+
+      def to_arel_field(node)
+        case node
+        when AST::Node then node.to_arel(table)
+        when Symbol then table[node]
+        else node
+        end
+      end
+
+      def build_join_node(target_table, join_class, &block)
+        ast = evaluate_block(&block)
+        join_class.new(
+          Arel::Table.new(target_table),
+          Arel::Nodes::On.new(ast.to_arel(table))
+        )
+      end
+    end
+  end
+end

data/lib/activerecord-refined/version.rb

@@ -0,0 +1,5 @@
+module Activerecord
+  module Refined
+    VERSION = '0.3.0'
+  end
+end

data/lib/activerecord-refined.rb

@@ -0,0 +1,7 @@
+require 'activerecord-refined/version'
+require 'active_record'
+require 'active_record/relation'
+require 'active_record/refined/ast'
+require 'active_record/refined'
+
+ActiveRecord::QueryMethods.prepend ActiveRecord::Refined::QueryMethods

data/test/test_block_syntax.rb

@@ -0,0 +1,307 @@
+require_relative 'test_helper'
+
+class TestBlockSyntax < Minitest::Test
+  def test_equal
+    assert_match(/WHERE "users"."name" = 'matz'/, User.where { :name == 'matz' }.to_sql)
+  end
+
+  def test_not_equal
+    assert_match(/WHERE "users"."name" != 'nobu'/, User.where { :name != 'nobu' }.to_sql)
+  end
+
+  def test_greater_than
+    assert_match(/WHERE "users"."age" > 3/, User.where { :age > 3 }.to_sql)
+  end
+
+  def test_greater_than_or_equal
+    assert_match(/WHERE "users"."age" >= 18/, User.where { :age >= 18 }.to_sql)
+  end
+
+  def test_less_than
+    assert_match(/WHERE "users"."age" < 60/, User.where { :age < 60 }.to_sql)
+  end
+
+  def test_less_than_or_equal
+    assert_match(/WHERE "users"."age" <= 35/, User.where { :age <= 35 }.to_sql)
+  end
+
+  def test_like
+    assert_match(/WHERE "users"."name" LIKE 'tender%'/, User.where { :name =~ 'tender%' }.to_sql)
+  end
+
+  def test_outside_of_where_block
+    assert_raises(ArgumentError) { :omg > 1 }
+  end
+
+  def test_and
+    assert_match(/WHERE "users"."name" = 'matz' AND "users"."age" > 18/,
+      User.where { (:name == 'matz') & (:age > 18) }.to_sql)
+  end
+
+  def test_or
+    assert_match(/WHERE \(?\"users\".\"name\" = 'matz' OR \"users\".\"name\" = 'nobu'\)?/,
+      User.where { (:name == 'matz') | (:name == 'nobu') }.to_sql)
+  end
+
+  def test_not
+    assert_match(/WHERE NOT \(?\"users\".\"name\" = 'matz'\)?/,
+      User.where { !(:name == 'matz') }.to_sql)
+  end
+
+  def test_complex_combination
+    sql = User.where { ((:name == 'matz') & (:age > 18)) | !(:name == 'nobu') }.to_sql
+    assert_match(/"users"."name" = 'matz'/, sql)
+    assert_match(/"users"."age" > 18/, sql)
+    assert_match(/NOT/, sql)
+    assert_match(/OR/, sql)
+  end
+
+  def test_between
+    assert_match(/WHERE "users"."age" BETWEEN 18 AND 65/,
+      User.where { :age == (18..65) }.to_sql)
+  end
+
+  def test_not_like
+    assert_match(/WHERE "users"."name" NOT LIKE 'tender%'/,
+      User.where { :name !~ 'tender%' }.to_sql)
+  end
+
+  def test_not_between
+    # Arel expands a bounded NOT BETWEEN into an OR of comparisons
+    assert_match(/WHERE \("users"."age" < 18 OR "users"."age" > 65\)/,
+      User.where { :age != (18..65) }.to_sql)
+  end
+
+  def test_is_null
+    assert_match(/WHERE "users"."name" IS NULL/,
+      User.where { :name.null? }.to_sql)
+  end
+
+  def test_is_null_qualified
+    assert_match(/WHERE "users"."name" IS NULL/,
+      User.where { :users[:name].null? }.to_sql)
+  end
+
+  def test_in
+    assert_match(/WHERE "users"."age" IN \(1, 2, 3\)/,
+      User.where { :age == [1, 2, 3] }.to_sql)
+  end
+
+  def test_not_in
+    assert_match(/WHERE "users"."age" NOT IN \(1, 2, 3\)/,
+      User.where { :age != [1, 2, 3] }.to_sql)
+  end
+
+  def test_qualified_column
+    assert_match(/WHERE "users"."name" = 'matz'/,
+      User.where { :users[:name] == 'matz' }.to_sql)
+  end
+
+  def test_column_to_column_comparison
+    sql = User.where { :users[:name] == :users[:age] }.to_sql
+    assert_match(/"users"."name" = "users"."age"/, sql)
+  end
+
+  def test_joins_with_block
+    sql = Author.joins(:posts) { :posts[:author_id] == :authors[:id] }.to_sql
+    assert_match(/INNER JOIN "posts" ON "posts"."author_id" = "authors"."id"/, sql)
+  end
+
+  def test_left_outer_joins_with_block
+    sql = Author.left_outer_joins(:posts) { :posts[:author_id] == :authors[:id] }.to_sql
+    assert_match(/LEFT OUTER JOIN "posts" ON "posts"."author_id" = "authors"."id"/, sql)
+  end
+
+  def test_select_aggregate
+    assert_match(/SELECT SUM\("users"."age"\)/,
+      User.select { :age.sum }.to_sql)
+  end
+
+  def test_select_aggregate_qualified
+    assert_match(/SELECT COUNT\("users"."id"\)/,
+      User.select { :users[:id].count }.to_sql)
+  end
+
+  def test_select_average
+    assert_match(/SELECT AVG\("users"."age"\)/,
+      User.select { :age.average }.to_sql)
+  end
+
+  def test_select_maximum
+    assert_match(/SELECT MAX\("users"."age"\)/,
+      User.select { :age.maximum }.to_sql)
+  end
+
+  def test_select_minimum
+    assert_match(/SELECT MIN\("users"."age"\)/,
+      User.select { :age.minimum }.to_sql)
+  end
+
+  def test_having_aggregate
+    sql = User.group(:name).having { :age.sum > 100 }.to_sql
+    assert_match(/GROUP BY "users"."name"/, sql)
+    assert_match(/HAVING SUM\("users"."age"\) > 100/, sql)
+  end
+
+  def test_select_avg_function
+    assert_match(/SELECT AVG\("users"."age"\)/,
+      User.select { avg(:age) }.to_sql)
+  end
+
+  def test_select_count_function
+    assert_match(/SELECT COUNT\("users"."id"\)/,
+      User.select { count(:id) }.to_sql)
+  end
+
+  def test_select_sum_function
+    assert_match(/SELECT SUM\("users"."age"\)/,
+      User.select { sum(:age) }.to_sql)
+  end
+
+  def test_select_min_function
+    assert_match(/SELECT MIN\("users"."age"\)/,
+      User.select { min(:age) }.to_sql)
+  end
+
+  def test_select_max_function
+    assert_match(/SELECT MAX\("users"."age"\)/,
+      User.select { max(:age) }.to_sql)
+  end
+
+  def test_function_qualified_column
+    assert_match(/SELECT AVG\("users"."age"\)/,
+      User.select { avg(:users[:age]) }.to_sql)
+  end
+
+  def test_having_function
+    sql = User.group(:name).having { sum(:age) > 100 }.to_sql
+    assert_match(/GROUP BY "users"."name"/, sql)
+    assert_match(/HAVING SUM\("users"."age"\) > 100/, sql)
+  end
+
+  def test_function_and_method_syntax_match
+    assert_equal User.select { :age.average }.to_sql,
+      User.select { avg(:age) }.to_sql
+  end
+
+  def test_upper_function
+    assert_match(/SELECT UPPER\("users"."name"\)/,
+      User.select { upper(:name) }.to_sql)
+  end
+
+  def test_lower_function
+    assert_match(/SELECT LOWER\("users"."name"\)/,
+      User.select { lower(:name) }.to_sql)
+  end
+
+  def test_length_function_in_where
+    assert_match(/WHERE LENGTH\("users"."name"\) > 3/,
+      User.where { length(:name) > 3 }.to_sql)
+  end
+
+  def test_coalesce_function_with_literal
+    assert_match(/SELECT COALESCE\("users"."name", 'unknown'\)/,
+      User.select { coalesce(:name, 'unknown') }.to_sql)
+  end
+
+  def test_function_comparison
+    assert_match(/WHERE UPPER\("users"."name"\) = 'MATZ'/,
+      User.where { upper(:name) == 'MATZ' }.to_sql)
+  end
+
+  def test_nested_function
+    assert_match(/SELECT UPPER\(COALESCE\("users"."name", 'x'\)\)/,
+      User.select { upper(coalesce(:name, 'x')) }.to_sql)
+  end
+
+  def test_function_qualified_column_arg
+    assert_match(/SELECT UPPER\("users"."name"\)/,
+      User.select { upper(:users[:name]) }.to_sql)
+  end
+
+  def test_select_multiple_fields
+    assert_match(/SELECT UPPER\("users"."name"\), "users"."age"/,
+      User.select { [upper(:name), :age] }.to_sql)
+  end
+
+  def test_select_multiple_columns
+    assert_match(/SELECT "users"."name", "users"."age"/,
+      User.select { [:name, :age] }.to_sql)
+  end
+
+  def test_select_multiple_with_aggregate
+    assert_match(/SELECT "users"."name", SUM\("users"."age"\)/,
+      User.select { [:name, sum(:age)] }.to_sql)
+  end
+
+  def test_select_function_with_alias
+    assert_match(/SELECT UPPER\("users"."name"\) AS upper_name, "users"."age"/,
+      User.select { [upper(:name).as(:upper_name), :age] }.to_sql)
+  end
+
+  def test_select_column_alias
+    assert_match(/SELECT "users"."name" AS n/,
+      User.select { :name.as(:n) }.to_sql)
+  end
+
+  def test_select_qualified_column_alias
+    assert_match(/SELECT "users"."name" AS n/,
+      User.select { :users[:name].as(:n) }.to_sql)
+  end
+
+  def test_select_aggregate_alias
+    assert_match(/SELECT COUNT\("users"."id"\) AS cnt/,
+      User.select { count(:id).as(:cnt) }.to_sql)
+  end
+
+  def test_order_default_asc
+    assert_match(/ORDER BY "users"."age"/,
+      User.order { :age }.to_sql)
+  end
+
+  def test_order_desc
+    assert_match(/ORDER BY "users"."age" DESC/,
+      User.order { :age.desc }.to_sql)
+  end
+
+  def test_order_asc
+    assert_match(/ORDER BY "users"."age" ASC/,
+      User.order { :age.asc }.to_sql)
+  end
+
+  def test_order_multiple
+    assert_match(/ORDER BY "users"."age" DESC, "users"."name" ASC/,
+      User.order { [:age.desc, :name.asc] }.to_sql)
+  end
+
+  def test_order_qualified_column
+    assert_match(/ORDER BY "users"."name" DESC/,
+      User.order { :users[:name].desc }.to_sql)
+  end
+
+  def test_group_single
+    assert_match(/GROUP BY "users"."name"/,
+      User.group { :name }.to_sql)
+  end
+
+  def test_group_multiple
+    assert_match(/GROUP BY "users"."name", "users"."age"/,
+      User.group { [:name, :age] }.to_sql)
+  end
+
+  def test_group_qualified_column
+    assert_match(/GROUP BY "users"."name"/,
+      User.group { :users[:name] }.to_sql)
+  end
+
+  def test_group_with_having
+    sql = User.group { :name }.having { sum(:age) > 100 }.to_sql
+    assert_match(/GROUP BY "users"."name"/, sql)
+    assert_match(/HAVING SUM\("users"."age"\) > 100/, sql)
+  end
+
+  def test_default_where_syntax
+    assert_match(/WHERE "users"."name" = 'Ruby' AND "users"."age" = 19/,
+      User.where(name: 'Ruby', age: 19).to_sql)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,31 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'minitest/autorun'
+Bundler.require
+
+require 'active_record'
+
+config = {:adapter => 'sqlite3', :database => ':memory:'}
+ActiveRecord::Base.establish_connection(config)
+
+class User < ActiveRecord::Base
+end
+
+class Author < ActiveRecord::Base
+  has_many :posts
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :author
+end
+
+class CreateAllTables < ActiveRecord::Migration[8.1]
+  def up
+    create_table(:users) {|t| t.string :name; t.integer :age}
+    create_table(:authors) {|t| t.string :name}
+    create_table(:posts) {|t| t.string :title; t.integer :author_id}
+  end
+end
+ActiveRecord::Migration.verbose = false
+CreateAllTables.new.up

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-refined
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+  - Shugo Maeda
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+  - !ruby/object:Gem::Dependency
+    name: activerecord
+    requirement: !ruby/object:Gem::Requirement
+      requirements:
+        -
+          - ">="
+          - !ruby/object:Gem::Version
+            version: "7.0"
+    type: :runtime
+    prerelease: false
+    version_requirements: !ruby/object:Gem::Requirement
+      requirements:
+        -
+          - ">="
+          - !ruby/object:Gem::Version
+            version: "7.0"
+  - !ruby/object:Gem::Dependency
+    name: sqlite3
+    requirement: !ruby/object:Gem::Requirement
+      requirements:
+        -
+          - ">="
+          - !ruby/object:Gem::Version
+            version: "0"
+    type: :development
+    prerelease: false
+    version_requirements: !ruby/object:Gem::Requirement
+      requirements:
+        -
+          - ">="
+          - !ruby/object:Gem::Version
+            version: "0"
+  - !ruby/object:Gem::Dependency
+    name: minitest
+    requirement: !ruby/object:Gem::Requirement
+      requirements:
+        -
+          - ">="
+          - !ruby/object:Gem::Version
+            version: "0"
+    type: :development
+    prerelease: false
+    version_requirements: !ruby/object:Gem::Requirement
+      requirements:
+        -
+          - ">="
+          - !ruby/object:Gem::Version
+            version: "0"
+  - !ruby/object:Gem::Dependency
+    name: rake
+    requirement: !ruby/object:Gem::Requirement
+      requirements:
+        -
+          - ">="
+          - !ruby/object:Gem::Version
+            version: "0"
+    type: :development
+    prerelease: false
+    version_requirements: !ruby/object:Gem::Requirement
+      requirements:
+        -
+          - ">="
+          - !ruby/object:Gem::Version
+            version: "0"
+description: Adding clean and powerful query syntax on AR using refinements
+email:
+  - shugo@ruby-lang.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+  - .gitignore
+  - Gemfile
+  - LICENSE.txt
+  - README.md
+  - Rakefile
+  - activerecord-refined.gemspec
+  - lib/active_record/refined.rb
+  - lib/active_record/refined/ast.rb
+  - lib/activerecord-refined.rb
+  - lib/activerecord-refined/version.rb
+  - test/test_block_syntax.rb
+  - test/test_helper.rb
+homepage: "https://github.com/shugo/activerecord-refined"
+licenses: []
+metadata: {}
+rdoc_options: []
+require_paths:
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+    -
+      - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.0.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+    -
+      - ">="
+      - !ruby/object:Gem::Version
+        version: "0"
+requirements: []
+rubygems_version: 4.1.0.dev
+specification_version: 4
+summary: ActiveRecord + Ruby 2.0 refinements
+test_files:
+  - test/test_block_syntax.rb
+  - test/test_helper.rb