epoxy 0.2.1 → 0.3.0

data/README.rdoc

@@ -1,19 +1,33 @@
-= Epoxy - bind data to queries for any query language.
-
-Let me hit ya with some science!
+ = Epoxy - bind data to queries for any query language.
+ 
+ Let me hit ya with some science!
 
+    # numbered binds
     ep = Epoxy.new("select * from foo where bar=?")
     binds = %W[foo]
     bound_query = ep.quote { |x| "'" + binds[x] + "'" }
     "select * from foo where bar='foo'"
 
-Epoxy handles:
+    # named binds
+    binds = { :name => 'Lee', :age => 132 }
+    ep = Epoxy.new("select * from people where name=?name and age=?age")
+    bound_query = ep.quote(binds) { |x| "'#{binds[x]}'" }
+    "select * from people where name='Lee' and age='132'"
 
-* ? for numbered binds (named binds coming soon!)
-* ?? for a *real* question mark
-* '?' for a *real* question mark
-* comments, weird quoting styles (look at the "holy shit" test for examples)
-* not telling you how to quote your data. This solution works for any query language and any database.
+    # mix them!
+    binds = { 0 => "Age", :name => 'Lee' }
+    ep = Epoxy.new("select * from people where name=?name and age=?")
+    bound_query = ep.quote(binds) { |x| "'#{binds[x]}'" }
+    "select * from people where name='Lee' and age='Age'"
+ 
+ Epoxy handles:
+ 
+ * ?<name> for named binds
+ * ? for numbered binds
+ * ?? for a *real* question mark
+ * '?' for a *real* question mark
+ * comments, weird quoting styles (look at the "holy shit" test for examples)
+ * not telling you how to quote your data. This solution works for any query language and any database.
 
 == Note on Patches/Pull Requests
  

data/Rakefile

@@ -11,6 +11,7 @@ begin
     gem.homepage = "http://github.com/erikh/epoxy"
     gem.authors = ["Erik Hollensbe"]
     gem.add_development_dependency 'rdoc'
+    gem.add_development_dependency 'test-unit'
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new
@@ -43,7 +44,7 @@ task :test => :check_dependencies
 task :default => :test
 
 task :to_blog => [:clobber_rdoc, :rdoc] do
-    sh "rm -fr $git/blog/content/docs/epoxy && mv rdoc $git/blog/content/docs/epoxy"
+  sh "rm -fr $git/blog/content/docs/epoxy && mv rdoc $git/blog/content/docs/epoxy"
 end
 
 require 'rdoc/task'
@@ -56,3 +57,5 @@ RDoc::Task.new do |rdoc|
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+# vim: syntax=ruby ts=2 et sw=2 sts=2

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.3.0

data/lib/epoxy.rb

@@ -1,92 +1,124 @@
 # = Epoxy - bind data to queries for any query language.
 # 
 # Let me hit ya with some science!
-# 
-#     ep = Epoxy.new("select * from foo where bar=?")
-#     binds = %W[foo]
-#     bound_query = ep.quote { |x| "'" + binds[x] + "'" }
-#     "select * from foo where bar='foo'"
+#
+#    # numbered binds
+#    ep = Epoxy.new("select * from foo where bar=?")
+#    binds = %W[foo]
+#    bound_query = ep.quote { |x| "'" + binds[x] + "'" }
+#    "select * from foo where bar='foo'"
+#
+#    # named binds
+#    binds = { :name => 'Lee', :age => 132 }
+#    ep = Epoxy.new("select * from people where name=?name and age=?age")
+#    bound_query = ep.quote(binds) { |x| "'#{binds[x]}'" }
+#    "select * from people where name='Lee' and age='132'"
+#
+#    # mix them!
+#    binds = { 0 => "Age", :name => 'Lee' }
+#    ep = Epoxy.new("select * from people where name=?name and age=?")
+#    bound_query = ep.quote(binds) { |x| "'#{binds[x]}'" }
+#    "select * from people where name='Lee' and age='Age'"
 # 
 # Epoxy handles:
 # 
-# * ? for numbered binds (named binds coming soon!)
+# * ?<name> for named binds
+# * ? for numbered binds
 # * ?? for a *real* question mark
 # * '?' for a *real* question mark
 # * comments, weird quoting styles (look at the "holy shit" test for examples)
 # * not telling you how to quote your data. This solution works for any query language and any database.
 #
 class Epoxy
-    #
-    # Token parser, isolates components of the query into parts to where they
-    # can be managed indepdently.
-    #
-    # Probably not the easiest thing to deal with by itself. Use the standard
-    # methods plox.
-    def self.parse_tokens(query, comment_chars)
-        query.scan(%r{
-            (
-                #{comment_chars}.*                               (?# matches "--" style comments to the end of line or string )
-                |
-                ' ( [^'\\]  |  ''  |  \\. )* '      (?# match strings surrounded by apostophes )
-                |
-                " ( [^"\\]  |  ""  |  \\. )* "      (?# match strings surrounded by " )
-                |
-                ['"]                                (?# match a loose quote ) 
-                |
-                \?\??                               (?# match one or two question marks )
-                |
-                [^-/'"?]+                           (?# match all characters except ' " ? - and / )
-
-            )
-        }x).collect(&:first)
-    end
+  #
+  # Token parser, isolates components of the query into parts to where they
+  # can be managed indepdently.
+  #
+  # Probably not the easiest thing to deal with by itself. Use the standard
+  # methods plox.
+  def self.parse_tokens(query, comment_chars)
+    a = query.scan(%r{
+      (
+        #{comment_chars}.*                  (?# matches "--" style comments to the end of line or string )
+        |
+        ' ( [^'\\]  |  ''  |  \\. )* '      (?# match strings surrounded by apostophes )
+        |
+        " ( [^"\\]  |  ""  |  \\. )* "      (?# match strings surrounded by " )
+        |
+        ['"]                                (?# match a loose quote ) 
+        |         
+        \?[a-zA-Z]+                         (?# match a named bind )
+        |
+        \?\??                               (?# match one or two question marks )
+        |
+        [^-/'"?:]+                          (?# match all characters except ' " ? - : and / )
+    )
+    }x).collect(&:first)
+  end
 
-    # tokens generated by Epoxy.parse_tokens. Just use Epoxy#quote for now.
-    attr_reader :tokens
-    # the original query, before quoting.
-    attr_reader :query
-    # leader comment characters - defaults to SQL "--"
-    attr_reader :comment_chars
+  # tokens generated by Epoxy.parse_tokens. Just use Epoxy#quote for now.
+  attr_reader :tokens
+  # the original query, before quoting.
+  attr_reader :query
+  # leader comment characters - defaults to SQL "--"
+  attr_reader :comment_chars
 
-    #
-    # Takes a query as a string and an optional regexp defining
-    # beginning-of-line comments. The binding rules are as follows:
-    #
-    # * ? for numbered binds (named binds coming soon!)
-    # * ?? for a *real* question mark
-    # * '?' for a *real* question mark
-    # * comments, weird quoting styles are unaffected.
-    #
-    def initialize(query, comment_chars=%r{--|//})
-        @comment_chars = comment_chars
-        @query  = query
-        @tokens = self.class.parse_tokens(query, @comment_chars)
-    end
+  #
+  # Takes a query as a string and an optional regexp defining
+  # beginning-of-line comments. The binding rules are as follows:
+  #
+  # * ?<name> for named binds
+  # * ? for numbered binds
+  # * ?? for a *real* question mark
+  # * '?' for a *real* question mark
+  # * comments, weird quoting styles are unaffected.
+  #
+  def initialize(query, comment_chars=%r{--|//})
+    @comment_chars = comment_chars
+    @query  = query
+    @tokens = self.class.parse_tokens(query, @comment_chars)
+  end
 
-    #
-    # Processes your query for quoting. Provide a block that emulates how your
-    # data should be quoted, and it will yield on each successive bound element
-    # with the index of that element passed.
-    #
-    # *You* are responsible for quoting your data properly. Epoxy just makes it
-    # easier to get the places you need to quote out of the query.
-    #
-    def quote(&block)
-        result = ""
-        bind_pos = 0
+  #
+  # Processes your query for quoting. Provide a block that emulates how your
+  # data should be quoted. This method accepts a Hash to process named bindings,
+  # which when provided will yield each successive Hash key which has a match
+  # in the named binds. <b>Keys are coerced to symbols before being yielded.</b>
+  #
+  # Without a Hash it will yield on each successive bound element
+  # with the index of that element passed.
+  # 
+  # *You* are responsible for quoting your data properly. Epoxy just makes it
+  # easier to get the places you need to quote out of the query.
+  #
+  def quote(binds = {}, &block)
+    result = ""
+    bind_pos = 0
 
-        tokens.each do |part|
-            case part
-            when '?'
-                result << block.call(bind_pos)
-                bind_pos += 1
-            when '??'
-                result << "?"
-            else
-                result << part
-            end
+    unless binds.empty?
+      tokens.each do |token|
+        binds.each do |key, rep|
+          if token == "?#{key}"
+            token.replace block.call(key.to_sym)
+          end
         end
+      end
+    end
 
-        return result
+    tokens.each do |part|
+      case part
+      when '?'
+        result << block.call(bind_pos)
+        bind_pos += 1
+      when '??'
+        result << "?"
+      else
+        result << part
+      end
     end
+
+    return result
+  end
 end
+
+# vim: syntax=ruby ts=2 et sw=2 sts=2

data/test/helper.rb

@@ -8,3 +8,5 @@ require 'epoxy'
 
 class Test::Unit::TestCase
 end
+
+# vim: syntax=ruby ts=2 et sw=2 sts=2

data/test/test_epoxy.rb

@@ -1,142 +1,208 @@
 require 'helper'
 
 class TestEpoxy < Test::Unit::TestCase
-    def test_01_basic
-        ep = Epoxy.new("select * from foo where bar=?")
-        assert(ep)
-        assert_kind_of(Epoxy, ep)
+  def test_01_basic
+    ep = Epoxy.new("select * from foo where bar=?")
+    assert(ep)
+    assert_kind_of(Epoxy, ep)
 
-        assert_equal("select * from foo where bar='foo'", ep.quote { |x| "'foo'" })
-    end
+    assert_equal("select * from foo where bar='foo'", ep.quote { |x| "'foo'" })
+  end
 
-    def test_02_literal_question_mark
-        ep = Epoxy.new("select ?? from foo where bar=?")
-        assert_equal("select ? from foo where bar='foo'", ep.quote { |x| "'foo'" })
+  def test_02_literal_question_mark
+    ep = Epoxy.new("select ?? from foo where bar=?")
+    assert_equal("select ? from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select ??? from foo where bar=?")
-        assert_equal("select ?'foo' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select ??? from foo where bar=?")
+    assert_equal("select ?'foo' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select ???? from foo where bar=?")
-        assert_equal("select ?? from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select ???? from foo where bar=?")
+    assert_equal("select ?? from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select ????? from foo where bar=?")
-        assert_equal("select ??'foo' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select ????? from foo where bar=?")
+    assert_equal("select ??'foo' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select '?' from foo where bar=?")
-        assert_equal("select '?' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select '?' from foo where bar=?")
+    assert_equal("select '?' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select '?'? from foo where bar=?")
-        assert_equal("select '?''foo' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select '?'? from foo where bar=?")
+    assert_equal("select '?''foo' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select '?''?' from foo where bar=?")
-        assert_equal("select '?''?' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select '?''?' from foo where bar=?")
+    assert_equal("select '?''?' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select ?'?' from foo where bar=?")
-        assert_equal("select 'foo''?' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select ?'?' from foo where bar=?")
+    assert_equal("select 'foo''?' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select ?'?'? from foo where bar=?")
-        assert_equal("select 'foo''?''foo' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select ?'?'? from foo where bar=?")
+    assert_equal("select 'foo''?''foo' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select '?'?'? from foo where bar=?")
-        assert_equal("select '?''foo'''foo' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select '?'?'? from foo where bar=?")
+    assert_equal("select '?''foo'''foo' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select '?'?'?' from foo where bar=?")
-        assert_equal("select '?''foo''?' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select '?'?'?' from foo where bar=?")
+    assert_equal("select '?''foo''?' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select '?'?? from foo where bar=?")
-        assert_equal("select '?'? from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select '?'?? from foo where bar=?")
+    assert_equal("select '?'? from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select '?'??? from foo where bar=?")
-        assert_equal("select '?'?'foo' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select '?'??? from foo where bar=?")
+    assert_equal("select '?'?'foo' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select ??'?'??? from foo where bar=?")
-        assert_equal("select ?'?'?'foo' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select ??'?'??? from foo where bar=?")
+    assert_equal("select ?'?'?'foo' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select ???'?'??? from foo where bar=?")
-        assert_equal("select ?'foo''?'?'foo' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select ???'?'??? from foo where bar=?")
+    assert_equal("select ?'foo''?'?'foo' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select ''? from foo where bar=?")
-        assert_equal("select '''foo' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select ''? from foo where bar=?")
+    assert_equal("select '''foo' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select '''? from foo where bar=?")
-        assert_equal("select ''''foo' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select '''? from foo where bar=?")
+    assert_equal("select ''''foo' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select ''?' from foo where bar=?")
-        assert_equal("select '''foo'' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select ''?' from foo where bar=?")
+    assert_equal("select '''foo'' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select ''?'' from foo where bar=?")
-        assert_equal("select '''foo''' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select ''?'' from foo where bar=?")
+    assert_equal("select '''foo''' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select ''??' from foo where bar=?")
-        assert_equal("select ''?' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select ''??' from foo where bar=?")
+    assert_equal("select ''?' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select '?''?' from foo where bar=?")
-        assert_equal("select '?''?' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select '?''?' from foo where bar=?")
+    assert_equal("select '?''?' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select '?'''?' from foo where bar=?")
-        assert_equal("select '?''''foo'' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select '?'''?' from foo where bar=?")
+    assert_equal("select '?''''foo'' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select '?''''?' from foo where bar=?")
-        assert_equal("select '?''''?' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select '?''''?' from foo where bar=?")
+    assert_equal("select '?''''?' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select '??' from foo where bar=?")
-        assert_equal("select '??' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select '??' from foo where bar=?")
+    assert_equal("select '??' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select '???' from foo where bar=?")
-        assert_equal("select '???' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select '???' from foo where bar=?")
+    assert_equal("select '???' from foo where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select ''???' from foo where bar=?")
-        assert_equal("select ''?'foo'' from foo where bar='foo'", ep.quote { |x| "'foo'" })
-    end
+    ep = Epoxy.new("select ''???' from foo where bar=?")
+    assert_equal("select ''?'foo'' from foo where bar='foo'", ep.quote { |x| "'foo'" })
+  end
 
-    def test_03_quotes_already
-        ep = Epoxy.new("select * from \"foo\" where bar=?")
-        assert_equal("select * from \"foo\" where bar='foo'", ep.quote { |x| "'foo'" })
+  def test_03_quotes_already
+    ep = Epoxy.new("select * from \"foo\" where bar=?")
+    assert_equal("select * from \"foo\" where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select * from 'foo' where bar=?")
-        assert_equal("select * from 'foo' where bar='foo'", ep.quote { |x| "'foo'" })
-    end
+    ep = Epoxy.new("select * from 'foo' where bar=?")
+    assert_equal("select * from 'foo' where bar='foo'", ep.quote { |x| "'foo'" })
+  end
 
-    def test_04_holy_shit
-        ep = Epoxy.new("select * from \"'foo'\" where bar=?")
-        assert_equal("select * from \"'foo'\" where bar='foo'", ep.quote { |x| "'foo'" })
+  def test_04_holy_shit
+    ep = Epoxy.new("select * from \"'foo'\" where bar=?")
+    assert_equal("select * from \"'foo'\" where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select * from E\"'foo'\" where bar=?")
-        assert_equal("select * from E\"'foo'\" where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select * from E\"'foo'\" where bar=?")
+    assert_equal("select * from E\"'foo'\" where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select * from E\"''foo''\" where bar=?")
-        assert_equal("select * from E\"''foo''\" where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select * from E\"''foo''\" where bar=?")
+    assert_equal("select * from E\"''foo''\" where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select * from E\"\\''foo''\" where bar=?")
-        assert_equal("select * from E\"\\''foo''\" where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select * from E\"\\''foo''\" where bar=?")
+    assert_equal("select * from E\"\\''foo''\" where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select * from E\"\\''foo\\''\" where bar=?")
-        assert_equal("select * from E\"\\''foo\\''\" where bar='foo'", ep.quote { |x| "'foo'" })
+    ep = Epoxy.new("select * from E\"\\''foo\\''\" where bar=?")
+    assert_equal("select * from E\"\\''foo\\''\" where bar='foo'", ep.quote { |x| "'foo'" })
 
-        ep = Epoxy.new("select * from foo where bar='?'")
-        assert_equal("select * from foo where bar='?'", ep.quote { |x| "'foo'" })
-    end
+    ep = Epoxy.new("select * from foo where bar='?'")
+    assert_equal("select * from foo where bar='?'", ep.quote { |x| "'foo'" })
+  end
 
-    def test_05_comments
-        ep = Epoxy.new(%Q{
-                       -- a comment!
+  def test_05_comments
+    ep = Epoxy.new(%Q{
+                       -- a comment?!
                        select * from foo where bar=?
                        }.strip)
 
-        assert_equal(%Q{
-                       -- a comment!
+                       assert_equal(%Q{
+                       -- a comment?!
                        select * from foo where bar='foo'
                      }.strip, ep.quote { |x| "'foo'" })
-        
-        ep = Epoxy.new(%Q{
+
+                     ep = Epoxy.new(%Q{
+                       // a comment?!
+                       select * from foo where bar=?
+                       }.strip)
+
+                       assert_equal(%Q{
+                       // a comment?!
+                       select * from foo where bar='foo'
+                     }.strip, ep.quote { |x| "'foo'" })
+
+                     ep = Epoxy.new(%Q{
                        # a comment!
                        select * from foo where bar=?
                        }.strip, %r{#})
-        
-        assert_equal(%Q{
+
+                       assert_equal(%Q{
                        # a comment!
                        select * from foo where bar='foo'
                      }.strip, ep.quote { |x| "'foo'" })
 
-    end
+  end
+
+  def test_06_named_binds
+    binds = { 0 => "test", :foo => 'bar', "bar" => 'baz', "void" => 'unused' }
+    yarrr = proc { |x| "'#{binds[x] || binds[x.to_s]}'" }
+
+    ep = Epoxy.new("select * from 'foo' where bar=?foo and baz=?bar")
+    assert_equal(
+      "select * from 'foo' where bar='bar' and baz='baz'", 
+      ep.quote(binds, &yarrr)
+    )
+    
+    ep = Epoxy.new("select * from 'foo' where bar='foo ?bar' and baz=?bar")
+    assert_equal(
+      "select * from 'foo' where bar='foo ?bar' and baz='baz'", 
+      ep.quote(binds, &yarrr)
+    )
+
+    ep = Epoxy.new("select * from 'foo' where bar=?foo and baz=?")
+    assert_equal(
+      "select * from 'foo' where bar='bar' and baz='test'",
+      ep.quote(binds, &yarrr)
+    )
+
+    ep = Epoxy.new("select * from 'foo' where bar='?foo' and baz='?baz'")
+    assert_equal(
+      "select * from 'foo' where bar='?foo' and baz='?baz'",
+      ep.quote(binds, &yarrr)
+    )
+
+    ep = Epoxy.new("select * from 'foo' where bar=?foo and baz=?foo")
+    assert_equal(
+      "select * from 'foo' where bar='bar' and baz='bar'",
+      ep.quote(binds, &yarrr)
+    )
+
+    ep = Epoxy.new("select * from 'foo' where bar=??")
+    assert_equal(
+      "select * from 'foo' where bar=?",
+      ep.quote(binds, &yarrr)
+    )
+    
+    ep = Epoxy.new("select * from 'foo' where bar=??bar")
+    assert_equal(
+      "select * from 'foo' where bar=?bar",
+      ep.quote(binds, &yarrr)
+    )
+
+    ep = Epoxy.new("select * from 'foo' where bar=?notfound")
+    assert_equal(
+      "select * from 'foo' where bar=?notfound",
+      ep.quote(binds, &yarrr)
+    )
+  end
+    
 end
+
+# vim: syntax=ruby ts=2 et sw=2 sts=2

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: epoxy
 version: !ruby/object:Gem::Version 
+  hash: 19
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 1
-  version: 0.2.1
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Erik Hollensbe
@@ -14,21 +15,37 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-27 00:00:00 -04:00
+date: 2010-07-12 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rdoc
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
   type: :development
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
 description: Parse binds in SQL or any other data query language, quote, even configure for client-side binding. It all works!
 email: erik@hollensbe.org
 executables: []
@@ -58,23 +75,27 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: A binding API for query languages that does not depend on any specific database.