em-sequel-async 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,11 @@
+source :rubygems
+
+gem 'sequel'
+gem 'mysql2'
+gem 'eventmachine'
+
+group :development do
+  gem 'await'
+  gem 'bundler'
+  gem 'jeweler'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Scott Tadman
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,19 @@
+= em-sequel-async
+
+Description goes here.
+
+== Contributing to em-sequel-async
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2012 Scott Tadman. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake'
+require 'jeweler'
+
+Jeweler::Tasks.new do |gem|
+  gem.name = "em-sequel-async"
+  gem.homepage = "http://github.com/tadman/em-sequel-async"
+  gem.license = "MIT"
+  gem.summary = %Q{Asynchronous Helper Methods for Sequel}
+  gem.description = %Q{Implements a number of asynchronous helper methods for Sequel}
+  gem.email = "scott@twg.ca"
+  gem.authors = [ "Scott Tadman" ]
+end
+
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/em-sequel-async.gemspec

@@ -0,0 +1,67 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "em-sequel-async"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Scott Tadman"]
+  s.date = "2012-11-14"
+  s.description = "Implements a number of asynchronous helper methods for Sequel"
+  s.email = "scott@twg.ca"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "em-sequel-async.gemspec",
+    "lib/em-sequel-async.rb",
+    "lib/em-sequel-async/mysql.rb",
+    "lib/em-sequel-async/sequel_extensions.rb",
+    "lib/sequel/extensions/em_sequel_async.rb",
+    "test/helper.rb",
+    "test/test_em-sequel-async.rb"
+  ]
+  s.homepage = "http://github.com/tadman/em-sequel-async"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "Asynchronous Helper Methods for Sequel"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<sequel>, [">= 0"])
+      s.add_runtime_dependency(%q<mysql2>, [">= 0"])
+      s.add_runtime_dependency(%q<eventmachine>, [">= 0"])
+      s.add_development_dependency(%q<await>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+    else
+      s.add_dependency(%q<sequel>, [">= 0"])
+      s.add_dependency(%q<mysql2>, [">= 0"])
+      s.add_dependency(%q<eventmachine>, [">= 0"])
+      s.add_dependency(%q<await>, [">= 0"])
+      s.add_dependency(%q<bundler>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<sequel>, [">= 0"])
+    s.add_dependency(%q<mysql2>, [">= 0"])
+    s.add_dependency(%q<eventmachine>, [">= 0"])
+    s.add_dependency(%q<await>, [">= 0"])
+    s.add_dependency(%q<bundler>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+  end
+end
+

data/lib/em-sequel-async/mysql.rb

@@ -0,0 +1,145 @@
+class EmSequelAsync::Mysql
+  class ClientPool
+    # == Class Methods ======================================================
+    
+    def self.size=(value)
+      @size = value.to_i
+      @size = 1 if (@size <= 0)
+    end
+    
+    def self.size
+      @size ||= 4
+    end
+    
+    def self.trace?
+      !!@trace
+    end
+    
+    def self.trace
+      @trace
+    end
+    
+    def self.trace=(value)
+      @trace = value
+    end
+    
+    # == Instance Methods ===================================================
+    
+    def initialize(db)
+      @options = {
+        :symbolize_keys => true
+      }
+
+      db.opts.each do |key, value|
+        case (key)
+        when :database, :username, :password, :host, :port, :socket, :encoding, :charset, :compress, :timeout
+          @options[key] = value
+        when :user
+          @options[:username] = value
+        when :loggers
+          if (value and !value.empty?)
+            @options[:logging] = true
+            @options[:logger] = value.first
+          end
+        end
+      end
+      
+      @query_queue = [ ]
+
+      @connections = { }
+      @connection_pool = [ ]
+      @connections_active = { }
+      
+      @connection_limit = @options[:connections] || self.class.size
+      
+      if (EventMachine.reactor_running? and self.class.trace?)
+        EventMachine::PeriodicTimer.new(1) do
+          dump_file = "#{self.class.trace}.#{@options[:database]}"
+          
+          File.open(dump_file, 'w') do |f|
+            f.puts @options[:database]
+
+            @connections.each do |c, x|
+              f.puts "\t#{c.inspect} -> #{x.inspect}"
+            end
+            @connection_pool.each do |c|
+              f.puts "\t#{c.inspect} (pool)"
+            end
+          
+            @query_queue.each do |query, callback|
+              f.puts "\t#{query}"
+            end
+          end
+        end
+      end
+    end
+    
+    def logger
+      @options[:logger]
+    end
+    
+    def log(level, *args)
+      @options[:logger] and @options[:logger].send(level, *args)
+    end
+    
+    def add(connection)
+      @connections[connection] = nil
+      
+      if (@query_queue.empty?)
+        @connections_active.delete(connection)
+        @connection_pool << connection
+      else
+        self.delegate_query(connection, *@query_queue.pop)
+      end
+    end
+
+    def delegate_query(connection, query, callback)
+      @connections[connection] = [ query, callback ]
+
+      start = Time.now
+      deferrable = connection.query(query)
+      
+      deferrable.callback do |result|
+        log(:debug, "(%.6fs) [OK] %s" % [ Time.now - start, query ])
+        
+        callback.call(result, (Time.now - start).to_f, connection)
+
+        self.add(connection)
+      end
+      deferrable.errback do |err|
+        log(:error, "(%.6fs) [ERR] %s (%s: %s)" % [ Time.now - start, query, err.class, err ])
+        log(:error, err.backtrace)
+
+        callback.call(false, (Time.now - start).to_f, connection, err)
+
+        self.add(connection)
+      end
+    end
+    
+    def pool_connection
+      connection = @connection_pool.pop
+      
+      if (!connection and @connections.length < @connection_limit)
+        connection = Mysql2::EM::Client.new(@options)
+      end
+
+      @connections_active[connection] = true
+      
+      connection
+    end
+
+    def query(query, callback = nil, &block)
+      callback ||= block
+
+      if (connection = self.pool_connection)
+        self.delegate_query(connection, query, callback)
+        
+        :executing
+      else
+        @query_queue << [ query, callback ]
+
+        :queued
+      end
+    end
+  end
+end

data/lib/em-sequel-async/sequel_extensions.rb

@@ -0,0 +1,230 @@
+require 'mysql2'
+require 'sequel/adapters/mysql2'
+
+module EmSequelAsync::SequelExtensions
+  def self.install!
+    Mysql2::Result.send(:extend, Result::ClassMethods)
+    Mysql2::Result.send(:include, Result::InstanceMethods)
+    
+    Sequel::Mysql2::Database.send(:extend, Database::ClassMethods)
+    Sequel::Mysql2::Database.send(:include, Database::InstanceMethods)
+    
+    Sequel::Dataset.send(:extend, Dataset::ClassMethods)
+    Sequel::Dataset.send(:include, Dataset::InstanceMethods)
+
+    Sequel::Model.send(:extend, Model::ClassMethods)
+    Sequel::Model.send(:include, Model::InstanceMethods)
+  end
+  
+  module Result
+    module ClassMethods
+    end
+    
+    module InstanceMethods
+      def empty?
+        !self.any?
+      end
+    end
+  end
+  
+  module Database
+    module ClassMethods
+    end
+    
+    module InstanceMethods
+      def async
+        @async_db ||= EmSequelAsync::Mysql::ClientPool.new(self)
+      end
+    end
+  end
+  
+  # NOTE: This interface is borrowed from the deprecated tmm1/em-mysql gem.
+  
+  module Dataset
+    module ClassMethods
+      # None defined.
+    end
+    
+    module InstanceMethods
+      STOCK_COUNT_OPTS = {
+        :select => [ Sequel::LiteralString.new("COUNT(*)").freeze ],
+        :order => nil
+      }.freeze
+      
+      def async_insert(*args)
+        self.db.async.query(insert_sql(*args)) do |result, time, client, err|
+          yield(err ? nil : client.last_id) if (block_given?)
+        end
+
+        return
+      end
+      
+      def async_query_return_affected_rows(query)
+        self.db.async.query(query) do |result, time, client, err|
+          yield(err ? nil : client.affected_rows) if (block_given?)
+        end
+
+        return
+      end
+
+      def async_insert_ignore(*args, &block)
+        self.async_query_return_affected_rows(insert_ignore.insert_sql(*args), &block)
+      end
+
+      def async_update(*args, &block)
+        self.async_query_return_affected_rows(update_sql(*args), &block)
+      end
+
+      def async_delete(&block)
+        self.async_query_return_affected_rows(delete_sql, &block)
+      end
+
+      def async_multi_insert(*args, &block)
+        self.async_query_return_affected_rows(multi_insert_sql(*args).first, &block)
+      end
+
+      def async_multi_insert_ignore(*args, &block)
+        self.async_query_return_affected_rows(insert_ignore.multi_insert_sql(*args).first, &block)
+      end
+      
+      def async_fetch_rows(sql, iter = :each)
+        self.db.async.query(sql) do |result, time, client, err|
+          case (result)
+          when Mysql2::Result
+            case (iter)
+            when :each
+              result.each do |row|
+                yield(row)
+              end
+            else
+              yield(result.to_a)
+            end
+          end
+        end
+
+        return
+      end
+
+      def async_first(sql)
+        async_fetch_rows(sql, :each) do |result, time, client, err|
+          yield(rows && rows[0])
+
+          return
+        end
+      end
+
+      def async_each
+        async_fetch_rows(select_sql, :each) do |row|
+          if (row_proc = @row_proc)
+            yield(row_proc.call(row))
+          else
+            yield(row)
+          end
+        end
+
+        return
+      end
+
+      def async_all
+        async_fetch_rows(sql, :all) do |rows|
+          if (row_proc = @row_proc)
+            yield(rows.map { |row| row_proc.call(row) })
+          else
+            yield(rows)
+          end
+        end
+
+        return
+      end
+
+      def async_count(&callback)
+        if (options_overlap(Sequel::Dataset::COUNT_FROM_SELF_OPTS))
+          from_self.async_count(&callback)
+        else
+          clone(STOCK_COUNT_OPTS).async_each do |row|
+            callback.call(
+              case (row)
+              when Hash
+                row.values.first.to_i
+              else
+                row.values.values.first.to_i
+              end
+            )
+          end
+        end
+        
+        return
+      end
+    end
+  end
+
+  module Model
+    module ClassMethods
+      [ :async_insert,
+        :async_insert_ignore,
+        :async_multi_insert,
+        :async_multi_insert_ignore,
+        :async_each,
+        :async_all,
+        :async_update,
+        :async_count,
+        :async_delete
+      ].each do |method|
+         eval %Q[
+          def #{method}(*args, &callback)
+            dataset.#{method}(*args, &callback)
+          end
+        ]
+      end
+
+      # This differs from async_multi_insert_ignore in that it takes an
+      # array of hashes rather than a series of arrays. The columns are
+      # automatically determined based on the keys of first hash provided.
+      def async_multi_insert_ignore_hash(hashes)
+        if (hashes.empty?)
+          yield if (block_given?)
+
+          return
+        end
+
+        columns = hashes.first.keys
+
+        insertions = hashes.collect do |row|
+          columns.collect { |c| row[c] }
+        end
+
+        async_multi_insert_ignore(columns, insertions) do |n|
+          yield(n) if (block_given?)
+        end
+      end
+
+      # Async version of Model#[]
+      def async_lookup(args)
+        unless (Hash === args)
+          args = primary_key_hash(args)
+        end
+
+        dataset.where(args).limit(1).async_all do |rows|
+          yield(rows.any? ? rows.first : nil)
+        end
+
+        return
+      end
+    end
+
+    module InstanceMethods
+      def async_update(*args, &callback)
+        this.async_update(*args, &callback)
+        set(*args)
+
+        self
+      end
+
+      def async_delete(&callback)
+        this.async_delete(&callback)
+
+        return
+      end
+    end
+  end
+end

data/lib/em-sequel-async.rb

@@ -0,0 +1,6 @@
+require 'mysql2/em'
+
+module EmSequelAsync
+  autoload(:Mysql, 'em-sequel-async/mysql')
+  autoload(:SequelExtensions, 'em-sequel-async/sequel_extensions')
+end

data/lib/sequel/extensions/em_sequel_async.rb

@@ -0,0 +1,3 @@
+module Sequel::EmSequelAsync
+  ::EmSequelAsync::SequelExtensions.install!
+end

data/test/helper.rb

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+
+  exit e.status_code
+end
+
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'em-sequel-async'
+
+require 'mysql2'
+require 'sequel'
+require 'eventmachine'
+
+Sequel.extension(:em_sequel_async)
+
+require 'await'
+
+class Test::Unit::TestCase
+  include Await
+  
+  def em
+    EventMachine.run do
+      Fiber.new do
+        yield
+
+        EventMachine.stop_event_loop
+      end.resume
+    end
+  end
+end

data/test/test_em-sequel-async.rb

@@ -0,0 +1,209 @@
+require File.expand_path('helper', File.dirname(__FILE__))
+
+DB_CONFIG = {
+  :default => {
+    :adapter => 'mysql2',
+    :username => 'test',
+    :password => 'JAQv0RM6xFVb8yz06GiQ7mOq',
+    :database => 'emsa_test_default'
+  },
+  :a => {
+    :adapter => 'mysql2',
+    :username => 'test',
+    :password => 'JAQv0RM6xFVb8yz06GiQ7mOq',
+    :database => 'emsa_test_a'
+  },
+  :b => {
+    :adapter => 'mysql2',
+    :username => 'test',
+    :password => 'JAQv0RM6xFVb8yz06GiQ7mOq',
+    :database => 'emsa_test_b'
+  }
+}.freeze
+
+DB = Hash[DB_CONFIG.collect { |db, config| [ db, Sequel.connect(config) ] }]
+
+{
+  :default => %w[ db_default_a_models db_default_b_models ],
+  :a => %w[ example_as ],
+  :b => %w[ example_bs ]
+}.each do |db, tables|
+  create_config = DB_CONFIG[db].dup
+  db_name = create_config.delete(:database)
+  
+  handle = Mysql2::Client.new(create_config)
+  db_name = DB_CONFIG[db][:database]
+  
+  handle.query("DROP DATABASE IF EXISTS `#{db_name}`")
+  handle.query("CREATE DATABASE `#{db_name}`")
+  handle.query("USE `#{db_name}`")
+
+  tables.each do |table|
+    handle.query("CREATE TABLE `#{table}` (id INT AUTO_INCREMENT PRIMARY KEY, data VARCHAR(255))")
+  end
+end
+
+class DbDefaultAModel < Sequel::Model
+end
+
+class DbDefaultBModel < Sequel::Model
+end
+
+class DbAModel < Sequel::Model(DB[:a][:example_as])
+end
+
+class DbBModel < Sequel::Model(DB[:b][:example_bs])
+end
+
+class TestEmSequelAsync < Test::Unit::TestCase
+  def test_module
+    assert EmSequelAsync
+  end
+  
+  def test_async_db_handle
+    assert DbDefaultAModel.db
+    assert DbDefaultAModel.db.async
+    
+    assert_equal DbDefaultAModel.db, DbDefaultBModel.db
+    assert_not_equal DbAModel.db, DbDefaultBModel.db
+    assert_not_equal DbAModel.db, DbBModel.db
+    
+    assert_equal DbDefaultAModel.db.async, DbDefaultBModel.db.async
+    assert_not_equal DbAModel.db.async, DbDefaultBModel.db.async
+    assert_not_equal DbAModel.db.async, DbBModel.db.async
+  end
+
+  def test_model_async_insert
+    inserted_id = nil
+    
+    em do
+      await do
+        DbDefaultAModel.async_insert(
+          :data => 'Test Name',
+          &defer do |id|
+            inserted_id = id
+          end
+        )
+
+        assert_equal nil, inserted_id
+      end
+    end
+
+    assert inserted_id
+    assert inserted_id > 0
+  end
+  
+  def test_model_async_insert_ignore
+    inserted_id = nil
+    inserted_count = nil
+    found_count = nil
+    deleted_count = nil
+
+    em do
+      await do
+        DbDefaultAModel.async_insert(
+          :data => 'Test Name',
+          &defer do |id|
+            inserted_id = id
+            
+            assert inserted_id > 0
+
+            DbDefaultAModel.where(:id => inserted_id).async_count(
+              &defer do |count|
+                found_count = count
+              end
+            )
+
+            DbDefaultAModel.async_insert_ignore(
+              :id => inserted_id,
+              :data => 'Duplicate',
+              &defer do |count|
+                inserted_count = count
+              end
+            )
+          end
+        )
+      end
+      
+      assert_equal 0, inserted_count
+      assert_equal 1, found_count
+    end
+    
+    em do
+      found_count = nil
+      delete_count = nil
+      inserted_count = nil
+      
+      await do |a|
+        DbDefaultAModel.where(:id => inserted_id).async_delete(
+          &defer do |count|
+            deleted_count = count
+            
+            assert_equal 1, deleted_count
+
+            DbDefaultAModel.where(:id => inserted_id).async_count(
+              &defer do |count|
+                found_count = count
+
+                DbDefaultAModel.async_insert_ignore(
+                  :id => inserted_id,
+                  :data => 'Duplicate',
+                  &defer do |count|
+                    inserted_count = count
+                  end
+                )
+              end
+            )
+          end
+        )
+      end
+    end
+    
+    assert_equal 0, found_count
+    assert_equal 1, deleted_count
+    assert_equal 1, inserted_count
+  end
+  
+  def test_dataset_async_count
+    models_count = nil
+    
+    em do
+      await do
+        DB[:default][:db_default_a_models].async_count(
+          &defer do |count|
+            models_count = count
+          end
+        )
+      end
+    end
+    
+    assert_equal DB[:default][:db_default_a_models].count, models_count
+  end
+
+  def test_dataset_async_insert_duplicate
+    em do
+      inserted_id = nil
+      duplicate_id = false
+      
+      await do
+        DbDefaultAModel.async_insert(
+          :data => 'Test Name',
+          &defer do |id|
+            inserted_id = id
+            
+            DbDefaultAModel.async_insert(
+              :id => inserted_id,
+              :data => 'Duplicate',
+              &defer do |*f|
+                duplicate_id = f[0]
+              end
+            )
+          end
+        )
+      end
+      
+      assert inserted_id
+      assert_equal nil, duplicate_id
+    end
+  end
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: em-sequel-async
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Scott Tadman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: await
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Implements a number of asynchronous helper methods for Sequel
+email: scott@twg.ca
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- em-sequel-async.gemspec
+- lib/em-sequel-async.rb
+- lib/em-sequel-async/mysql.rb
+- lib/em-sequel-async/sequel_extensions.rb
+- lib/sequel/extensions/em_sequel_async.rb
+- test/helper.rb
+- test/test_em-sequel-async.rb
+homepage: http://github.com/tadman/em-sequel-async
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Asynchronous Helper Methods for Sequel
+test_files: []