swift 0.4.3 → 0.5.0

data/ext/swift.h

@@ -0,0 +1,35 @@
+#ifndef SWIFT_H
+#define SWIFT_H
+
+#include <dbic++.h>
+#include <ruby/ruby.h>
+#include <ruby/io.h>
+#include <stdint.h>
+
+#define CONST_GET(scope, constant) rb_funcall(scope, rb_intern("const_get"), 1, rb_str_new2(constant))
+#define TO_S(v)                    rb_funcall(v, rb_intern("to_s"), 0)
+#define CSTRING(v)                 RSTRING_PTR(TO_S(v))
+
+extern VALUE eSwiftError;
+extern VALUE eSwiftArgumentError;
+extern VALUE eSwiftRuntimeError;
+extern VALUE eSwiftConnectionError;
+
+#define CATCH_DBI_EXCEPTIONS() \
+  catch (dbi::ConnectionError &error) { \
+    rb_raise(eSwiftConnectionError, "%s", CSTRING(rb_str_new2(error.what()))); \
+  } \
+  catch (dbi::Error &error) { \
+    rb_raise(eSwiftRuntimeError, "%s", CSTRING(rb_str_new2(error.what()))); \
+  }
+
+#include "adapter.h"
+#include "iostream.h"
+#include "query.h"
+#include "result.h"
+#include "statement.h"
+#include "request.h"
+#include "pool.h"
+
+#endif
+

data/lib/swift/adapter.rb

@@ -1,13 +1,7 @@
 module Swift
-  #--
-  # TODO: Still not convinced all and first are necessary.
   class Adapter
     attr_reader :options
 
-    def identity_map
-      @identity_map ||= IdentityMap.new
-    end
-
     def get scheme, keys
       relation = scheme.new(keys)
       prepare_get(scheme).execute(*relation.tuple.values_at(*scheme.header.keys)).first
@@ -19,7 +13,8 @@ module Swift
     end
 
     def first scheme, conditions = '', *binds, &block
-      all(scheme, "#{conditions} limit 1", *binds, &block).first
+      where = "where #{exchange_names(scheme, conditions)}" unless conditions.empty?
+      prepare(scheme, "select * from #{scheme.store} #{where} limit 1").execute(*binds, &block).first
     end
 
     def create scheme, *relations
@@ -38,6 +33,7 @@ module Swift
       relations.map do |relation|
         relation = scheme.new(relation) unless relation.kind_of?(scheme)
         statement.execute(*relation.tuple.values_at(*scheme.header.updatable, *scheme.header.keys))
+        relation
       end
     end
 
@@ -113,6 +109,7 @@ module Swift
           when Type::BigDecimal then 'numeric'
           when Type::Time       then 'timestamp'
           when Type::Boolean    then 'boolean'
+          when Type::IO         then 'blob'
           else 'text'
         end
       end

data/lib/swift/attribute.rb

@@ -12,12 +12,18 @@ module Swift
     end
 
     def default
-      @default.respond_to?(:call) ? @default.call : (@default.nil? ? nil : @default.dup)
+      if @default.respond_to?(:call)
+        @default.call
+      elsif Swift.special_constant?(@default)
+        @default
+      else
+        @default.dup
+      end
     end
 
     def define_scheme_methods scheme
       scheme.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{name};        tuple.fetch(:#{field})        end
+        def #{name};        tuple.fetch(:#{field}, nil)   end
         def #{name}= value; tuple.store(:#{field}, value) end
       RUBY
     end

data/lib/swift/db.rb

@@ -3,13 +3,6 @@ module Swift
     class Mysql < Adapter
       def initialize options = {}
         super options.update(driver: 'mysql')
-        execute('select unix_timestamp() - unix_timestamp(utc_timestamp()) as offset') {|r| @tzoffset = r[:offset] }
-      end
-
-      def timezone *args
-        super(*args)
-        execute('select unix_timestamp() - unix_timestamp(utc_timestamp()) as offset') {|r| @tzoffset = r[:offset] }
-        @tzoffset
       end
 
       def returning?
@@ -20,20 +13,18 @@ module Swift
     class Postgres < Adapter
       def initialize options = {}
         super options.update(driver: 'postgresql')
-        sql = "select extract(epoch from now())::bigint - extract(epoch from now() at time zone 'UTC')::bigint"
-        execute('%s as offset' % sql) {|r| @tzoffset = r[:offset] }
-      end
-
-      def timezone *args
-        super(*args)
-        sql = "select extract(epoch from now())::bigint - extract(epoch from now() at time zone 'UTC')::bigint"
-        execute('%s as offset' % sql) {|r| @tzoffset = r[:offset] }
-        @tzoffset
       end
 
       def returning?
         true
       end
+
+      def field_definition attribute
+        case attribute
+          when Type::IO then '%s bytea' % attribute.field
+          else super
+        end
+      end
     end # Postgres
   end # DB
 end # Swift

data/lib/swift/identity_map.rb

@@ -27,7 +27,15 @@ module Swift
       end
   end # IdentityMap
 
+  class Adapter
+    def identity_map
+      @identity_map ||= IdentityMap.new
+    end
+  end
+
   class Scheme
+    #--
+    # TODO: Redefined method :(
     def self.load tuple
       im = [self, *tuple.values_at(*header.keys)]
       unless scheme = Swift.db.identity_map.get(im)

data/lib/swift/migrations.rb

@@ -0,0 +1,15 @@
+module Swift
+  class Scheme
+    def self.migrations &migrations
+      (class << self; self end).send :define_method, :migrate!, lambda{|db = Swift.db| migrations.call(db) }
+    end
+
+    def self.migrate! db = Swift.db
+      db.migrate! self
+    end
+  end # Scheme
+
+  def self.migrate! name = nil
+    schema.each{|scheme| scheme.migrate!(db(name)) }
+  end
+end # Swift

data/lib/swift/pool.rb

@@ -19,8 +19,9 @@ module Swift
       end
     end # Handler
 
+
     def initialize size, options
-      @pool         = Swift::ConnectionPool.new size, options
+      @pool         = Swift::DB::Pool.new size, options
       @stop_reactor = EM.reactor_running? ? false : true
       @pending      = {}
       @queue        = []

data/lib/swift/scheme.rb

@@ -41,14 +41,6 @@ module Swift
         name ? @store = name : @store
       end
 
-      def migration &migration
-        (class << self; self end).send(:define_method, :migrate!, lambda{ Swift.db.instance_eval(&migration) })
-      end
-
-      def migrate!
-        Swift.db.migrate!(self)
-      end
-
       def create options = {}
         Swift.db.create(self, options)
       end

data/lib/swift/validations.rb

@@ -0,0 +1,27 @@
+module Swift
+  class Errors < Array
+    attr_accessor :relation
+
+    def initialize relation
+      @relation = relation
+    end
+  end # Errors
+
+  class Scheme
+    def self.validations &validations
+      define_method :validate do
+        errors = Errors.new(self)
+        instance_exec errors, &validations
+        errors
+      end
+    end
+
+    def validate errors = Errors.new(self)
+      errors
+    end
+
+    def valid?
+      validate.empty?
+    end
+  end # Scheme
+end # Swift

data/lib/swift.rb

@@ -39,10 +39,5 @@ module Swift
     def schema
       @schema ||= []
     end
-
-    def migrate! name = nil
-      db(name){ schema.each(&:migrate!)}
-    end
   end
 end # Swift
-

data/swift.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{swift}
-  s.version = "0.4.3"
+  s.version = "0.5.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Shane Hanna", "Bharanee 'Barney' Rathna"]
-  s.date = %q{2010-08-07}
+  s.date = %q{2010-08-30}
   s.description = %q{A rational rudimentary database abstraction.}
   s.email = ["shane.hanna@gmail.com", "deepfryed@gmail.com"]
   s.extensions = ["ext/extconf.rb"]
@@ -18,46 +18,72 @@ Gem::Specification.new do |s|
      "README.rdoc"
   ]
   s.files = [
-    "LICENSE",
+    "API.rdoc",
+     "LICENSE",
      "README.rdoc",
      "Rakefile",
      "VERSION",
+     "ext/adapter.cc",
+     "ext/adapter.h",
      "ext/extconf.rb",
+     "ext/iostream.cc",
+     "ext/iostream.h",
+     "ext/pool.cc",
+     "ext/pool.h",
+     "ext/query.cc",
+     "ext/query.h",
+     "ext/request.cc",
+     "ext/request.h",
+     "ext/result.cc",
+     "ext/result.h",
+     "ext/statement.cc",
+     "ext/statement.h",
      "ext/swift.cc",
+     "ext/swift.h",
      "lib/swift.rb",
      "lib/swift/adapter.rb",
      "lib/swift/attribute.rb",
      "lib/swift/db.rb",
      "lib/swift/header.rb",
      "lib/swift/identity_map.rb",
+     "lib/swift/migrations.rb",
      "lib/swift/pool.rb",
      "lib/swift/scheme.rb",
      "lib/swift/type.rb",
+     "lib/swift/validations.rb",
      "swift.gemspec",
      "test/helper.rb",
      "test/house-explode.jpg",
      "test/test_adapter.rb",
      "test/test_encoding.rb",
+     "test/test_error.rb",
      "test/test_identity_map.rb",
      "test/test_io.rb",
      "test/test_pool.rb",
-     "test/test_timestamps.rb"
+     "test/test_scheme.rb",
+     "test/test_timestamps.rb",
+     "test/test_transactions.rb",
+     "test/test_validations.rb"
   ]
   s.homepage = %q{http://github.com/shanna/swift}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.6}
+  s.rubygems_version = %q{1.3.7}
   s.summary = %q{A rational rudimentary database abstraction.}
   s.test_files = [
-    "test/test_adapter.rb",
+    "test/test_pool.rb",
      "test/test_io.rb",
+     "test/test_validations.rb",
+     "test/test_transactions.rb",
+     "test/test_adapter.rb",
+     "test/test_identity_map.rb",
+     "test/test_error.rb",
+     "test/helper.rb",
      "test/test_encoding.rb",
      "test/test_timestamps.rb",
-     "test/helper.rb",
-     "test/test_identity_map.rb",
-     "test/test_pool.rb",
-     "examples/async.rb",
+     "test/test_scheme.rb",
      "examples/scheme.rb",
+     "examples/async.rb",
      "examples/db.rb"
   ]
 
@@ -65,13 +91,16 @@ Gem::Specification.new do |s|
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_development_dependency(%q<minitest>, [">= 1.7.0"])
+      s.add_development_dependency(%q<eventmachine>, [">= 0"])
     else
       s.add_dependency(%q<minitest>, [">= 1.7.0"])
+      s.add_dependency(%q<eventmachine>, [">= 0"])
     end
   else
     s.add_dependency(%q<minitest>, [">= 1.7.0"])
+    s.add_dependency(%q<eventmachine>, [">= 0"])
   end
 end
 

data/test/helper.rb

@@ -1,10 +1,8 @@
-require 'minitest/unit'
-require 'minitest/spec'
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'minitest/spec'
+require 'minitest/unit'
 require 'swift'
-require 'swift/pool'
 
 class MiniTest::Unit::TestCase
 end
@@ -12,13 +10,13 @@ end
 class MiniTest::Spec
   def self.supported_by *adapters, &block
     adapters.each do |adapter|
-      # test if adapter can be loaded.
       begin
         Swift.setup :default, adapter, db: 'swift_test'
       rescue => error
         warn "Unable to setup 'swift_test' db for #{adapter}, #{error.message}. Skipping..."
         next
       end
+
       describe("Adapter #{adapter.name}") do
         before do
           Swift.setup :default, adapter, db: 'swift_test'
@@ -29,4 +27,6 @@ class MiniTest::Spec
   end
 end
 
+# All tests run in this timezone.
+ENV['TZ'] = ":Australia/Melbourne"
 MiniTest::Unit.autorun

data/test/test_adapter.rb

@@ -44,6 +44,14 @@ describe 'Adapter' do
         assert sth.execute('Apple Arthurton')
         assert sth.execute('Benny Arthurton')
       end
+
+      it 'has insert_id' do
+        sql = case @db
+          when Swift::DB::Postgres then %q{insert into users (name, created_at) values (?, now()) returning id}
+          when Swift::DB::Mysql    then %q{insert into users (name, created_at) values (?, now())}
+        end
+        assert_kind_of Numeric, @db.prepare(sql).execute('Connie Arthurton').insert_id
+      end
     end
 
     describe 'executed prepared statements' do
@@ -76,31 +84,16 @@ describe 'Adapter' do
         assert_kind_of Hash, @sth.first
       end
 
-      it 'returns array rows for fetchrow' do
-        assert_kind_of Array, @sth.fetchrow
-      end
-
       it 'returns a result set on Adapter#execute{}' do
         @db.execute('select * from users') {|r| assert_kind_of Hash, r }
       end
 
       it 'returns a result set on Adapter#results' do
         @db.execute('select * from users')
-        assert_kind_of Swift::ResultSet, @db.results
+        assert_kind_of Swift::Result, @db.results
       end
     end
 
-    describe 'transactions' do
-      it 'yields db to block' do
-        Swift.db.transaction do |db|
-          assert_kind_of Swift::Adapter, db
-        end
-
-        Swift.db.transaction :sweet do |db|
-          assert_kind_of Swift::Adapter, db
-        end
-      end
-    end
 
     #--
     # TODO: Not sure how I feel about the block in write; feels like it's just there to get around the fields in the

data/test/test_error.rb

@@ -0,0 +1,26 @@
+require_relative 'helper'
+
+describe 'Error' do
+  supported_by Swift::DB::Postgres, Swift::DB::Mysql do
+    describe 'prepare' do
+      before do
+        Swift.db do |db|
+          db.execute %q{drop table if exists users}
+          db.execute %q{create table users(id serial, name text, primary key(id))}
+        end
+      end
+
+      it 'throws a runtime error on invalid sql' do
+        assert_raises(SwiftRuntimeError) do
+          Swift.db.prepare('garble garble garble')
+        end
+      end
+
+      it 'throws a runtime error on invalid bind parameters' do
+        assert_raises(SwiftRuntimeError) do
+          Swift.db.prepare('select * from users where id > ?').execute
+        end
+      end
+    end
+  end
+end

data/test/test_io.rb

@@ -4,11 +4,13 @@ describe 'Adapter' do
   supported_by Swift::DB::Postgres, Swift::DB::Mysql do
     describe 'Storing binary objects' do
       before do
-        Swift.db do |db|
-          type = db.is_a?(Swift::DB::Postgres) ? 'bytea' : 'blob'
-          db.execute %q{drop table if exists users}
-          db.execute %Q{create table users(id serial, name text, image #{type}, primary key(id))}
+        user = Class.new(Swift::Scheme) do
+          store :users
+          attribute :id,    Swift::Type::Integer, serial: true, key: true
+          attribute :name,  Swift::Type::String
+          attribute :image, Swift::Type::IO
         end
+        Swift.db.migrate! user
       end
 
       it 'stores and retrieves an image' do

data/test/test_pool.rb

@@ -1,11 +1,11 @@
 require_relative 'helper'
+require 'swift/pool'
 
 describe 'Adapter' do
   supported_by Swift::DB::Postgres, Swift::DB::Mysql do
     describe 'Asynchronous connection pool' do
       before do
         Swift.db do |db|
-          type = db.is_a?(Swift::DB::Postgres) ? 'bytea' : 'blob'
           db.execute %q{drop table if exists users}
           db.execute %Q{create table users(id serial, name text)}
         end

data/test/test_scheme.rb

@@ -0,0 +1,51 @@
+require_relative 'helper'
+
+describe 'scheme' do
+  before do
+    @user = Class.new(Swift::Scheme) do
+      store     :users
+      attribute :id,         Swift::Type::Integer, serial: true, key: true
+      attribute :name,       Swift::Type::String,  default: "dave"
+      attribute :age,        Swift::Type::Integer, default: 18
+      attribute :email,      Swift::Type::String
+      attribute :verified,   Swift::Type::Boolean, default: false
+      attribute :created_at, Swift::Type::Time,    default: proc { Time.now }
+    end
+  end
+
+  describe 'attributes' do
+    it 'defines attributes' do
+      instance = @user.new
+      %w(id name age email created_at).each do |m|
+        assert instance.respond_to?(m),       "responds to m"
+        assert instance.respond_to?("#{m}="), "responds to m="
+      end
+    end
+  end
+
+  describe 'instantiation' do
+    it 'returns a new instance with defaults' do
+      instance = @user.new
+      assert_kind_of @user, instance
+      assert_kind_of Time,  instance.created_at
+
+      assert_equal nil,    instance.id
+      assert_equal 'dave', instance.name
+      assert_equal 18,     instance.age
+      assert_equal nil,    instance.email
+      assert_equal false,  instance.verified
+    end
+
+    it 'returns a new instance' do
+      instance = @user.new name: 'cary', age: 22, email: 'cary@local'
+
+      assert_kind_of @user, instance
+      assert_kind_of Time,  instance.created_at
+
+      assert_equal nil,          instance.id
+      assert_equal 'cary',       instance.name
+      assert_equal 22,           instance.age
+      assert_equal 'cary@local', instance.email
+    end
+  end
+end

data/test/test_timestamps.rb

@@ -2,25 +2,38 @@ require_relative 'helper'
 require 'date'
 
 describe 'Adapter' do
-  supported_by Swift::DB::Postgres, Swift::DB::Mysql do
+  supported_by Swift::DB::Postgres do
     describe 'time parsing and time zones' do
-      it 'should set timezone' do
-        assert Swift.db.timezone(8, 0) # +08:00
+
+      before do
+        @db = Swift.db.class.new Swift.db.options.merge(timezone: 'Asia/Kabul')
       end
 
       it 'should parse timestamps and do conversion accordingly' do
-        assert Swift.db.timezone(8, 30) # +08:30
+        time  = DateTime.parse('2010-01-01 15:00:00+04:30')
+        assert_timestamp_like time, fetch_timestamp_at(time), 'parses correctly'
+      end
+
+      it 'should parse correctly when DST is on' do
+        time  = DateTime.parse('2010-10-02 20:31:00+04:30')
+        assert_timestamp_like time, fetch_timestamp_at(time), 'DST on'
+      end
+
+      it 'should parse correctly when DST is off' do
+        time  = DateTime.parse('2010-04-04 20:31:00+04:30')
+        assert_timestamp_like time, fetch_timestamp_at(time), 'DST off'
+      end
+
+      def fetch_timestamp_at value
+        sql = "select '%s'::timestamp with time zone as now" % value.strftime('%F %T%z')
+        @db.execute(sql)
+        @db.results.first.fetch(:now)
+      end
 
-        time  = DateTime.parse('2010-01-01 15:00:00+08:30')
-        match = Regexp.new time.to_time.strftime("%F %H:%M")
-        sql   = if Swift.db.kind_of?(Swift::DB::Postgres)
-          "select '#{time.strftime('%F %H:%M:%S')}'::timestamp as now"
-        else
-          "select timestamp('#{time.strftime('%F %H:%M:%S')}') as now"
-        end
-        Swift.db.execute(sql) do |r|
-          assert_match match, r[:now].to_s, "parses time and does zone conversion"
-        end
+      def assert_timestamp_like expect, given, comment
+        match = Regexp.new expect.to_time.strftime('%F %T')
+        assert_kind_of DateTime, given
+        assert_match match, given.strftime('%F %T'), comment
       end
     end
   end

data/test/test_transactions.rb

@@ -0,0 +1,76 @@
+require_relative 'helper'
+describe 'Adapter' do
+  supported_by Swift::DB::Postgres do #, Swift::DB::Mysql do
+    before do
+      Swift.db.execute %q{drop table if exists users}
+      Swift.db.execute %q{create table users(id serial, name text, created_at timestamp)}
+    end
+
+    describe 'transactions' do
+      before do
+        @name = 'test1 - transaction 1'
+        @db   = Swift.db
+      end
+
+      it 'yields db to block' do
+        @db.transaction do |db|
+          assert_kind_of Swift::Adapter, db
+        end
+
+        @db.transaction :sweet do |db|
+          assert_kind_of Swift::Adapter, db
+        end
+      end
+
+      describe 'commits work' do
+        before do
+          @db.execute('truncate users')
+        end
+
+        after do
+          @db.execute('select count(*) as c from users where name = ?', @name) {|r| assert_equal 1, r[:c] }
+        end
+
+        it 'should allow explicit commits' do
+          @db.transaction do |db|
+            db.execute('insert into users(name) values(?)', @name)
+            db.commit
+          end
+        end
+
+        it 'should autocommit' do
+          @db.transaction do |db|
+            db.execute('insert into users(name) values(?)', @name)
+          end
+        end
+      end
+
+      describe 'rollbacks work' do
+
+        before do
+          @db.execute('truncate users')
+        end
+
+        after do
+          @db.execute('select count(*) as c from users where name = ?', @name) {|r| assert_equal 0, r[:c] }
+        end
+
+        it 'should allow explicit rollbacks' do
+          @db.transaction do |db|
+            db.execute('insert into users(name) values(?)', @name)
+            db.rollback
+          end
+        end
+
+        it 'should auto rollback' do
+          assert_raises(RuntimeError) do
+            @db.transaction do |db|
+              db.execute('insert into users(name) values(?)', @name)
+              raise 'foo'
+            end
+          end
+        end
+      end
+    end
+  end
+end