activerecord-refined 0.3.1 → 0.3.3

data/lib/active_record/refined/ast.rb

@@ -1,6 +1,90 @@
 module ActiveRecord
   module Refined
     module AST
+      # Predicate builders shared by symbols, qualified columns and
+      # expressions. Imported into the Symbol refinement with
+      # Refinement#import_methods, so every method must be defined with def.
+      module Predications
+        # == and != mean SQL = and <>, and = NULL is never true there, so nil
+        # is rejected rather than silently rewritten to IS NULL.  null? builds
+        # its node directly and stays clear of this check.
+        def ==(other)
+          if other.nil?
+            raise ArgumentError, "== does not take nil; use null? instead"
+          end
+          Comparison.new(self, :==, other)
+        end
+
+        def !=(other)
+          if other.nil?
+            raise ArgumentError, "!= does not take nil; use !null? instead"
+          end
+          Comparison.new(self, :!=, other)
+        end
+
+        def >(other)
+          Comparison.new(self, :>, other)
+        end
+
+        def >=(other)
+          Comparison.new(self, :>=, other)
+        end
+
+        def <(other)
+          Comparison.new(self, :<, other)
+        end
+
+        def <=(other)
+          Comparison.new(self, :<=, other)
+        end
+
+        def =~(pattern)
+          Match.new(self, pattern)
+        end
+
+        def !~(pattern)
+          Match.new(self, pattern, negated: true)
+        end
+
+        def null?
+          Comparison.new(self, :==, nil)
+        end
+
+        def in?(values)
+          In.new(self, values)
+        end
+
+        def between?(min, max)
+          In.new(self, min..max)
+        end
+
+        def like?(pattern)
+          Like.new(self, pattern)
+        end
+
+        def start_with?(*prefixes)
+          if prefixes.empty?
+            raise ArgumentError, "start_with? needs at least one prefix"
+          end
+          Like.any(self, prefixes.map {|prefix| "#{Like.escape(prefix)}%" })
+        end
+
+        def end_with?(*suffixes)
+          if suffixes.empty?
+            raise ArgumentError, "end_with? needs at least one suffix"
+          end
+          Like.any(self, suffixes.map {|suffix| "%#{Like.escape(suffix)}" })
+        end
+
+        def include?(substring)
+          Like.new(self, "%#{Like.escape(substring)}%", Like::ESCAPE)
+        end
+
+        def member?(element)
+          Member.new(self, element)
+        end
+      end
+
       class Node
         def to_arel(table)
           raise ScriptError, "subclass must override this method"
@@ -17,6 +101,18 @@ module ActiveRecord
         def desc
           Ordering.new(self, :desc)
         end
+
+        private
+
+        # Resolves an operand denoting a column or an expression.
+        def to_arel_operand(operand, table)
+          case operand
+          when Node then operand.to_arel(table)
+          when :* then Arel.star
+          when Symbol then table[operand]
+          else operand
+          end
+        end
       end
 
       class Predicate < Node
@@ -34,6 +130,8 @@ module ActiveRecord
       end
 
       class Column < Node
+        include Predications
+
         attr_reader :table_name, :column_name
 
         def initialize(table_name, column_name)
@@ -45,20 +143,14 @@ module ActiveRecord
           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
+        include Predications
+
         attr_reader :operand, :function
 
         def initialize(operand, function)
@@ -67,15 +159,7 @@ module ActiveRecord
         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) }
+          to_arel_operand(operand, table).public_send(function)
         end
       end
 
@@ -88,12 +172,7 @@ module ActiveRecord
         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)
+          to_arel_operand(operand, table).as(alias_name.to_s)
         end
       end
 
@@ -106,16 +185,13 @@ module ActiveRecord
         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)
+          to_arel_operand(operand, table).public_send(direction)
         end
       end
 
       class Function < Node
+        include Predications
+
         attr_reader :name, :args
 
         def initialize(name, args)
@@ -126,22 +202,20 @@ module ActiveRecord
         def to_arel(table)
           arel_args = args.map do |arg|
             case arg
-            when Node then arg.to_arel(table)
-            when Symbol then table[arg]
+            when Node, Symbol then to_arel_operand(arg, table)
             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
 
+      # 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.
       class Comparison < Predicate
         OPERATOR_MAP = {
-          :== => :eq, :!= => :not_eq, :=~ => :matches, :!~ => :does_not_match,
+          :== => :eq, :!= => :not_eq,
           :> => :gt, :>= => :gteq, :< => :lt, :<= => :lteq
         }.freeze
 
@@ -154,26 +228,173 @@ module ActiveRecord
         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)
+          arel_column = to_arel_operand(column, table)
+          arel_value = value.is_a?(Node) ? value.to_arel(table) : value
+          arel_column.public_send(OPERATOR_MAP.fetch(operator), arel_value)
+        end
+      end
+
+      # IN for a list of values, BETWEEN for a range, IN (SELECT ...) for a
+      # relation.
+      class In < Predicate
+        attr_reader :operand, :values
+
+        def initialize(operand, values)
+          @operand = operand
+          @values = values
+        end
+
+        def to_arel(table)
+          arel_operand = to_arel_operand(operand, table)
+          case values
+          when Range then arel_operand.between(values)
+          when ActiveRecord::Relation then arel_operand.in(subquery(values))
+          else arel_operand.in(values)
+          end
+        end
+
+        private
+
+        # The same treatment ActiveRecord's own RelationHandler gives a
+        # relation used as a value: without an explicit select list the
+        # subquery selects the model's primary key.
+        def subquery(relation)
+          if relation.eager_loading?
+            relation = relation.send(:apply_join_dependency)
+          end
+          if relation.select_values.empty?
+            model = relation.model
+            if model.composite_primary_key?
+              raise ArgumentError,
+                "Cannot map composite primary key #{model.primary_key} to IN"
+            end
+            relation = relation.select(relation.table[model.primary_key])
+          end
+          relation.arel
+        end
+      end
+
+      # EXISTS (SELECT ...) for a relation.  Correlate the subquery with the
+      # outer table through qualified columns.  EXISTS only asks whether a row
+      # comes back, so unlike In there is no select list to fix up.
+      class Exists < Predicate
+        attr_reader :relation
+
+        def initialize(relation)
+          @relation = relation
+        end
+
+        def to_arel(_table)
+          subquery = relation
+          if subquery.eager_loading?
+            subquery = subquery.send(:apply_join_dependency)
+          end
+          subquery.arel.exists
+        end
+      end
+
+      class Like < Predicate
+        ESCAPE = "\\".freeze
+
+        # Escapes % and _ so that they match literally. The pattern built from
+        # the result must be used with ESCAPE, since SQLite has no default
+        # escape character.
+        def self.escape(string)
+          ActiveRecord::Base.sanitize_sql_like(string, ESCAPE)
+        end
+
+        # ORs one LIKE per pattern, for the shortcuts that accept several
+        # literals the way String#start_with? does.
+        def self.any(operand, patterns)
+          patterns.map {|pattern| new(operand, pattern, ESCAPE) }.
+            inject {|left, right| Or.new(left, right) }
+        end
+
+        attr_reader :operand, :pattern, :escape
+
+        def initialize(operand, pattern, escape = nil)
+          @operand = operand
+          @pattern = pattern
+          @escape = escape
+        end
+
+        def to_arel(table)
+          # Arel matches case-insensitively unless told otherwise, which turns
+          # into ILIKE on PostgreSQL. like? means SQL LIKE on every adapter.
+          to_arel_operand(operand, table).matches(pattern, escape, true)
+        end
+      end
+
+      # Containment in a PostgreSQL array column.  The two flavors of "does it
+      # contain this?" split by name the way Ruby's own classes do: include? is
+      # String's substring match (LIKE), member? is Enumerable's element test,
+      # which String does not have.  The elements are rendered as an array
+      # literal, which PostgreSQL coerces to the column's element type, so any
+      # expression works as the operand and no schema lookup is needed.
+      class Member < Predicate
+        attr_reader :operand, :elements
+
+        def initialize(operand, element)
+          @operand = operand
+          @elements = element.is_a?(::Array) ? element : [element]
+        end
+
+        def to_arel(table)
+          arel_operand = to_arel_operand(operand, table)
+          arel_operand.contains(Arel::Nodes.build_quoted(array_literal))
+        end
+
+        private
+
+        # PostgreSQL array input syntax: elements joined by commas inside
+        # braces, and an element is double-quoted whenever it is empty, spells
+        # NULL, or contains a character the parser treats specially.
+        def array_literal
+          encoded = elements.map do |value|
+            s = value.to_s
+            if s.empty? || s.casecmp?("null") || s.match?(/[\s{},"\\]/)
+              "\"#{s.gsub(/["\\]/) {|c| "\\#{c}" }}\""
+            else
+              s
+            end
+          end
+          "{#{encoded.join(',')}}"
+        end
+      end
+
+      # Regular expression match: REGEXP on MySQL, ~ on PostgreSQL.  SQLite has
+      # no regexp operator built in, so Arel raises NotImplementedError there.
+      class Match < Predicate
+        attr_reader :operand, :pattern, :negated
+
+        def initialize(operand, pattern, negated: false)
+          @operand = operand
+          @pattern = pattern.is_a?(Regexp) ? regexp_source(pattern) : pattern
+          @negated = negated
+        end
+
+        def to_arel(table)
+          arel_operand = to_arel_operand(operand, table)
+          if negated
+            arel_operand.does_not_match_regexp(pattern)
           else
-            arel_column.public_send(OPERATOR_MAP.fetch(operator), arel_value)
+            arel_operand.matches_regexp(pattern)
+          end
+        end
+
+        private
+
+        # A Regexp literal reads naturally with =~, but only its source crosses
+        # over; the database has its own dialect and no notion of Ruby's flags.
+        # Dropping a flag would silently change what the query matches, so
+        # anything beyond a plain literal is refused rather than ignored.
+        def regexp_source(regexp)
+          unless regexp.options.zero?
+            raise ArgumentError,
+              "#{regexp.inspect} has options that SQL cannot express; " \
+              "pass the pattern as a string instead"
           end
+          regexp.source
         end
       end
 

data/lib/active_record/refined.rb

@@ -2,13 +2,7 @@ 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
+        import_methods AST::Predications
 
         %i[count sum average maximum minimum].each do |func|
           define_method(func) { AST::Aggregate.new(self, func) }
@@ -46,6 +40,10 @@ module ActiveRecord
       SCALAR_FUNCTIONS.each do |name|
         define_method(name) {|*args| AST::Function.new(name.to_s.upcase, args) }
       end
+
+      def exists?(relation)
+        AST::Exists.new(relation)
+      end
     end
 
     module QueryMethods

data/lib/activerecord-refined/version.rb

@@ -1,5 +1,5 @@
 module Activerecord
   module Refined
-    VERSION = '0.3.1'
+    VERSION = '0.3.3'
   end
 end