activerecord-refined 0.3.0 → 0.3.2

data/lib/active_record/refined/ast.rb

@@ -1,6 +1,71 @@
 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
+        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 <(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?(prefix)
+          Like.new(self, "#{Like.escape(prefix)}%", Like::ESCAPE)
+        end
+
+        def end_with?(suffix)
+          Like.new(self, "%#{Like.escape(suffix)}", Like::ESCAPE)
+        end
+
+        def include?(substring)
+          Like.new(self, "%#{Like.escape(substring)}%", Like::ESCAPE)
+        end
+      end
+
       class Node
         def to_arel(table)
           raise ScriptError, "subclass must override this method"
@@ -17,6 +82,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 +111,8 @@ module ActiveRecord
       end
 
       class Column < Node
+        include Predications
+
         attr_reader :table_name, :column_name
 
         def initialize(table_name, column_name)
@@ -45,20 +124,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 +140,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 +153,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 +166,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 +183,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 +209,88 @@ 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.
+      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)
+          else arel_operand.in(values)
+          end
+        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
+
+        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
+
+      # 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) }

data/lib/activerecord-refined/version.rb

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