rdo 0.0.6 → 0.0.7

data/README.md

@@ -37,7 +37,7 @@ conn.close
 ## Why your ORM so shit?
 
 RDO provides access to a number of RDBMS's. It allows you to query using SQL
-and issue commands using DDL, as thinly as is necessary. It is absolutely not,
+and other things using DDL, as thinly as is necessary. It is absolutely not,
 nor is it trying to be an SQL abstraction layer, an ORM or anything of that
 nature. The intention is to provide a way to allow Ruby developers to write
 applications that use a database, but don't use an ORM (*scoff!*).
@@ -94,26 +94,30 @@ And then execute:
       <th>URI Schemes</th>
       <th>Gem</th>
       <th>Author</th>
+      <th>Status</th>
     </tr>
   </thead>
   <tbody>
     <tr>
       <th>SQLite</th>
-      <td>sqlite</td>
+      <td>sqlite, sqlite3</td>
       <td><a href="https://github.com/d11wtq/rdo-sqlite">rdo-sqlite</a></td>
       <td><a href="https://github.com/d11wtq">d11wtq</a></td>
+      <td>Published</td>
     </tr>
     <tr>
       <th>PostgreSQL</th>
       <td>postgresql, postgres</td>
       <td><a href="https://github.com/d11wtq/rdo-postgres">rdo-postgres</a></td>
       <td><a href="https://github.com/d11wtq">d11wtq</a></td>
+      <td>Published</td>
     </tr>
     <tr>
       <th>MySQL</th>
       <td>mysql</td>
       <td><a href="https://github.com/d11wtq/rdo-mysql">rdo-mysql</a></td>
       <td><a href="https://github.com/d11wtq">d11wtq</a></td>
+      <td>Pending development</td>
     </tr>
   </tbody>
 </table>
@@ -137,6 +141,8 @@ conn = RDO.connect("postgresql://user:pass@host:port/db_name?encoding=utf-8")
 p conn.open? #=> true
 ```
 
+For semantic reasons, #connect is aliased to #open.
+
 If it is not possible to establish a connection an RDO::Exception is raised,
 which should provide any reason given by the DBMS.
 
@@ -146,8 +152,7 @@ RDO will disconnect automatically when the connection is garbage-collected,
 or when the program exits, but if you need to disconnect explicitly,
 call #close. It is safe to call this even if the connection is already closed.
 
-Call #open to re-connect after closing a connection, for example when forking
-child processes.
+If you have called #close, say before forking, call #open to re-connect.
 
 ``` ruby
 conn.close
@@ -157,6 +162,18 @@ conn.open
 p conn.open? #=> true
 ```
 
+### One-time use connections
+
+If you pass a block to RDO.connect, RDO yields the connection into the block,
+returns the result of the block, the closes the connection.
+
+``` ruby
+puts RDO.open("sqlite:some.db") do |c|
+  c.execute("SELECT value FROM config WHERE name = ?", "api_key").first_value
+end
+# => "EXAMPLE_KEY"
+```
+
 ### Performing non-read commands
 
 All SQL and DDL (Data Definition Language) is executed with #execute, which

data/lib/rdo.rb

@@ -17,16 +17,32 @@ require "rdo/util"
 module RDO
   class << self
     # Establish a connection to the RDBMS.
+    # The connection will be returned open.
     #
     # The needed driver must be loaded before calling this.
     #
+    # If a block is given, the connection is passed to the block and then
+    # closed at the end of the block, before this method finally returns
+    # the result of the block.
+    #
     # @param [Object] options
     #   either a connection URI string, or an option Hash
     #
     # @return [Connection]
     #   a Connection for the required driver
     def connect(options)
-      Connection.new(options)
+      if block_given?
+        begin
+          c = Connection.new(options)
+          yield c
+        ensure
+          c.close unless c.nil?
+        end
+      else
+        Connection.new(options)
+      end
     end
+
+    alias_method :open, :connect
   end
 end

data/lib/rdo/connection.rb

@@ -92,20 +92,38 @@ module RDO
     end
 
     def parse_connection_uri(str)
-      uri = URI.parse(str.to_s)
+      uri = # handle e.g. sqlite: and sqlite:// (empty host and path)
+        if str =~ %r{\A[a-z0-9_\+-]+:\Z}i
+          URI.parse(str.to_s + "//rdo-spoof").tap{|u| u.host = nil}
+        elsif str =~ %r{\A[a-z0-9_\+-]+://\Z}i
+          URI.parse(str.to_s + "rdo-spoof").tap{|u| u.host = nil}
+        else
+          URI.parse(str.to_s)
+        end
+
       normalize_options(
         {
           driver:   uri.scheme,
           host:     uri.host,
           port:     uri.port,
-          path:     uri.path,
-          database: uri.path.to_s.sub("/", ""),
+          path:     extract_uri_path(uri),
+          database: extract_uri_path(uri).to_s.sub("/", ""),
           user:     uri.user,
           password: uri.password
-        }.merge(parse_query_string(uri.query))
+        }.merge(parse_query_string(extract_uri_query(uri)))
       )
     end
 
+    def extract_uri_path(uri)
+      return uri.path unless uri.opaque
+      uri.opaque.sub(/\?.*\Z/, "")
+    end
+
+    def extract_uri_query(uri)
+      return uri.query unless uri.opaque
+      uri.opaque.sub(/\A.*?\?/, "")
+    end
+
     def parse_query_string(str)
       str.nil? ? {} : Hash[CGI.parse(str).map{|k,v| [k, v.size == 1 ? v.first : v]}]
     end

data/lib/rdo/version.rb

@@ -6,5 +6,5 @@
 ##
 
 module RDO
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

data/spec/rdo/rdo_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe RDO do
+  let(:driver_class) { stub(new: driver) }
+  let(:driver)       { stub(:driver, open: true, close: true) }
+
+  before(:each) { RDO::Connection.register_driver(:test, driver_class) }
+
+  describe ".connect" do
+    it "returns a connection for the given driver" do
+      RDO.connect("test://whatever").should be_a_kind_of(RDO::Connection)
+    end
+
+    it "opens the connection" do
+      driver.should_receive(:open).and_return(true)
+      RDO.connect("test://whatever")
+    end
+
+    it "is aliased as .open" do
+      RDO.open("test://whatever").should be_a_kind_of(RDO::Connection)
+    end
+
+    context "when given a block" do
+      it "yields the connection" do
+        conn = nil
+        RDO.open("test://whatever") { |c| conn = c }
+        conn.should be_a_kind_of(RDO::Connection)
+      end
+
+      it "opens the connection" do
+        driver.should_receive(:open).and_return(true)
+        RDO.open("test://whatever") { |c| }
+      end
+
+      it "closes the connection" do
+        driver.should_receive(:close).and_return(true)
+        RDO.open("test://whatever") { |c| }
+      end
+
+      it "returns the result of the block" do
+        RDO.open("test://whatever"){ |c| "test" }.should == "test"
+      end
+
+      context "on error in block" do
+        it "still closes the connection" do
+          driver.should_receive(:close).and_return(true)
+          begin
+            RDO.open("test://whatever") { |c| raise "Blarg" }
+          rescue
+          end
+        end
+      end
+    end
+  end
+end

data/util/macros.h

@@ -1,5 +1,5 @@
 /*
- * RDO Postgres Driver.
+ * RDO—Ruby Data Objects.
  * Copyright © 2012 Chris Corbyn.
  *
  * See LICENSE file for details.
@@ -18,6 +18,52 @@
  * --------------------------------------------------------------------------
  */
 
+#include <ruby.h>
+#include <ruby/encoding.h>
+
+/**
+ * Convenience to call #to_s on any Ruby object.
+ */
+#define RDO_OBJ_TO_S(obj) (rb_funcall(obj, rb_intern("to_s"), 0))
+
+/**
+ * Raise an RDO::Exception with the given msg format and any number of parameters.
+ *
+ * @param (char *) msg
+ *   a format string passed to rb_raise()
+ *
+ * @param (void *) ...
+ *   args used to interpolate the error message
+ */
+#define RDO_ERROR(...) (rb_raise(rb_path2class("RDO::Exception"), __VA_ARGS__))
+
+/**
+ * Factory to return a new RDO::Result for an Enumerable object of tuples.
+ *
+ * @param VALUE (Enumerable) tuples
+ *   an object that knows how to iterate all tuples
+ *
+ * @param VALUE (Hash)
+ *   an optional hash of query info.
+ *
+ * @return VALUE (RDO::Result)
+ *   a new Result object
+ */
+#define RDO_RESULT(tuples, info) \
+  (rb_funcall(rb_path2class("RDO::Result"), rb_intern("new"), 2, tuples, info))
+
+/**
+ * Wrap the given StatementExecutor in a RDO::Statement.
+ *
+ * @param VALUE
+ *   any object that responds to #command and #execute
+ *
+ * @return VALUE
+ *   an RDO::Statement
+ */
+#define RDO_STATEMENT(executor) \
+  (rb_funcall(rb_path2class("RDO::Statement"), rb_intern("new"), 1, executor))
+
 /**
  * Convert a C string to a ruby String.
  *
@@ -30,9 +76,8 @@
  * @return VALUE (String)
  *   a Ruby String
  */
-#define RDO_STRING(s, len, enc) ( \
-    rb_enc_associate_index(rb_str_new(s, len), enc > 0 ? enc : 0) \
-    )
+#define RDO_STRING(s, len, enc) \
+  (rb_enc_associate_index(rb_str_new(s, len), enc > 0 ? enc : 0))
 
 /**
  * Convert a C string to a ruby String, assuming possible NULL bytes.
@@ -64,11 +109,9 @@
  * @return VALUE (Float)
  *   a ruby Float
  */
-#define RDO_FLOAT(s) ( \
-    rb_funcall(rb_path2class("RDO::Util"), \
-      rb_intern("float"), 1, \
-      rb_str_new2(s)) \
-    )
+#define RDO_FLOAT(s) \
+  (rb_funcall(rb_path2class("RDO::Util"), \
+              rb_intern("float"), 1, rb_str_new2(s)))
 
 /**
  * Convert a C string representing a precision decimal into a BigDecimal.
@@ -83,11 +126,9 @@
  *   RDO_DECIMAL("1.234")
  *   => #<BigDecimal:7feb42b2b6e8,'0.1234E1',18(18)>
  */
-#define RDO_DECIMAL(s) ( \
-    rb_funcall(rb_path2class("RDO::Util"), \
-      rb_intern("decimal"), 1, \
-      rb_str_new2(s)) \
-    )
+#define RDO_DECIMAL(s) \
+  (rb_funcall(rb_path2class("RDO::Util"), \
+              rb_intern("decimal"), 1, rb_str_new2(s)))
 
 /**
  * Convert a C string representing a date into a Date.
@@ -102,11 +143,9 @@
  *   RDO_DATE("431-09-22 BC")
  *   #<Date: -0430-09-22 ((1564265j,0s,0n),+0s,2299161j)>
  */
-#define RDO_DATE(s) ( \
-    rb_funcall(rb_path2class("RDO::Util"), \
-      rb_intern("date"), 1, \
-      rb_str_new2(s)) \
-    )
+#define RDO_DATE(s) \
+  (rb_funcall(rb_path2class("RDO::Util"), \
+              rb_intern("date"), 1, rb_str_new2(s)))
 
 /**
  * Convert a C string representing a date & time with no time zone into a DateTime.
@@ -121,11 +160,9 @@
  *   RDO_DATE_TIME_WITHOUT_ZONE("2012-09-22 04:36:12")
  *   #<DateTime: 2012-09-22T04:36:12+10:00 ((2456192j,66972s,0n),+36000s,2299161j)>
  */
-#define RDO_DATE_TIME_WITHOUT_ZONE(s) ( \
-    rb_funcall(rb_path2class("RDO::Util"), \
-      rb_intern("date_time_without_zone"), 1, \
-      rb_str_new2(s)) \
-    )
+#define RDO_DATE_TIME_WITHOUT_ZONE(s) \
+  (rb_funcall(rb_path2class("RDO::Util"), \
+              rb_intern("date_time_without_zone"), 1, rb_str_new2(s)))
 
 /**
  * Convert a C string representing a date & time that includes a time zone into a DateTime.
@@ -140,11 +177,9 @@
  *   RDO_DATE_TIME_WITHOUT_ZONE("2012-09-22 04:36:12+10:00")
  *   #<DateTime: 2012-09-22T04:36:12+10:00 ((2456192j,66972s,0n),+36000s,2299161j)>
  */
-#define RDO_DATE_TIME_WITH_ZONE(s) ( \
-    rb_funcall(rb_path2class("RDO::Util"), \
-      rb_intern("date_time_with_zone"), 1, \
-      rb_str_new2(s)) \
-    )
+#define RDO_DATE_TIME_WITH_ZONE(s) \
+  (rb_funcall(rb_path2class("RDO::Util"), \
+              rb_intern("date_time_with_zone"), 1, rb_str_new2(s)))
 
 /**
  * Convert a boolean string to TrueClass/FalseClass.
@@ -156,22 +191,3 @@
  *   the boolean representation
  */
 #define RDO_BOOL(s) ((s[0] == 't') ? Qtrue : Qfalse)
-
-/**
- * Wrap the given StatementExecutor in a RDO::Statement.
- *
- * @param VALUE
- *   any object that responds to #command and #execute
- *
- * @return VALUE
- *   an RDO::Statement
- */
-#define RDO_STATEMENT(executor) ( \
-    rb_funcall(rb_path2class("RDO::Statement"), \
-      rb_intern("new"), 1, executor) \
-    )
-
-/**
- * Convenience to call #to_s on any Ruby object.
- */
-#define RDO_OBJ_TO_S(obj) (rb_funcall(obj, rb_intern("to_s"), 0))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdo
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-24 00:00:00.000000000 Z
+date: 2012-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -70,6 +70,7 @@ files:
 - spec/rdo/connection_spec.rb
 - spec/rdo/driver_spec.rb
 - spec/rdo/emulated_statements_spec.rb
+- spec/rdo/rdo_spec.rb
 - spec/rdo/result_spec.rb
 - spec/rdo/statement_spec.rb
 - spec/rdo/util_spec.rb
@@ -105,6 +106,7 @@ test_files:
 - spec/rdo/connection_spec.rb
 - spec/rdo/driver_spec.rb
 - spec/rdo/emulated_statements_spec.rb
+- spec/rdo/rdo_spec.rb
 - spec/rdo/result_spec.rb
 - spec/rdo/statement_spec.rb
 - spec/rdo/util_spec.rb