deli 0.5.0

data/lib/deli/query.rb

@@ -0,0 +1,133 @@
+module Deli
+  class Query
+    class << self
+      def parse_string(string)
+        parse_query(::URI.parse(string).query)
+      end
+      
+      # from rack
+      def parse_query(qs, d = nil)
+        params = {}
+        
+        (qs || '').split(d ? /[#{d}] */n : /[&;] */n).each do |p|
+          k, v = p.split('=', 2).map { |x| unescape(x) }
+          if cur = params[k]
+            if cur.class == Array
+              params[k] << v
+            else
+              params[k] = [cur, v]
+            end
+          else
+            params[k] = v
+          end
+        end
+        
+        return params
+      end
+      
+      # from rack
+      def unescape(string)
+        string.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n) { [$1.delete('%')].pack('H*') }
+      end
+      
+      # from rack, except we don't escape anything!
+      # keeps url's nicely formatted...
+      # up to you to make sure you have the right input
+      def build_query(params)
+        params.map do |k, v|
+          if v.class == Array
+            build_query(v.map { |x| [k, x] })
+          else
+            "#{k}=#{v}"
+          end
+        end.join("&").gsub(/\s+/, "+")
+      end
+    end
+    
+    attr_reader :controller
+    
+    def initialize(deli_controller)
+      @controller = deli_controller
+    end
+    
+    def matching(params)
+      controller.params.select do |param|
+        params[param.key].present?
+      end
+    end
+    
+    def find(key)
+      controller.params.detect do |param|
+        param.key == key
+      end
+    end
+    
+    def conditions?(params)
+      controller.params.select do |param|
+        param.key !~ /^(?:page|limit|sort)$/
+      end.any? do |param|
+        params[param.key].present?
+      end
+    end
+    
+    def append_join(key)
+      joins.push(key.to_sym)
+    end
+    
+    def joins
+      @joins ||= []
+    end
+    
+    def default_sort
+      if @default_sort_exists.nil?
+        sort = find("sort")
+        @default_sort_exists = sort.present? && sort.default.present?
+        @default_sort = sort.default if @default_sort_exists
+      end
+      
+      @default_sort
+    end
+    
+    def parse_string(string)
+      ::Deli::Query.parse_string(string)
+    end
+    
+    def parse_query(qs, d = nil)
+      ::Deli::Query.parse_query(qs, d)
+    end
+    
+    def parse(url_or_params)
+      case url_or_params
+      when ::String
+        parse_string(url_or_params)
+      else
+        url_or_params
+      end
+    end
+    
+    def render(params)
+      params = parse(params)
+      matching(params).inject({}) do |hash, param|
+        hash[param.key] = param.render(params[param.key])
+        hash
+      end
+    end
+    
+    def conditions(params)
+      to_conditions(render(params.except("page", "limit", "sort")))
+    end
+    
+    def to_conditions(hash)
+      keys   = []
+      values = []
+      hash.values.collect do |array|
+        keys << array[0]
+        values << array[1..-1]
+      end
+      
+      keys.map! {|i| "(#{i})"} if keys.length > 1
+
+      [keys.join(" AND "), *values.flatten]
+    end
+  end
+end

data/lib/deli/railtie.rb

@@ -0,0 +1,14 @@
+module Deli
+  class Railtie < Rails::Railtie
+    initializer "deli.insert_into_stack" do
+      ActiveSupport.on_load :active_record do
+        ::ActiveRecord::Base.send :extend, ::Deli::Pagination
+      end
+      
+      ActiveSupport.on_load :action_controller do
+        ActionController::Base.send :include, ::Deli::Helper
+        ActionView::Base.send :include, ::Deli::Helper
+      end
+    end
+  end
+end

data/spec/active_record_spec.rb

@@ -0,0 +1,358 @@
+require 'spec_helper'
+
+describe Deli::Adapters::ActiveRecord do
+  context "param:string" do
+    before do
+      @param = Deli::Adapters::ActiveRecord::String.new(:title)
+    end
+    
+    it "should render a simple string" do
+      result = ["title LIKE ?", "%Hello World%"]
+      @param.render("Hello World").should == result
+    end
+    
+    it "should split + into individual tokens" do
+      result = ["title LIKE ? AND title LIKE ?", "%Hello%", "%World%"]
+      @param.render("Hello+World").should == result
+    end
+    
+    context "query for exact matches" do
+      it "should split single quotes ' into tokens" do
+        result = ["title LIKE ?", "%Hello World%"]
+        @param.render("'Hello World'").should == result
+      end
+    
+      it "should query for exact matches: split single quotes ' into tokens, even with + signs" do
+        result = ["title LIKE ?", "%Hello World%"]
+        @param.render("'Hello+World'").should == result
+      end
+    end
+    
+    context "query negations" do
+      it "should render a simple string" do
+        result = ["title NOT LIKE ? AND title NOT LIKE ?", "%Hello%", "%World%"]
+        @param.render("-Hello+-World").should == result
+      end
+      
+      # NOT PASSING, FIX REGEX
+      # it "should not negate hyphenated phrases" do   
+      #   result = ["title LIKE ?", "%Hello-World%"]
+      #   @param.render("Hello-World").should == result
+      # end
+    end
+    
+    context "query OR" do
+      it "should render a simple string with +OR+" do
+        result = ["(title LIKE ?) OR (title LIKE ?)", "%Hello%", "%World%"]
+        @param.render("Hello+OR+World").should == result
+      end
+      
+      it "should render a simple string with pipe |" do
+        result = ["(title LIKE ?) OR (title LIKE ?)", "%Hello%", "%World%"]
+        @param.render("Hello|World").should == result
+      end
+      
+      it "should render a complex string" do
+        result = ["(title LIKE ? AND title LIKE ?) OR (title LIKE ?)", "%Hello%", "%World%", "%Query%"]
+        @param.render("Hello+World+OR+Query").should == result
+      end
+      
+      it "should with single quotes" do
+        result = ["(title LIKE ? AND title LIKE ?) OR (title LIKE ?)", "%Hello%", "%World%", "%ruby on rails%"]
+        @param.render("Hello+World+OR+'ruby+on+rails'").should == result
+      end
+      
+      it "should with multiple on each side" do
+        result = ["(title LIKE ? AND title LIKE ?) OR (title LIKE ? AND title LIKE ?)", "%Hello%", "%World%", "%Ruby%", "%Javascript%"]
+        @param.render("Hello+World+OR+Ruby+Javascript").should == result
+      end
+    end
+    
+    context "query start and end" do
+      it "should render start match" do
+        result = ["title LIKE ?", "%phone"]
+        @param.render("^phone").should == result
+      end
+      
+      it "should render end match" do
+        result = ["title LIKE ?", "phone%"]
+        @param.render("phone$").should == result
+      end
+    end
+  end
+  
+  context "param:number" do
+    before do
+      @param = Deli::Adapters::ActiveRecord::Number.new(:login_count)
+    end
+    
+    it "should render single digit numbers" do
+      num     = 8
+      result  = ["login_count = ?", num]
+      @param.render("8").should == result
+    end
+    
+    it "should render multiple digit numbers" do
+      num     = 1920
+      result  = ["login_count = ?", num]
+      @param.render("1_920").should == result
+    end
+    
+    it "should render negative single digit numbers" do
+      num     = -4
+      result  = ["login_count = ?", num]
+      @param.render("-4").should == result
+    end
+    
+    it "should render negative multiple digit numbers" do
+      num     = -470
+      result  = ["login_count = ?", num]
+      @param.render("-470").should == result
+    end
+    
+    it "should render range" do
+      result    = ["login_count >= ? AND login_count <= ?", 3, 21]
+      @param.render("3..21").should == result
+    end
+    
+    it "should render range with no end" do
+      result    = ["login_count >= ?", 3]
+      @param.render("3..n").should == result
+    end
+    
+    it "should render range with no start" do
+      result    = ["login_count <= ?", 21]
+      @param.render("n..21").should == result
+    end
+    
+    it "should render multiple numbers with OR" do
+      result    = ["(login_count = ?) OR (login_count = ?)", 10, 1000]
+      @param.render("10,1000").should == result
+    end
+    
+    it "should render multiple ranges with OR" do
+      result    = ["(login_count >= ? AND login_count <= ?) OR (login_count >= ? AND login_count <= ?)", 1, 10, 100, 1_000]
+      @param.render("1..10,100..1000").should == result
+    end
+    
+    it "should render multiple numbers with OR, along with a range" do
+      result    = ["(login_count = ?) OR (login_count = ?) OR (login_count >= ? AND login_count <= ?)", 1, 10, 100, 1_000]
+      @param.render("1,10,100..1000").should == result
+    end
+  end
+  
+  context "param:time" do
+    before do
+      @param = ::Deli::Adapters::ActiveRecord::Time.new(:created_at)
+    end
+    
+    it "should render single date" do
+      time   = Time.zone.parse("2011-02-01") # feb 1, 2011
+      result = ["created_at = ?", time]
+      @param.render("2011-02-01").should == result
+    end
+    
+    it "should render date range" do
+      starts_on = Time.zone.parse("2011-02-01")
+      ends_on   = Time.zone.parse("2011-03-01")
+      result    = ["created_at >= ? AND created_at <= ?", starts_on, ends_on]
+      @param.render("2011-02-01..2011-03-01").should == result
+    end
+    
+    it "should render date range with no end" do
+      starts_on = Time.zone.parse("2011-02-01")
+      result    = ["created_at >= ?", starts_on]
+      @param.render("2011-02-01..t").should == result
+    end
+    
+    it "should render date range with no start" do
+      ends_on   = Time.zone.parse("2011-03-01")
+      result    = ["created_at <= ?", ends_on]
+      @param.render("t..2011-03-01").should == result
+    end
+    
+    it "should render single time" do
+      time   = Time.zone.parse("2011-12-25@2am") # christmas morning
+      result = ["created_at = ?", time]
+      @param.render("2011-12-25@2am").should == result
+    end
+    
+    it "should render single complex time" do
+      time    = Time.zone.parse("2011-12-25@2:15:27am")
+      result  = ["created_at = ?", time]
+      @param.render("2011-12-25@2:15:27am").should == result
+    end
+  end
+  
+  context "param:sort" do
+    before do
+      @param = ::Deli::Adapters::ActiveRecord::Order.new(:sort)
+    end
+      
+    it "should render single sort param (defaults to ASC)" do
+      result = "created_at ASC"
+      @param.render("created_at").should == result
+    end
+    
+    it "should render single sort param DESC" do
+      result = "created_at DESC"
+      @param.render("created_at-").should == result
+    end
+    
+    it "should render single sort param ASC" do
+      result = "created_at ASC"
+      @param.render("created_at+").should == result
+    end
+    
+    it "should render mutiple sort params" do
+      result = "created_at ASC, name ASC"
+      @param.render("created_at,name+").should == result
+    end
+  end
+  
+  context ":query" do
+    context "raw" do
+      before do
+        @url = "http://site.com/search?title=Ruby+-'Hello+World'&created_at=t..2011-02-01&sort=created_at,title-&page=12&limit=20"
+        @params = {
+          :title      => "Ruby+-'Hello+World'",
+          :created_at => "t..2011-02-01",
+          :sort       => "created_at,title-",
+          :page       => "12",
+          :limit      => "20"
+        }.stringify_keys
+
+        @params.each do |k, v|
+          @params[k] = v.gsub("+", " ")
+        end
+      end
+
+      it "should parse raw query string" do
+        ::Deli::Query.parse_string(@url).should == @params
+      end
+
+      context "definitions" do
+        before do
+          @controller = ::Deli::Controller.new(:user) do
+            match :title, :type => :string
+            match :created_at, :type => :datetime
+          end
+        end
+
+        it "should has 5 params (title, created_at, sort, page, limit)" do
+          @controller.params.length.should == 5
+          %w(title created_at sort page limit).each do |key|
+            @controller.keys.include?(key).should == true
+          end
+        end
+        
+        it "should render query" do
+          query         = {
+            :conditions => ["(users.title LIKE ? AND users.title NOT LIKE ?) AND (users.created_at <= ?)", "%Ruby%", "%Hello World%", Time.zone.parse("2011-02-01")],
+            :limit      => 20,
+            :offset     => (12 - 1) * 20,
+            :order      => "users.created_at ASC, users.title DESC"
+          }
+          
+          @controller.render(@params).should == query
+        end
+      end
+      
+      context "database" do
+        before do
+          @controller = ::Deli::Controller.new(:user) do
+            match :first_name
+            match :last_name
+            match :created_at
+            match :has_bookmark, :to => {:bookmarks => :event}, :exact => true, :type => :string
+          end
+          User.delete_all
+          Bookmark.delete_all
+          @user = User.create(:first_name => "DaVinci")
+        end
+        
+        it "should query the database" do
+          params              = {"first_name" => "DaVinci+OR+Michelangelo"}
+          expected            = {:conditions => ["(users.first_name LIKE ?) OR (users.first_name LIKE ?)", "%DaVinci%", "%Michelangelo%"], :limit => 20}
+          result              = @controller.render(params)
+          result.should      == expected
+          result              = User.first(result)
+          result.should      == @user
+        end
+        
+        it "should parse to conditions array" do
+          params              = {"first_name" => "DaVinci|Michelangelo"}
+          expected            = {:conditions => ["(users.first_name LIKE ?) OR (users.first_name LIKE ?)", "%DaVinci%", "%Michelangelo%"], :limit => 20}
+          result              = @controller.render(params)
+          result.should      == expected
+          result              = User.first(result)
+          result.should      == @user
+        end
+        
+        it "should handle complex conditions" do
+          week_ago            = 1.week.ago.beginning_of_day
+          params              = {"created_at" => "#{week_ago.strftime("%Y-%m-%d")}..t", "first_name" => "DaVinci|Michelangelo"}
+          expected            = {:conditions => ["((users.first_name LIKE ?) OR (users.first_name LIKE ?)) AND (users.created_at >= ?)", "%DaVinci%", "%Michelangelo%", week_ago], :limit => 20}
+          result              = @controller.render(params)
+          result.should      == expected
+          result              = User.first(result)
+          result.should      == @user
+        end
+        
+        it "should create full activerecord hash" do
+          expected = {
+            :conditions => ["(users.first_name LIKE ?) OR (users.first_name LIKE ?)", "%DaVinci%", "%Michelangelo%"],
+            :limit      => 20,
+            :offset     => 80,
+            :order      => "users.created_at ASC"
+          }
+          params  = {"first_name" => "DaVinci|Michelangelo", "page" => "5", "limit" => "20", "sort" => "created_at"}
+          
+          @controller.render(params).should == expected
+        end
+        
+        # it "should automatically handle joins" do
+        #   expected = {
+        #     :conditions => ["(bookmarks.event = ?) AND ((users.first_name LIKE ?) OR (users.first_name LIKE ?))", "selected", "%DaVinci%", "%Michelangelo%"]
+        #     :limit      => 20,
+        #     :offset     => 80,
+        #     #:joins      => [" INNER JOIN \"bookmarks\" ON bookmarks.user_id = users.id "],
+        #     :order      => "users.created_at ASC",
+        #   }
+        #   params  = {"has_bookmark" => "selected", "first_name" => "DaVinci|Michelangelo", "page" => "5", "limit" => "20", "sort" => "created_at"}
+        #   
+        #   @controller.render(params).should == expected
+        # end
+        
+        it "should create a named scope" do
+          3.times { # 4 times total
+            @user = User.create(:first_name => "DaVinci")
+          }
+          
+          params  = {"first_name" => "DaVinci|Michelangelo", "limit" => "2", "sort" => "created_at"}
+          result  = User.paginate(@controller.render(params))
+          
+          result.class.should == ::ActiveRecord::Relation
+          result.count.should == 2
+          result.total_count.should == 4
+        end
+        
+        it "should handle named scopes on associations" do
+          params  = {"first_name" => "DaVinci|Michelangelo", "limit" => "2", "sort" => "created_at"}
+          @controller = ::Deli::Controller.new(:bookmark) do
+            match :first_name, :to => {:user => :first_name}, :type => :string
+            match :created_at
+          end
+          4.times {
+            Bookmark.create(:user => @user)
+          }
+          
+          result = @user.bookmarks.paginate(@controller.render(params)).joins(:user)
+          result.class.should == ::ActiveRecord::Relation
+          result.count.should == 2
+          result.total_count.should == 4
+        end
+      end
+    end
+  end
+end