downpour 0.0.1 → 0.0.2

data/ext/downpour/connection.c

@@ -1,4 +1,4 @@
-#include "drizzle.h"
+#include "downpour.h"
 
 #define SELF_TYPE drizzle_con_st
 
@@ -13,7 +13,14 @@ static VALUE query(VALUE self, VALUE query)
 
   CHECK_OK(retptr);
 
-  return Data_Wrap_Struct(DrizzleResult, NULL, NULL, result);
+  return downpour_result_constructor(result, self);
+}
+
+VALUE downpour_connection_constructor(drizzle_con_st *self_ptr, VALUE status)
+{
+  VALUE ret = Data_Wrap_Struct(DrizzleConnection, NULL, drizzle_con_free, self_ptr);
+  rb_iv_set(ret, "@status", status);
+  return ret;
 }
 
 void init_drizzle_connection()

data/ext/downpour/{drizzle.c → downpour.c}

@@ -1,18 +1,18 @@
-#include "drizzle.h"
+#include "downpour.h"
 
-VALUE DrizzleModule;
+VALUE DownpourModule;
 VALUE DrizzleStatus;
 VALUE DrizzleConnection;
 VALUE DrizzleResult;
 
-void init_drizzle_module();
+void init_downpour_module();
 void init_drizzle_status();
 void init_drizzle_connection();
 void init_drizzle_result();
 
 void Init_downpour()
 {
-  init_drizzle_module();
+  init_downpour_module();
   init_drizzle_status();
   init_drizzle_connection();
   init_drizzle_result();

data/ext/downpour/{drizzle.h → downpour.h}

@@ -5,11 +5,16 @@
 #include <libdrizzle/drizzle.h>
 #include <libdrizzle/drizzle_client.h>
 
-extern VALUE DrizzleModule;
+extern VALUE DownpourModule;
 extern VALUE DrizzleStatus;
 extern VALUE DrizzleConnection;
 extern VALUE DrizzleResult;
 
+// All Constructors
+VALUE downpour_constructor(drizzle_st *self_ptr);
+VALUE downpour_connection_constructor(drizzle_con_st *self_ptr, VALUE status);
+VALUE downpour_result_constructor(drizzle_result_st *self_ptr, VALUE connection);
+
 VALUE drizzle_gem_create_class_with_private_constructor(const char *name, VALUE super);
 void drizzle_gem_assert_value_is_ok(drizzle_return_t value);
 VALUE drizzle_gem_to_string_array(char **array, long count);
@@ -20,5 +25,7 @@ const char *drizzle_gem_read_string_with_default(VALUE string, const char *defau
 #define CHECK_OK(value) drizzle_gem_assert_value_is_ok(value)
 #define rb_call(self, string) rb_funcall(self, rb_intern(string), 0)
 #define read_string(value, default_value) drizzle_gem_read_string_with_default(value, default_value)
+#define drizzle_alloc(type) ((type *) malloc(sizeof(type)))
+#define unset_option(value, bit) if(value->options & bit) value->options ^= bit
 
 #endif

data/ext/downpour/extconf.rb

@@ -1,9 +1,15 @@
 require 'mkmf'
 
+libdrizzle = 'libdrizzle-1.0'
+
 extension_name = 'downpour'
 dir_config(extension_name)
 
-have_library("drizzle")
-$CFLAGS += " -I/usr/local/include/libdrizzle-1.0 -I/usr/include/libdrizzle-1.0"
+if(!system("pkg-config #{libdrizzle}"))
+  raise "Cannot find pkg-config or #{libdrizzle}"
+end
+
+$LDFLAGS += " " + `pkg-config --libs #{libdrizzle}`
+$CFLAGS += " " + `pkg-config --cflags #{libdrizzle}`
 
 create_makefile(extension_name)

data/ext/downpour/helpers.c

@@ -1,4 +1,4 @@
-#include "drizzle.h"
+#include "downpour.h"
 
 static VALUE do_not_use_this_constructor(VALUE self)
 {
@@ -18,7 +18,7 @@ VALUE drizzle_gem_to_string_array(char **array, long count)
 
 VALUE drizzle_gem_create_class_with_private_constructor(const char *name, VALUE super)
 {
-  VALUE ret = rb_define_class_under(DrizzleModule, name, super);
+  VALUE ret = rb_define_class_under(DownpourModule, name, super);
   rb_define_method(ret, "initialize", do_not_use_this_constructor, 0);
   return ret;
 }

data/ext/downpour/module.c

@@ -1,4 +1,4 @@
-#include "drizzle.h"
+#include "downpour.h"
 
 static VALUE version(VALUE self)
 {
@@ -8,12 +8,13 @@ static VALUE version(VALUE self)
 static VALUE create(VALUE self)
 {
   drizzle_st *ptr = drizzle_create(NULL);
-  return Data_Wrap_Struct(DrizzleStatus, NULL, drizzle_free, ptr);
+  unset_option(ptr, DRIZZLE_FREE_OBJECTS);
+  return downpour_constructor(ptr);
 }
 
-void init_drizzle_module()
+void init_downpour_module()
 {
-  DrizzleModule = rb_define_module("Drizzle");
-  rb_define_singleton_method(DrizzleModule, "version", version, 0);
-  rb_define_singleton_method(DrizzleModule, "create", create, 0);
+  DownpourModule = rb_define_module("Downpour");
+  rb_define_singleton_method(DownpourModule, "drizzle_version", version, 0);
+  rb_define_singleton_method(DownpourModule, "create", create, 0);
 }

data/ext/downpour/result.c

@@ -1,4 +1,4 @@
-#include "drizzle.h"
+#include "downpour.h"
 
 #define SELF_TYPE drizzle_result_st
 
@@ -48,21 +48,38 @@ static VALUE wrap_row(drizzle_result_st *self_ptr, drizzle_row_t row)
   if(row == NULL)
     return Qnil;
 
-  // TODO: wrap this in a Ruby Object. It should be freed
   return drizzle_gem_to_string_array(row, do_column_count(self_ptr));
 }
 
 static VALUE next_row_buffered(drizzle_result_st *self_ptr)
 {
-  return wrap_row(self_ptr, drizzle_row_next(self_ptr));
+  drizzle_row_t result = drizzle_row_next(self_ptr);
+  return wrap_row(self_ptr, result);
 }
 
-static VALUE next_row_unbuffered(drizzle_result_st *self_ptr)
+static void buffer_column_if_needed(drizzle_result_st *self_ptr)
+{
+  if(self_ptr->options & DRIZZLE_RESULT_BUFFER_COLUMN)
+    return;
+  CHECK_OK(drizzle_column_buffer(self_ptr));
+}
+
+static drizzle_row_t do_drizzle_row_buffer(drizzle_result_st *self_ptr)
 {
   drizzle_return_t ret;
   drizzle_row_t result = drizzle_row_buffer(self_ptr, &ret);
   CHECK_OK(ret);
-  return wrap_row(self_ptr, result);
+  return result;
+}
+
+static VALUE next_row_unbuffered(drizzle_result_st *self_ptr)
+{
+  buffer_column_if_needed(self_ptr);
+  drizzle_row_t result = do_drizzle_row_buffer(self_ptr);
+  VALUE parsed = wrap_row(self_ptr, result);
+  if(result)
+    drizzle_row_free(self_ptr, result);
+  return parsed;
 }
 
 static VALUE next_row(VALUE self)
@@ -81,6 +98,20 @@ static VALUE column_count(VALUE self)
   return UINT2NUM(do_column_count(self_ptr));
 }
 
+static VALUE insert_id(VALUE self)
+{
+  read_self_ptr();
+
+  return UINT2NUM(drizzle_result_insert_id(self_ptr));
+}
+
+VALUE downpour_result_constructor(drizzle_result_st *self_ptr, VALUE connection)
+{
+  VALUE ret = Data_Wrap_Struct(DrizzleResult, NULL, drizzle_result_free, self_ptr);
+  rb_iv_set(ret, "@connection", connection);
+  return ret;
+}
+
 void init_drizzle_result()
 {
   DrizzleResult = drizzle_gem_create_class_with_private_constructor("Result", rb_cObject);
@@ -89,4 +120,5 @@ void init_drizzle_result()
   rb_define_method(DrizzleResult, "buffer!", buffer_if_needed, 0);
   rb_define_method(DrizzleResult, "buffered?", is_buffered, 0);
   rb_define_method(DrizzleResult, "next_row", next_row, 0);
+  rb_define_method(DrizzleResult, "insert_id", insert_id, 0);
 }

data/ext/downpour/status.c

@@ -1,14 +1,7 @@
-#include "drizzle.h"
+#include "downpour.h"
 
 #define SELF_TYPE drizzle_st
 
-static VALUE clone_status(VALUE self)
-{
-  read_self_ptr();
-  drizzle_st *cloned = drizzle_clone(NULL, self_ptr);
-  return Data_Wrap_Struct(DrizzleStatus, NULL, drizzle_free, cloned);
-}
-
 static in_port_t get_port(VALUE port)
 {
   if(port == Qnil)
@@ -17,7 +10,6 @@ static in_port_t get_port(VALUE port)
   return NUM2UINT(port);
 }
 
-
 static VALUE add_tcp_connection(int argc, VALUE *argv, VALUE self)
 {
   read_self_ptr();
@@ -34,10 +26,7 @@ static VALUE add_tcp_connection(int argc, VALUE *argv, VALUE self)
                                                     read_string(passwd, ""),
                                                     read_string(db, "test"),
                                                     DRIZZLE_CON_NONE);
-
-  VALUE val = Data_Wrap_Struct(DrizzleConnection, NULL, NULL, connection);
-  rb_iv_set(val, "@status", self);
-  return val;
+  return downpour_connection_constructor(connection, self);
 }
 
 static VALUE error(VALUE self)
@@ -57,11 +46,31 @@ static VALUE set_verbose(VALUE self, VALUE newVerbocity)
   return newVerbocity;
 }
 
+static VALUE get_verbose(VALUE self)
+{
+  read_self_ptr();
+
+  return UINT2NUM(drizzle_verbose(self_ptr));
+}
+
+static VALUE verbose_name(VALUE self)
+{
+  read_self_ptr();
+
+  return rb_str_new2(drizzle_verbose_name(drizzle_verbose(self_ptr)));
+}
+
+VALUE downpour_constructor(drizzle_st *self_ptr)
+{
+  return Data_Wrap_Struct(DrizzleStatus, NULL, drizzle_free, self_ptr);
+}
+
 void init_drizzle_status()
 {
   DrizzleStatus = drizzle_gem_create_class_with_private_constructor("Status", rb_cObject);
-  rb_define_method(DrizzleStatus, "clone", clone_status, 0);
   rb_define_method(DrizzleStatus, "add_tcp_connection", add_tcp_connection, -1);
   rb_define_method(DrizzleStatus, "error", error, 0);
   rb_define_method(DrizzleStatus, "verbose=", set_verbose, 1);
+  rb_define_method(DrizzleStatus, "verbose", get_verbose, 0);
+  rb_define_method(DrizzleStatus, "verbose_name", verbose_name, 0);
 }

data/lib/downpour/version.rb

@@ -1,3 +1,3 @@
 module Downpour
-  VERSION = "0.0.1"
-end
+  VERSION = "0.0.2"
+end

data/spec/bootstrap.sql

@@ -5,3 +5,9 @@ create table Test1 (
 insert into Test1 values ('foo');
 insert into Test1 values ('bar');
 insert into Test1 values ('baz');
+
+drop table if exists Test2;
+create table Test2 (
+  id int auto_increment primary key,
+  name varchar(20)
+);

data/spec/downpour/insert_spec.rb

@@ -0,0 +1,19 @@
+describe "insert query" do
+
+  def count_of_test2
+    @conn.query("select * from Test2").row_count
+  end
+
+  before(:each) do
+    @status = Downpour.create
+    @conn = create_connection(@status)
+  end
+
+  it "should increment the row count by one" do
+    lambda { @conn.query "insert into Test2 (name) values ('foo')" }.should change(self, :count_of_test2).by(1)
+  end
+
+  it "should get id after inserting" do
+    @conn.query("insert into Test2 (name) values ('foo')").insert_id.should == count_of_test2
+  end
+end

data/spec/downpour/module_spec.rb

@@ -0,0 +1,12 @@
+describe Downpour do
+  it "should have the version number set" do
+    Downpour.drizzle_version.should eq("7")
+  end
+
+  it "should set the verbose level" do
+    st = Downpour.create
+    st.verbose = 5
+    st.verbose.should == 5
+    st.verbose_name.should == "CRAZY"
+  end
+end

data/spec/{query_spec.rb → downpour/query_spec.rb}

@@ -1,6 +1,6 @@
-describe Drizzle do
+describe Downpour do
   before(:each) do
-    @status = Drizzle.create
+    @status = Downpour.create
     @connection = create_connection(@status)
   end
 

data/spec/downpour/select_spec.rb

@@ -0,0 +1,52 @@
+describe "select query" do
+
+  before(:each) do
+    @status = Downpour.create
+    @conn = create_connection(@status)
+    @results = @conn.query "select * from Test1"
+  end
+
+  it "should count records" do
+    @results.row_count.should == 3
+    @results.should be_buffered
+  end
+
+  it "should buffer records" do
+    @results.should_not be_buffered
+    @results.buffer!
+    @results.should be_buffered
+  end
+
+  it "should only buffer records once" do
+    @results.buffer!.should be_true
+    @results.buffer!.should be_false
+  end
+
+  it "should count columns" do
+    @results.column_count.should == 1
+  end
+
+  it "should not buffer when reading a single row" do
+    @results.next_row
+    @results.should_not be_buffered
+  end
+
+  shared_examples_for "a read query" do
+    it "should read all rows" do
+      @results.next_row.should == ["foo"]
+      @results.next_row.should == ["bar"]
+      @results.next_row.should == ["baz"]
+      @results.next_row.should be_nil
+    end
+  end
+
+  context "without buffering" do
+    it_should_behave_like "a read query"
+  end
+
+  context "with buffering" do
+    before(:each) { @results.buffer! }
+
+    it_should_behave_like "a read query"
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: downpour
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Tejas Dinkar
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-25 00:00:00 +05:30
+date: 2011-05-30 00:00:00 +05:30
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -46,8 +46,8 @@ extra_rdoc_files:
 files: 
 - downpour.gemspec
 - ext/downpour/connection.c
-- ext/downpour/drizzle.c
-- ext/downpour/drizzle.h
+- ext/downpour/downpour.c
+- ext/downpour/downpour.h
 - ext/downpour/extconf.rb
 - ext/downpour/helpers.c
 - ext/downpour/module.c
@@ -55,12 +55,13 @@ files:
 - ext/downpour/status.c
 - lib/downpour.rb
 - lib/downpour/version.rb
-- README.rdoc
 - spec/bootstrap.sql
-- spec/module_spec.rb
-- spec/query_spec.rb
-- spec/smoke_spec.rb
+- spec/downpour/insert_spec.rb
+- spec/downpour/module_spec.rb
+- spec/downpour/query_spec.rb
+- spec/downpour/select_spec.rb
 - spec/spec_helper.rb
+- README.rdoc
 has_rdoc: true
 homepage: http://github.com/gja/downpour
 licenses: []
@@ -92,7 +93,8 @@ specification_version: 3
 summary: A simple, fast Mysql and Drizzle library for Ruby, binding to libdrizzle
 test_files: 
 - spec/bootstrap.sql
-- spec/module_spec.rb
-- spec/query_spec.rb
-- spec/smoke_spec.rb
+- spec/downpour/insert_spec.rb
+- spec/downpour/module_spec.rb
+- spec/downpour/query_spec.rb
+- spec/downpour/select_spec.rb
 - spec/spec_helper.rb

data/spec/module_spec.rb

@@ -1,5 +0,0 @@
-describe Drizzle do
-  it "should have the version number set" do
-    Drizzle.version.should == "7"
-  end
-end

data/spec/smoke_spec.rb

@@ -1,61 +0,0 @@
-describe Drizzle do
-
-  before(:each) do
-    @status = Drizzle.create
-    @conn = create_connection(@status)
-  end
-
-  context "select query" do
-    before(:each) do
-      @results = @conn.query "select * from Test1"
-    end
-
-    it "should count records" do
-      @results.row_count.should == 3
-      @results.should be_buffered
-    end
-
-    it "should buffer records" do
-      @results.should_not be_buffered
-      @results.buffer!
-      @results.should be_buffered
-    end
-
-    it "should only buffer records once" do
-      @results.buffer!.should be_true
-      @results.buffer!.should be_false
-    end
-
-    it "should count columns" do
-      @results.column_count.should == 1
-    end
-
-    it "should not buffer when reading a single row" do
-      @results.next_row
-      @results.should_not be_buffered
-    end
-
-    shared_examples_for "a read query" do
-      it "should read all rows" do
-        @results.next_row.should == ["foo"]
-        @results.next_row.should == ["bar"]
-        @results.next_row.should == ["baz"]
-        @results.next_row.should be_nil
-      end
-    end
-
-    context "without buffering" do
-      it_should_behave_like "a read query"
-    end
-
-    context "with buffering" do
-      before(:each) { @results.buffer! }
-
-      it_should_behave_like "a read query"
-    end
-  end
-
-  after(:each) do
-    #puts @status.error
-  end
-end