sexy_scopes 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ce33d394e7388e54629f64eb7ffb6db752337088
-  data.tar.gz: 08ed0052a528fba6aec3bdfc27ef53e36c881790
+  metadata.gz: ea9d2e3c3ca0c50058139d67222d97894fb0192c
+  data.tar.gz: aa1d5490fe8d78f9a3323a25bf10e78cdf072909
 SHA512:
-  metadata.gz: fcf5492bd6d3717504dcf30371796781cd46d13ef5b9fc2de143925b93b6488141f9cf705348b20c0f77fe4e60dfc3b05b7bed8ce4a415a57407ecd381104d33
-  data.tar.gz: 490a59156615aeef8e8e94bafb92877c20ebf30680bac27120e5883913ac34da5cf724c694e5d19ea758c17b6fe03ed5a4aa8678f0fa5f5d8edea2227e0a95b1
+  metadata.gz: 08a625a5ff5b18d1a0955efcb48bd66093a794382b4d86ee8ad8676fdf28ad34a8aaabd86fa3b8c403a3d328c2b1f06bf72139a12b871dfbeb2d449d64992bea
+  data.tar.gz: 5ec1351dc43eebefeed0defc5ea6da10a9d56cfb41f9812b59e57160f9ed18da9891a5ce0da1ee418b892bd3baef8d76789e461f6ad19e24164ee25613f0f757

data/CHANGELOG.md

@@ -1,9 +1,24 @@
-### 0.6.0
+# Changelog
+All notable changes to this project will be documented in this file.
 
-- Drop support for Ruby < 1.9.2 and ActiveRecord < 3.1
-- Add support for JRuby and Rubinius
-- Integrate with Travis CI
+## 0.7.0 - 2014-07-23
 
-### 0.5.1
+### Added
+- Support for Regular Expressions with the `=~` and `!~` operators (PostgreSQL, MySQL & SQLite3)
+- Support for ActiveRecord 4.1
+- Support for Arel 6
+- Integration with Travis CI (https://travis-ci.org/samleb/sexy_scopes)
 
-- Initial stable release
+### Fixed
+- Existing class methods no longer overriden by dynamic method generation
+
+### Removed
+- Support for Ruby 1.9.2
+
+## 0.6.0 - 2013-05-29
+
+### Added
+- Support for JRuby and Rubinius
+
+### Removed
+- Support for Ruby < 1.9.2 and ActiveRecord < 3.1

data/README.md

@@ -1,11 +1,11 @@
 SexyScopes
 ==========
 
-[![Gem Version](https://badge.fury.io/rb/sexy_scopes.png)](https://rubygems.org/gems/sexy_scopes)
-[![Dependencies](https://gemnasium.com/samleb/sexy_scopes.png?travis)](https://gemnasium.com/samleb/sexy_scopes)
-[![Code Climate](https://codeclimate.com/github/samleb/sexy_scopes.png)](https://codeclimate.com/github/samleb/sexy_scopes)
-[![Build Status](https://api.travis-ci.org/samleb/sexy_scopes.png)](https://travis-ci.org/samleb/sexy_scopes)
-[![Coverage Status](https://coveralls.io/repos/samleb/sexy_scopes/badge.png)](https://coveralls.io/r/samleb/sexy_scopes)
+[![Gem Version](http://img.shields.io/gem/v/sexy_scopes.svg?style=flat)](https://rubygems.org/gems/sexy_scopes)
+[![Dependencies](https://img.shields.io/gemnasium/samleb/sexy_scopes.svg?style=flat)](https://gemnasium.com/samleb/sexy_scopes)
+[![Code Climate](https://img.shields.io/codeclimate/github/samleb/sexy_scopes.svg?style=flat)](https://codeclimate.com/github/samleb/sexy_scopes)
+[![Build Status](https://img.shields.io/travis/samleb/sexy_scopes.svg?style=flat)](https://travis-ci.org/samleb/sexy_scopes)
+[![Coverage Status](https://img.shields.io/coveralls/samleb/sexy_scopes.svg?style=flat)](https://coveralls.io/r/samleb/sexy_scopes)
 
 **Write beautiful and expressive ActiveRecord scopes without SQL**
 
@@ -168,16 +168,65 @@ Add this line to your application's Gemfile:
 
 And then execute:
 
-    $ bundle
+    bundle
 
 Or install it yourself as:
 
-    $ gem install sexy_scopes
+    gem install sexy_scopes
 
 Then require it in your application code:
 
     require 'sexy_scopes'
 
+Regular Expressions
+-------------------
+
+Did you know that most RDBMS come with pretty good support for regular expressions?
+
+One reason they're quite unpopular in Rails applications is that their syntax is really different amongst
+databases implementations.
+Let's say you're using SQLite3 in development, and PostgreSQL in testing/production, well that's quite a good reason
+not to use database-specific code, isn't it?
+
+Once again, SexyScopes comes to the rescue:
+The `=~` and `!~` operators when called with a regular expression will generate the SQL you don't want to know about.
+
+```ruby
+predicate = User.username =~ /^john\b(.*\b)?doe$/i
+
+# In development, using SQLite3:
+predicate.to_sql
+# => "users"."username" REGEXP '^john\b(.*\b)?doe$'
+
+# In testing/production, using PostgreSQL
+predicate.to_sql
+# => "users"."username" ~* '^john\b(.*\b)?doe$'
+```
+
+Now let's suppose that you want to give your admin a powerful regexp based search upon usernames, here's how
+you could do it:
+
+```ruby
+class Admin::UsersController
+  def index
+    @users = User.where(User.username =~ Regexp.compile(params[:query]))
+    respond_with @users
+  end
+end
+```
+
+Let's see what happens in our production logs (SQL included) when they try this new feature:
+
+```
+Started GET "/admin/users?query=bob%7Calice" for xx.xx.xx.xx at 2014-03-31 16:00:50 +0200
+  Processing by Admin::UsersController#index as HTML
+  Parameters: {"query"=>"bob|alice"}
+  User Load (0.1ms)  SELECT "users".* FROM "users"  WHERE ("users"."username" ~ 'bob|alice')
+```
+
+The proper SQL is generated, protected from SQL injection BTW, and from now on you have reusable code for 
+both you development and your production environment.
+
 Contributing
 ------------
 

data/lib/arel/visitors_extensions.rb

@@ -0,0 +1,89 @@
+require 'arel/visitors'
+
+module Arel
+  module Visitors
+    class ToSql
+      private
+      
+      def visit_Regexp(regexp, arg = nil)
+        source = SexyScopes.quote(regexp.source)
+        sexy_scopes_visit source, arg
+      end
+      
+      # Arel >= 4.0
+      if instance_method(:visit).arity > 1
+        alias_method :sexy_scopes_visit, :visit
+      else
+        def sexy_scopes_visit(node, arg = nil)
+          visit(node)
+        end
+      end
+      
+      # Arel >= 6.0
+      if instance_method(:accept).arity > 1
+        def reduce_visitor?
+          true
+        end
+      else
+        def reduce_visitor?
+          false
+        end
+      end
+    end
+    
+    class MySQL
+      private
+      
+      def visit_SexyScopes_Arel_Nodes_RegexpMatches(o, arg = nil)
+        regexp = o.right
+        right = SexyScopes.quote(regexp.source)
+        right = Arel::Nodes::Bin.new(right) unless regexp.casefold?
+        if reduce_visitor?
+          visit o.left, arg
+          arg << ' REGEXP '
+          visit right, arg
+        else
+          "#{sexy_scopes_visit o.left, arg} REGEXP #{visit right}"
+        end
+      end
+    end
+    
+    class PostgreSQL
+      private
+      
+      def visit_SexyScopes_Arel_Nodes_RegexpMatches(o, arg = nil)
+        regexp = o.right
+        operator = regexp.casefold? ? '~*' : '~'
+        right = SexyScopes.quote(regexp.source)
+        if reduce_visitor?
+          visit o.left, arg
+          arg << SPACE << operator << SPACE
+          visit right, arg
+        else
+          "#{sexy_scopes_visit o.left, arg} #{operator} #{visit right}"
+        end
+      end
+    end
+    
+    class Oracle
+      private
+      
+      def visit_SexyScopes_Arel_Nodes_RegexpMatches(o, arg = nil)
+        regexp = o.right
+        flags = regexp.casefold? ? 'i' : 'c'
+        flags << 'm' if regexp.options & Regexp::MULTILINE == Regexp::MULTILINE
+        if reduce_visitor?
+          arg << 'REGEXP_LIKE('
+          visit o.left, arg
+          arg << COMMA
+          visit regexp.source, arg
+          arg << COMMA
+          visit flags, arg
+          arg << ')'
+        else
+          "REGEXP_LIKE(#{sexy_scopes_visit o.left, arg}, #{visit regexp.source}, #{visit flags})"
+        end
+      end
+    end
+  end
+end

data/lib/sexy_scopes.rb

@@ -1,19 +1,42 @@
-require 'active_support/dependencies/autoload'
+require 'active_support/lazy_load_hooks'
+require 'sexy_scopes/version'
 
 module SexyScopes
-  %w( Version VERSION ).each do |constant|
-    autoload constant, 'sexy_scopes/version'
-  end
-  
-  extend ActiveSupport::Autoload
+  autoload :Arel, 'sexy_scopes/arel'
   
-  autoload :Wrappers
-  autoload :ExpressionWrappers
-  autoload :PredicateWrappers
+  class << self
+    AREL_6 = ::Arel::VERSION >= '6.0.0'
+    
+    def extend_expression(expression)
+      expression.extend(Arel::ExpressionMethods)
+    end
+    
+    def extend_predicate(predicate)
+      predicate.extend(Arel::PredicateMethods)
+    end
+    
+    def arel_6?
+      AREL_6
+    end
+    
+    if AREL_6
+      def quote(node, attribute = nil)
+        ::Arel::Nodes.build_quoted(node, attribute)
+      end
+    else
+      def quote(node, attribute = nil)
+        node
+      end
+    end
+    
+    alias_method :type_cast, :quote
+  end
 end
 
 if defined? Rails::Railtie
   require 'sexy_scopes/railtie'
 else
-  require 'sexy_scopes/active_record'
+  ActiveSupport.on_load :active_record do
+    require 'sexy_scopes/active_record'
+  end
 end

data/lib/sexy_scopes/active_record.rb

@@ -1,4 +1,3 @@
-require 'active_record'
 require 'sexy_scopes/active_record/class_methods'
 require 'sexy_scopes/active_record/dynamic_methods'
 

data/lib/sexy_scopes/active_record/class_methods.rb

@@ -1,11 +1,6 @@
-require 'sexy_scopes/arel'
-require 'sexy_scopes/wrappers'
-
 module SexyScopes
   module ActiveRecord
     module ClassMethods
-      include Wrappers
-
       # Creates and extends an Arel <tt>Attribute</tt> representing the table's column with
       # the given <tt>name</tt>.
       #
@@ -14,12 +9,11 @@ module SexyScopes
       # @note Please note that no exception is raised if no such column actually exists.
       #
       # @example
-      #   User.where(User.attribute(:score) > 1000)
-      #   # => SELECT "users".* FROM "users" WHERE ("users"."score" > 1000)
+      #   where attribute(:score) > 1000
       #
       def attribute(name)
         attribute = arel_table[name]
-        extend_expression(attribute)
+        SexyScopes.extend_expression(attribute)
       end
 
       # Creates and extends an Arel <tt>SqlLiteral</tt> instance for the given <tt>expression</tt>,
@@ -28,17 +22,12 @@ module SexyScopes
       # @param [String, #to_s] expression Any SQL expression.
       #
       # @example
-      #   def Circle.with_perimeter_smaller_than(perimeter)
-      #     where sql(2 * Math::PI) * radius < perimeter
-      #   end
-      #   
-      #   Circle.with_perimeter_smaller_than(20)
-      #   # => SELECT "circles".* FROM "circles" WHERE (6.283185307179586 * "circles"."radius" < 20)
+      #   where sql('LENGTH(email)') > 200
       #
       def sql_literal(expression)
         ::Arel.sql(expression.to_s).tap do |literal|
-          extend_expression(literal)
-          extend_predicate(literal)
+          SexyScopes.extend_expression(literal)
+          SexyScopes.extend_predicate(literal)
         end
       end
       alias_method :sql, :sql_literal

data/lib/sexy_scopes/active_record/dynamic_methods.rb

@@ -2,11 +2,14 @@ module SexyScopes
   module ActiveRecord
     module DynamicMethods
       private
-        # # @!visibility private
-        def respond_to_missing?(method_name, include_private = false) # :nodoc:
+        def respond_to_missing?(method_name, *)
           # super currently resolve to Object#respond_to_missing? which return false,
           # but future version of ActiveRecord::Base might implement respond_to_missing?
-          sexy_scopes_has_attribute?(method_name) || super
+          if @sexy_scopes_attribute_methods_generated
+            super
+          else
+            sexy_scopes_has_attribute?(method_name)
+          end
         end
         
         # Equivalent to calling {#attribute} with the missing method's <tt>name</tt> if the table
@@ -37,29 +40,31 @@ module SexyScopes
         #   # In these cases you'll have to use `attribute` explicitely
         #   User.attribute(:name)
         #
-        def method_missing(name, *args)
-          if sexy_scopes_has_attribute?(name)
-            sexy_scopes_define_attribute_method(name)
-            attribute(name)
-          else
+        def method_missing(name, *args, &block)
+          if @sexy_scopes_attribute_methods_generated
             super
+          else
+            sexy_scopes_define_attribute_methods
+            send(name, *args, &block)
           end
         end
-
-        def sexy_scopes_define_attribute_method(name)
-          class_eval <<-EVAL, __FILE__, __LINE__ + 1
-            def self.#{name}        # def self.username
-              attribute(:#{name})   #   attribute(:username)
-            end                     # end
-          EVAL
+        
+        def sexy_scopes_define_attribute_methods
+          @sexy_scopes_attribute_methods_generated = true
+          return unless sexy_scopes_is_table?
+          column_names.each do |name|
+            unless respond_to?(name, true)
+              define_singleton_method(name) { attribute(name) }
+            end
+          end
         end
-
+        
         def sexy_scopes_has_attribute?(attribute_name)
-          if equal?(::ActiveRecord::Base) || abstract_class? || !table_exists?
-            false
-          else
-            column_names.include?(attribute_name.to_s)
-          end
+          sexy_scopes_is_table? && column_names.include?(attribute_name.to_s)
+        end
+        
+        def sexy_scopes_is_table?
+          !(equal?(::ActiveRecord::Base) || abstract_class?) && table_exists?
         end
     end
   end

data/lib/sexy_scopes/arel.rb

@@ -1,34 +1,16 @@
+require 'arel/visitors_extensions'
+
 module SexyScopes
   module Arel
-    extend ActiveSupport::Autoload
-
-    autoload :MathMethods
-    autoload :PredicateMethods
-    autoload :BooleanMethods
-  end
-end
-
-module Arel
-  module Nodes
-    # <tt>Grouping</tt> nodes didn't include <tt>Arel::Predications</tt> before
-    # {https://github.com/rails/arel/commit/c78227d9b219933f54cecefb99c72bb231fbb8f2 this commit}.
-    #
-    # Here they are included explicitely just in case they're missing.
-    class Grouping
-      include Arel::Predications
-    end
+    autoload :ExpressionMethods, 'sexy_scopes/arel/expression_methods'
+    autoload :PredicateMethods, 'sexy_scopes/arel/predicate_methods'
     
-    # As <tt>SqlLiteral</tt> could be any arbitrary SQL expression, include <tt>Arel::Math</tt>
-    # to allow common mathematic operations.
-    #
-    # @see SexyScopes::ActiveRecord#sql_literal
-    class SqlLiteral
-      include Arel::Math
+    autoload :Predications, 'sexy_scopes/arel/predications'
+    autoload :Typecasting, 'sexy_scopes/arel/typecasting'
+    autoload :Math, 'sexy_scopes/arel/math'
+    
+    module Nodes
+      autoload :RegexpMatches, 'sexy_scopes/arel/nodes/regexp_matches'
     end
   end
-  
-  # @!visibility private
-  class SqlLiteral # :nodoc:
-    include Arel::Math
-  end
 end

data/lib/sexy_scopes/arel/expression_methods.rb

@@ -0,0 +1,9 @@
+module SexyScopes
+  module Arel
+    module ExpressionMethods
+      include ::Arel::Math
+      include Predications
+      include Math
+    end
+  end
+end