Location: New York

Description
A leading Investment Bank is looking for an expert level Ruby on Rails developer and works incredibly fast and loves challenging work environment. The job requires developing a world class Client Portal servicing the needs of the Investment Bank's client portfolio. If you want to learn Finance, you will get ample opportunity.... This is a fun, high profile project in the bank where you get to work with some cutting edge technology and with some really smart people.

To apply
Send your resume to arannyak.ghosh@hcl.in

Summary
Python is now an approved language in Google's yearly Code Jam coding contest.

For a number of years, Google has run a yearly coding contest named Code Jam. The smartest (young) programmers in the world compete against each other for prizes and fame.

There are 3 online rounds (September 5-6, September 14 and September 19). The top 100 will be invited for the final coding showdown at Google New York on October 27, 2006. All travel and accommodation expenses will be covered by Google and there will be over $165,000 in cash and prizes.

What's most exciting for me is that this year, for the first time, Python is one of the supported languages. (The others are C++, Java, C# and VB.NET.) I'm hoping that at least some of the finalists will get that far by exploiting Python's superior coding speed!

(Googlers, others involved in setting up the competition, and their families, etc., etc., are not allowed to participate, as is customary in such things.)

Untwisting Python Network Programming

Networking is an essential task in software applications nowadays. Many programming languages have support for network programming to various extents. While the core libraries of most languages allow low-level socket programming, other libraries and third-party extensions often facilitate higher-level Internet protocols. For example, Java has a standard API to access sockets and send emails (via the URL class), but other common Internet protocols are available through external libraries such as JavaMail, JTelnet, and JTA. Perl has a native Unix-style interface to sockets and convenient core modules such as IO::Socket, Net::POP3, Net::SMTP, and Net::FTP. To access Telnet programmatically in Perl, the CPAN module Net::Telnet is a good option.

Python is an exception--it has very good built-in support for both socket and various Internet protocols, including POP3, SMTP, FTP, Telnet, and Gopher. The Python core distribution contains many networking modules, such as socket, poplib, ftplib, smtplib, telnetlib, and gopherlib. Being components in a high-level programming language, these modules encapsulate the complexity of the underlying protocols and are very convenient to use. Twisted is also another powerful networking framework, which, unlike the core networking modules, adopts an asynchronous approach in the networking programs.

This article introduces basic client-side networking using both core Python modules and the Twisted framework. For its example, I will show how to send, receive, and delete emails, and conduct Telnet sessions. I have written two functionally equivalent examples, one using the core modules (mail-core.py) and another using Twisted (mail-twisted.py), with both start, stop, and interact with a server to process emails. These programs work with any standard-compliant SMTP and POP3 servers in sending and retrieving of emails. The starting and stopping of server are specific to the Apache James mail server, which I choose as a local testing server due to its ease of installation and its shutdown procedure in a Telnet session.

Sending Mails with smtplib

The core module smtplib provides a SMTP class that encapsulates the interactions to a SMTP server to send emails. Essentially, you create an SMTP instance with the address of the server specified, invoke sendmail to send the mail(s), and finally close the SMTP connection by the quit method:

def sendMail(host, addr, to, subject, content):
    import smtplib
    from email.MIMEText import MIMEText

    print "Sending mail from", addr, "to", to, "...",
    server = smtplib.SMTP(host)
    msg    = MIMEText(content)

    msg["Subject"] = subject
    msg["From"]    = addr
    msg["To"]      = to

    server.sendmail(addr, [to], msg.as_string())
    server.quit()
    print "done."

The sendmail method takes parameters of the sender's address, receivers's addresses in a list, and the content of the message. Because the message content should be in the MIME format, use the convenient class MIMEText (from email.MIMEText) to create a text message. Create a MIMEText with the message body, specify the subject, from, and to addresses with the dictionary-like syntax, and take it as a string when passing to sendmail.

This testing server accepts and relays emails from anyone, and this is the default configuration of the Apache James server. Although it is fine for a local testing server, most, if not all, SMTP servers in the Internet mandate certain security measures to fight spam. To use a SMTP object with a server that requires authentication, invoke the login(username, password) method before sending any message. This method keeps silent on success and raises an exception when the authentication fails.

Retrieving Emails with poplib

Retrieving emails is inherently more complex than sending: it involves identification of the user, getting the number of messages, and retrieving or deleting the messages. The POP3 class in the poplib module provides methods to do this:

def display(host, user, passwd, deletion = 0):
    import poplib, email
    pop3 = poplib.POP3(host)
    pop3.user(user)
    pop3.pass_(passwd)

    num = len(pop3.list()[1])
    print user, "has", num, "messages"

    format = "%-3s %-15s %s"

    if num > 0:
        if deletion:
            print "Deleting", num, "messages",
            for i in range(1, num+1):
                pop3.dele(i)
                print ".",
            print " done."
        else:
            print format % ("Num", "From", "Subject")
            for i in range(1, num+1):
                str = string.join(pop3.top(i, 1)[1], "\n")
                msg = email.message_from_string(str)
                print format % (i, msg["From"], msg["Subject"])
    pop3.quit()

Like the SMTP class, you can create a POP3 instance by specifying the mail server. Terminate the POP3 session with the quit method. Log in to the POP3 account with the methods user and pass_ with parameters of the user name and password respectively.

To get the number of messages in the server, you may use either the stat method or the list method. The stat method returns a tuple of two values: the number of messages and the total mailbox size. The list method, used in the example, returns the message list in the following form:

(response, ['mesg_num octets', ...], octets)

Here the second value is a list of strings, each stating the number and size of a message in the mailbox. The number of messages is the size of this list of strings.

Retrieve a message wholly with the method retr(message_index) or partially with top(message_index, number_of_lines). In both methods, the message index is 1-based and returns a message in the following form:

(response, ['line', ...], octets)

Typically, the second value in the results is the most interesting: it is a list of the lines of the message. The example program needs only to retrieve the header information, so it gets string containing all header plus one line of body text with string.join(pop3.top(i, 1)[1], "\n"), then uses email.message_from_string to parse the string to build a MIME message object. From the MIME message, you can fetch the email subject, sender address, and receiver address(es) via the standard dictionary syntax.

To delete a message in the mailbox, use the method dele(message_index). It sets the deletion flag of the specified message and then the server actually does the deletion when you close the POP3 session. If you have a program calling dele on a message but the message persists, check that the program actually invokes quit.

Conducting Telnet with telnetlib

The Apache James mail server comes with a batch file to start it. As a convenient option, the example program can invoke the batch file via a call to os.system.

def start():
    print "Starting server...",
    os.system("c:/apps/bin/james.bat")
    print "done."

def stop(host):
    import telnetlib
    print "Stoping server...",

    telnet = telnetlib.Telnet(host, 4555)
    telnet.read_until("Login id:")
    telnet.write("root\n")
    telnet.read_until("Password:")
    telnet.write("root\n")
    telnet.read_until("Welcome")
    telnet.write("shutdown\n")
    telnet.close()

    print "done."

Shutting down the server, on the other hand, requires a Telnet session. Manually, you can do it through a Telnet client program connected to port 4555 of the server. Enter the user name as root, password as root, and the command shutdown, respectively. To shutdown the server programmatically in Python, use class Telnet from the core module telnetlib.

To establish a Telnet session, create a Telnet object with the Telnet server address and port number specified. To interact with the telnet server, interleave calls to methods read_until and write. The read_until method reads data from the server until it receives a specified string, while the write method sends a string to the server. Note that the Apache James mail server expects a trailing carriage return in the string from the Telnet client, so the example appends "\n" to the end of the parameter to write. The Telnet session ends with the invocation of method close on the Telnet object.

The Twisted Framework

Beyond the core Python modules, Twisted is a networking framework in a different style. As demonstrated in the previous example, Python's core networking modules use a procedural approach. To perform a task, your code must invoke a method that holds the thread of execution until the task either completes successfully or fails. Such a method is straightforward to use since it is synchronous and communicates any results of execution to its caller by means of some return value. The code to perform a sequence of tasks simply invokes the appropriate methods one by one, possibly with some structural constructs and checking of return values.

On the other hand, the Twisted framework adopts a different approach of asynchronous invocation. A method call will schedule a task to do in the framework's execution thread, returning control to its caller immediately and before the completion of the task. An event-driven mechanism communicates the results of the execution. The object returned by the asynchronous method call can register success and failure callbacks that will be invoked when the scheduled task completes successfully and fails, respectively. Performing a sequence of tasks is relatively more complex, since you must typically define each task in a method registered as the success callback to the object returned by the previous task's method.

In Twisted, get used to receiving a Deferred (from twisted.internet.defer) object from an asynchronous method call. There is also a DeferredList object which can watch for asynchronous method calls completing or failing. The engine reactor (from twisted.internet) controls the framework's execution thread. Start it and shut it down with the methods run and stop, respectively.

Sending Mails the Twisted Way

The sendmail (from twisted.mail.smtp) method is the workhorse for sending mails in Twisted. It takes similar parameters as the sendmail method of a smtplib.SMTP object, with the additional first parameter of the SMTP host name. The return value is a Deferred object to which you can attach success and failure callback methods.

def sendMail(host, addr, to, subject, content):
    from twisted.mail.smtp import sendmail
    from email.MIMEText import MIMEText

    print "Sending mail from", addr, "to", to, "..."
    msg = MIMEText(content)

    msg["Subject"] = subject
    msg["From"]    = addr
    msg["To"]      = to

    return sendmail(host, addr, [to], msg.as_string())

def main():
    ...
    elif "s" == sys.argv[1]:
        print len(addrs), "messages to be sent."
        dlist = []

        for addr in addrs:
            toaddr = user + "@" + host
            text   = "Test mail: " + addr + " to " + toaddr
            dlist.append( sendMail(host, addr, toaddr, text, text) )

        DeferredList(dlist).addBoth(lambda _: reactor.stop())
        reactor.run()

To send more than one mails with sendmail, you don't need to attach the callbacks to each of the returned Deferreds. Instead, put the Deferreds in a list to create a DeferredList object. The code then attaches a callback to that single DeferredList object via its addBoth method. It will fire when all the sendmail actions succeed or any of them fails. The callback simply stops the Twisted's execution thread by reactor.stop(). Note that the tasks scheduled or registered by sendmail or addBoth are not executing until the call to reactor.run(), which starts Twisted's execution thread.

Retrieving Mails with Twisted

Programming a POP3 client to retrieve mails in the Twisted framework is more complex and takes more code. The logic to retrieve mails is all in a class that subclasses POPClient (from twisted.mail.pop3client). Due to the event-driven nature of Twisted, it's easier to define a method for each step, register the success, and failure callbacks to the method to enter the next step and handle any error, respectively.

from twisted.internet.protocol import ClientCreator
from twisted.mail.pop3client import POP3Client

class MyPOP3Client(POP3Client):

    def serverGreeting(self, msg):
        POP3Client.serverGreeting(self, msg)
        self.login(self.myuser, self.mypass).addCallbacks(
              self.do_stat, errorHandler)
              
    def do_stat(self, result):
        self.stat().addCallbacks(self.do_retrieve, errorHandler)

In the class MyPOP3Client, the first step to get mails is the serverGreeting method, which Twisted will invoke when the client starts. This method invokes the superclass's serverGreeting, and then logs in to the POP3 server with a user name and password. The login method returns a Deferred object, invoking the addCallbacks method to register the do_stat method (called upon successful login), and the errorHandler method (called on login error).

Similarly, the do_stat method invokes POP3Client's stat method to perform a POP3 STAT command, and registers the next step as do_retrieve. Because the call to method stat is asynchronous, it cannot return its results to the caller with return values. Instead, it passes the results as arguments to the success callback registered to the stat method. The second parameter to the do_retrieve method is a list, of which the first element is the number of messages in the POP3 account.

def do_retrieve(self, stats):
        self.format       = "%-3s %-15s %s"
        self.num_messages = stats[0]
        self.cur_message  = 0

        print self.myuser, "has", self.num_messages, "messages"

        if self.num_messages > 0:
            if deletion:
                print "Deleting", self.num_messages, "messages",
                self.delete(0).addCallbacks(self.do_delete_msg, errorHandler)
            else:
                print self.format % ("Num", "From", "Subject")
                self.retrieve(0).addCallbacks(self.do_retrieve_msg, errorHandler)
        else:
            reactor.stop()

    def do_retrieve_msg(self, lines):
        msg = email.message_from_string("\r\n".join(lines))
        print self.format % (self.cur_message, msg["From"], msg["Subject"])
        self.cur_message += 1
        if (self.cur_message < self.num_messages):
            self.retrieve(self.cur_message).addCallbacks(
                    self.do_retrieve_msg, errorHandler)
        else:
            reactor.stop()

If there is no message in the mailbox, the code calls reactor.stop to tell Twisted to shutdown. Otherwise, it invokes retrieve(0) to get the first message. Its success callback, do_retrieve_msg, handles the message by displaying its summary, and then retrieves the next message. Because the method do_retrieve_msg gets invoked for all subsequent messages, the code uses an instance variable, cur_message, to keep track of the current message number and to determine when it has handled all messages. When it has processed everything, it stops the Twisted main loop.

Because the logic of mail retrieval is similar to deletion, both features are in the same class, MyPOP3Client. The instance variable deletion denotes the current mode of working. You can see its initialization in __init__, along with the user name and password. More interesting is the setting of allowInsecureLogin to true, which allows login to a server without authentication challenge non-encrypted transport.

    def __init__(self):
        self.myuser   = user
        self.mypass   = passwd
        self.deletion = deletion
        self.allowInsecureLogin = True
        
    def do_delete_msg(self, str):
        print ".",
        self.cur_message += 1
        if (self.cur_message < self.num_messages):
            self.delete(self.cur_message).addCallbacks(
                    self.do_delete_msg, errorHandler)
        else:
            print " done."
            q = self.quit()
            q.addCallbacks(lambda _: reactor.stop(), errorHandler)

To delete a mail, call the delete method of class POP3Client. Similar to the core poplib module, this method just marks the mail for deletion, and the actual deletion occurs when you send the POP3 command QUIT to the server, as with the quit method. Finally, Twisted's execution thread stops when the quitting action completes.

pop3 = ClientCreator(reactor, MyPOP3Client)
d    = pop3.connectTCP(host, 110)
reactor.run()

With the implementation of the desired mail handling in class MyPOP3Client, you can launch the client. With its descriptive name, the class ClientCreator (from twisted.internet.protocol) provides a convenient way to start a communication client. This code passes the reactor and the MyPOP3Client class to create a ClientCreator, and begins the mail retrieval by calling connectTCP with the specified server and port number. Twisted's execution loop then kicks off by reactor.run().

Invoking do_retrieve_msg repeatedly for all messages is conceptually tedious and lengthy, when compared to the DeferredList mechanism which keeps track of several actions and gets notified when all actions complete, as in the case of sending mails. However, collecting the Deferreds of multiple calls to retrieve of POP3Client in a DeferredList simply does not work in Twisted (Versions 2.2.0 and 2.4.0). The success callback never gets invoked (see mail-twisted.py).

Doing Telnet with Twisted

Twisted can power a Telnet client in a way similar to, but simpler than, the POP3 client. the Telnet conversation logic goes in a subclass of Telnet (from twisted.conch.telnet).

def stop(host):
    from twisted.internet.protocol import ClientCreator
    from twisted.conch.telnet import Telnet

    class MyTelnet(Telnet):
        def dataReceived(self, data):
            if "Login id:" in data:
                self._write("root\n")
            elif "Password:" in data:
                self._write("root\n")
            elif "Welcome" in data:
                d = self._write("shutdown\n")

        def connectionLost(self, reason):
            reactor.stop()
            print "done."

    mytelnet = ClientCreator(reactor, MyTelnet)
    d = mytelnet.connectTCP(host, 4555)
    reactor.run()

The class MyTelnet overrides two methods of class Telnet. The first method, dataReceived, is called when data arrives at the client. It checks the data received and calls the _write method to send the user name, password, or the shutdown command accordingly to the server. The second method is connectionLost, which Twisted calls when the server closes the telnet session. In that case, the program simply terminates the Twisted execution loop. The Telnet client starts by using the ClientClient class, connected to port 4555 of the James mail server.

When to Be Twisted?

The two functionally equivalent programs, one using Python core modules and the other using the Twisted framework, significantly differ from each other in terms of programming style and the amount of code. Then when should you use either of the two options?

For basic programs such as the command-line client of this example, the Python core networking modules are more desirable due to the simplicity and performance advantages. However, most real-world networking programs are very complex, and Twisted's asynchronous programming model is more effective. For example, BitTorrent, the popular peer-to-peer file sharing client that performs massive parallel downloading of data chunks from different sources, uses Twisted. Twisted also works well in programs with graphical user interface (GUI), because its asynchronous nature fits more seamlessly with the event-driven programming models of modern GUI frameworks. In fact, Twisted has integration with popular GUI frameworks including PyGTK, Qt, Tkinter, WxPython, and Win32.

The other area where Twisted shines is in server programming. A typical network server uses multithreading so that it can handle multiple clients concurrently. The asynchronous mechanism of Twisted alleviates the creation and handling of threads by server programs. In addition, Twisted provides several protocols on which to build new networking services, enabling rapid development of complex servers. One such project is Quotient, which adopts Twisted to build a multiprotocol messaging server that supports a variety of protocols and services including SMTP, POP3, IMAP, webmail, and SIP.

Kendrew Lau is a consultant in Hong Kong, with focus on Java, Linux, and other OSS technologies.

Return to the Python DevCenter.

Copyright © 2006 O'Reilly Media, Inc.

Work like you don't need the money;
dance like no one is watching;
sing like no one is listening;
love like you've never been hurt;
and live life every day as if it were your last.

转贴未名的趣文一篇和感人贴一篇：

发信人: yting (贝贝壳), 信区: Beauty
标  题: 来试试改变心情
发信站: 北大未名站 (2003年05月18日14:53:48 星期天), 转信

按我说的方法可能会改变你的心情哟：

在一张纸上写下你的名字，然后在第一个字上面写下M，在左边写下E，在下面写下W，

在最后一个字下面写上W，在右边写下Q，然后

用弧线把字母连起来，然后你会发现……我给你惊喜哟

写在前头：
这是我的好友在异国结婚时，他父亲从大陆寄来的信，结婚当日司仪当众就把全文朗颂出来，那是我见过最安静的一次请客场合，在场学生无不为其父母的挚爱而感动，虽然事隔多年但那个场景仍然深深印在脑海中，这篇文章後来流传开了，我则是一直保存到现在，希望能对你们有所启示．
　　　

家——不是讲理的地方
一份不在婚礼上的家长致辞

萍儿：
爸妈听到你要结婚喜讯，真为你高兴，远隔千里，我们不能参加你的婚礼，不能在婚礼上献上我们的家长致辞，这是我们内心的一点遗憾．但你是我们的女儿，相信你能理解爸妈的一份感受．那天放下电话，我和你妈沈默了良久－－我们的孩子怎么一下子就长大了？後来，你妈对著镜子淡淡地说：你看，我的白头发又多了，萍儿也该结婚了．我数著你妈的白发，那些白发竟像许多往事，一件一件浮上心头．你妈提醒我：还是给女儿写一封信吧！就算是我们送你的一份新婚礼物．

萍儿，我们只是天底下最平凡的父母，我们的孩子也只是天底下最平凡的女儿，我们不奢求太多，只是希望我的孩子踏上婚姻之路，走向人生之旅後，能满怀感恩，一路平安在这里，给你一个我们的生活体会．

先要告诉你：家不是一个讲理的地方．这句话听起来，很没有道理，但千真万确，这句话是真理，是至理，是多少夫妇，多少家庭（包括我们家）用多少岁月，多少辛酸，多少爱恨，多少是非，多少对错，在纠缠不清难解难分的混乱中，梳理出来的一个最後结论．

当夫妇之间开始据理力争时，家里便开始布上阴影．两人都会不自觉地各抱一堆面目全非的歪理，敌视对方，伤害对方，最後只能两败俱伤，难以收拾．多少夫妻，为了表面的一个〔理〕，落得负心无情．他们不知道，家不是讲理的地方，不是算帐的地方．

那么，何为（家），家是什么地方？萍儿，我们年轻的时候，也回答不了这个问题；也像许多夫妻那样，为一点小事争闹不休．那一年为了你小叔的调动问题，我和你妈大吵了一场，甚至闹到要离婚的地步．只是在那个时代我们还缺乏勇气．

直到有一天，一位老战友在他孩子的婚礼上说：希望你白头偕老，相爱永远时，爱这简短的字，像春雷响在我心里．是的，家不是讲理的地方，家该是讲爱的地方．爱一时很容易，爱一生一世却不容易，这里面有许多妙处需要我们去总结和体会．
　　　　
其次我们要告诉你：婚姻是个空盒子，你必须往里面放东西，才能取回你要的东西；你放的愈多，得到的也就愈多．很多人结婚时，对婚姻有许多期盼，期盼从中可以得到富贵，藉慰，爱情，宁静，快乐，健康，其实婚姻开始的时候，只是一个空盒子．走到一起的两个人，一定要养成一个习惯，去给，去爱，彼此侍奉，彼此赞赏，日後，那个空盒子才会日渐丰富起来．

空盒子最先该放的应该是（思念），思念是一种使我们刻骨铭心的东西．它是两个人有了肯定，有了情感，然後进而关怀，进而疼爱的一种情绪．（思念）是疲惫时通向家里的一条小路，是寒冷冬夜里的一股暖意，是匆忙推开家门後扑面而来家饭香....

空盒子里还要放进（艺术），婚姻生活中的艺术．在婚姻生活中，需要讲艺术的地方无处不在，生气有艺术，吵架有艺术．有一对夫妇含辛茹苦养育了五个孩子，其中之艰难，只有他们自己能体会．一天，夫妻为了孩子的一件小事吵起来，越吵越厉害，眼看不可收拾了，妻子突然说：等一下，我要去生孩子了．这句话，就是吵架的艺术．

婚姻的盒子里，除了放（思念）和（艺术）外，还有许多东西，都可以放进去，这有待於你们自己去填补．写到这里想到一位作家说过的一句话：你们生养他，教育他，你们的责任已尽，而你们给他最好的礼物，是一对翅膀．

萍儿，这封信，就是爸妈送给你的结婚礼物，我们希望你带著我们的祝福，快乐的飞翔！

爸爸，妈妈

爱一个人
要了解，也要开解；要道歉，也要道谢；
要认错，也要改错；要体贴，也要体谅；
是接受，而不是忍受；是宽容，而不是纵容；

是支持，而不是支配；是慰问，而不是质问；
是倾诉；而不是控诉；是难忘；而不是遗忘；
是彼此交流，而不是凡事交代；
是为对方默默祈求，而不是向对方诸多要求；
可以浪漫，但不要浪费；
可以随时牵手，但不要随便分手；
以上的都做到了，即使不再爱一个人 ，
也只有怀念，而不会怀恨 。

从段伟那看到的,大家可以试试,一会在comments里说我做的结果:)

问题1：Sergey Brin、Jerry Yang和Bill Gates同时爱上了一个姑娘，为了决定他们谁能娶这个姑娘，他们决定用手枪进一次决斗。 Gates的命中率是30％，Yang比他好些，命中率是50％，最出色的枪手是年轻的Brin，从不失误，他的命中率是100％。由于这个显而易见的事实，为公平起见，他们决定按这样的顺序：Gates先开枪，Yang第二，Brin最后一个。然后这样循环，直到他们只剩下一个人。问题是： (1) 首先，猜猜Sergey Brin、Jerry Yang和Bill Gates都是谁？ (2) 显然Brin、Yang和Gates都是绝顶聪明的人，那么这三个人中谁活下来的机会最大呢？ (3) 前两枪他们都应该采取什么样的策略？

New release of ez_where plugin

Posted by ezmobius 17 days ago

cond = EZ::Where::Condition.new :my_table do
  title =~ "%#{params[:search]}%" unless params[:search].blank?
  user == params[:user] unless params[:user].blank?
end

cond = EZ::Where::Condition.new :my_table do
  title =~ "%#{params[:search]}%"
  user == params[:user]
end

# find all posts where with body LIKE '%rails%'
@posts = Post.find_where(:all) { |p| p.body =~ "%rails%" }
=>  ["posts.body LIKE ?", "%rails%"]

# find all posts where with title, body or extended LIKE '%rails%'
@posts = Post.find_where :all do |post|
  post.any_of(:title, :body, :extened) =~ '%rails%'
end  
=> ["(posts.title LIKE ? OR posts.body LIKE ? 
    OR posts.extended LIKE ?)", "%rails%", "%rails%", "%rails%"]

# find all articles with title, body or extended LIKE "%#{params[:search]}%"
# AND (author.name = params[:author] OR comment.body LIKE "%#{params[:search]}%")
@articles = Article.find_where(:all, :include => [:author, { :comments => :users }]) do
  |article, author, comment|
   article.any_of(:title, :body, :extended) =~ "%#{params[:search]}%"
   any {
     author.name == params[:author]
     comment.body =~ "%#{params[:search]}%"
   }
end
=>["(articles.title LIKE ? OR articles.body LIKE ? 
   OR articles.extended LIKE ?) AND ((authors.name = ?)
   OR (comments.body LIKE ?))", "%foo%", "%foo%", "%foo%", "Ezra", "%foo%"]


     One of the coolest new features is the c method. This promotes conditions
into first class objects. It works like this:

c{ title =~ '%foo%' }.to_sql
=> ["title LIKE ?", "%foo%"]
With a naked block like this it just converts whats inside the block 
into a condition.


c(:posts) {  title =~ '%foo%' }.to_sql  
=> ["posts.title LIKE ?",  "%foo%"] 
When you give it a plural table name as  an arguments it scopes the condition to that
table.

You can also use the c object directly in a find like so:

Post.find :all, :conditions => c{ body =~ '%rails%' }


Now that you can have conditions as objects you can do some really interesting
and complex queries with them. You can use operators to define how 
the conditions get strung together. So:

+ == AND   
| == OR      
- == AND NOT 

For example:

cond1 = c(:posts) { body =~ '%rails%'}
cond2 = c(:comments) { username == 'ezmobius'}
cond3 = c(:posts) { author_id === (1..4) }
(cond1 + cond2 | cond3).to_sql
=> ["((posts.body LIKE ?) AND (comments.username = ?)) 
    OR (posts.author_id IN (?))", "%rails%", "ezmobius", [1, 2, 3, 4]]
    
Now you can pass these into a find like this and .to_sql will 
automatically be called on the compound condition:

Post.find :all, :conditions => (cond1 + cond2 | cond3)

You can also build up one compound condition use +=, -= or |=
 
cond = c{ title =~ '%ruby%' }
cond += c{ description =~ '%ez-where%' }
cond |= c{ user_id === (1..5) }
cond -= c{ pub_date > Time.now.to_s(:db) }
Post.find :all, :conditions => cond
=> ["((title LIKE ?) AND (description LIKE ?)) 
    OR ((user_id IN (?)) AND NOT (pub_date > ?))",
    "%ruby%", "%ez-where%", [1, 2, 3, 4, 5], "2006-06-21 01:17:47"]