cramp 0.0.1

data/README

@@ -0,0 +1,30 @@
+require 'rubygems'
+
+$: << File.join(File.dirname(__FILE__), "lib")
+require 'cramp/model'
+
+Cramp::Model.init(:username => 'root', :database => 'arel_development')
+
+class User < Cramp::Model::Base
+  attribute :id, :type => Integer, :primary_key => true
+  attribute :name
+
+  validates_presence_of :name
+end
+
+EM.run do
+  user = User.new
+
+  user.save do |status|
+    if status.success?
+      puts "WTF!"
+    else
+      puts "Oops. Found errors : #{user.errors.inspect}"
+
+      user.name = 'Lush'
+      user.save do
+        User.where(User[:name].eq('Lush')).all {|users| puts users.inspect; EM.stop }
+      end
+    end
+  end
+end

data/lib/cramp/controller/base.rb

@@ -0,0 +1,114 @@
+module Cramp
+  module Controller
+    class Base
+      ASYNC_RESPONSE = [-1, {}, []]
+
+      DEFAULT_STATUS = 200
+      DEFAULT_HEADERS =  { 'Content-Type' => 'text/html' }
+
+      def self.call(env)
+        controller = new(env).process
+      end
+
+      def self.set_default_response(status = 200, headers = DEFAULT_HEADERS)
+        @@default_status = 200
+        @@default_headers = headers
+      end
+
+      def self.default_status
+        defined?(@@default_status) ? @@default_status : DEFAULT_STATUS
+      end
+
+      def self.default_headers
+        defined?(@@default_headers) ? @@default_headers : DEFAULT_HEADERS
+      end
+
+      def self.periodic_timer(method, options = {})
+        @@periodic_timers ||= []
+        @@periodic_timers << [method, options]
+      end
+
+      def self.periodic_timers
+        defined?(@@periodic_timers) ? @@periodic_timers : []
+      end
+
+      def self.keep_connection_alive(options = {})
+        options = { :every => 30 }.merge(options)
+        periodic_timer :keep_connection_alive, options
+      end
+
+      def initialize(env)
+        @env = env
+        @timers = []
+      end
+
+      def process
+        EM.next_tick { before_start }
+        ASYNC_RESPONSE
+      end
+
+      def request
+        @request ||= Rack::Request.new(@env)
+      end
+
+      def params
+        @params ||= @env['usher.params']
+      end
+
+      def render(body)
+        @body.call(body)
+      end
+
+      def send_initial_response(response_status, response_headers, response_body)
+        EM.next_tick { @env['async.callback'].call [response_status, response_headers, response_body] }
+      end
+
+      def finish
+        EM.next_tick { @body.succeed }
+      end
+
+      def before_start
+        continue
+      end
+
+      def halt(status, headers = self.class.default_headers, halt_body = '')
+        send_initial_response(status, headers, halt_body)
+      end
+
+      def continue
+        init_async_body
+        send_initial_response(self.class.default_status, self.class.default_headers, @body)
+
+        EM.next_tick { start_periodic_timers }
+        EM.next_tick { start } if respond_to?(:start)
+      end
+
+      def init_async_body
+        @body = Body.new
+        @body.callback { on_finish }
+        @body.errback { on_finish }
+
+        @body.callback { stop_periodic_timers }
+        @body.errback { stop_periodic_timers }
+      end
+
+      def start_periodic_timers
+        self.class.periodic_timers.each do |method, options|
+          @timers << EventMachine::PeriodicTimer.new(options[:every] || 1) { send(method) }
+        end
+      end
+
+      def stop_periodic_timers
+        @timers.each {|t| t.cancel }
+      end
+
+      def on_finish
+      end
+
+      def keep_connection_alive
+        render " "
+      end
+
+    end
+  end
+end

data/lib/cramp/controller/body.rb

@@ -0,0 +1,41 @@
+#  Copyright 2008 James Tucker <raggi@rubyforge.org>.
+
+module Cramp
+  module Controller
+    class Body
+
+      include EventMachine::Deferrable
+
+      def initialize
+        @queue = []
+      end
+
+      def call(body)
+        @queue << body
+        schedule_dequeue
+      end
+
+      def each &blk
+        @body_callback = blk
+        schedule_dequeue
+      end
+
+      def closed?
+        @deferred_status != :unknown
+      end
+
+      private
+
+      def schedule_dequeue
+        return unless @body_callback
+        EventMachine.next_tick do
+          next unless body = @queue.shift
+
+          body.each{|chunk| @body_callback.call(chunk) }
+          schedule_dequeue unless @queue.empty?
+        end
+      end
+
+    end
+  end
+end

data/lib/cramp/controller.rb

@@ -0,0 +1,14 @@
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), 'vendor/activesupport/lib'))
+require 'active_support'
+require 'active_support/concern'
+require 'active_support/core_ext/hash/indifferent_access'
+
+require 'usher'
+require 'rack'
+
+module Cramp
+  module Controller
+    autoload :Base, "cramp/controller/base"
+    autoload :Body, "cramp/controller/body"
+  end
+end

data/lib/cramp/model/arel_monkey_patches.rb

@@ -0,0 +1,66 @@
+class Arel::Session
+  def create(insert, &block)
+    insert.call(&block)
+  end
+
+  def read(select, &block)
+    select.call(&block)
+  end
+
+  def update(update, &block)
+    update.call(&block)
+  end
+
+  def delete(delete, &block)
+    delete.call(&block)
+  end
+
+end
+
+class Arel::Relation
+  def call(&block)
+    engine.read(self, &block)
+  end
+
+  def all(&block)
+    session.read(self) {|rows| block.call(rows) }
+  end
+
+  def first(&block)
+    session.read(self) {|rows| block.call(rows[0]) }
+  end
+
+  def each(&block)
+    session.read(self) {|rows| rows.each {|r| block.call(r) } }
+  end
+
+  def insert(record, &block)
+    session.create(Arel::Insert.new(self, record), &block)
+  end
+
+  def update(assignments, &block)
+    session.update(Arel::Update.new(self, assignments), &block)
+  end
+
+  def delete(&block)
+    session.delete(Arel::Deletion.new(self), &block)
+  end
+end
+
+class Arel::Deletion
+  def call(&block)
+    engine.delete(self, &block)
+  end
+end
+
+class Arel::Insert
+  def call(&block)
+    engine.create(self, &block)
+  end
+end
+
+class Arel::Update
+  def call(&block)
+    engine.update(self, &block)
+  end
+end

data/lib/cramp/model/attribute.rb

@@ -0,0 +1,104 @@
+# Copyright (c) 2009 Koziarski Software Ltd
+# 
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+module Cramp
+  module Model
+    class Attribute
+
+      FORMATS = {}
+      FORMATS[Date]    = /^\d{4}\/\d{2}\/\d{2}$/
+      FORMATS[Integer] = /^-?\d+$/
+      FORMATS[Float]   = /^-?\d*\.\d*$/
+      FORMATS[Time]    = /\A\s*
+                -?\d+-\d\d-\d\d
+                T
+                \d\d:\d\d:\d\d
+                (\.\d*)?
+                (Z|[+-]\d\d:\d\d)?
+                \s*\z/ix # lifted from the implementation of Time.xmlschema
+
+      CONVERTERS = {}
+      CONVERTERS[Date] = Proc.new do |str|
+        Date.strptime(str, "%Y/%m/%d")
+      end
+
+      CONVERTERS[Integer] = Proc.new do |str|
+        Integer(str)
+      end
+
+      CONVERTERS[Float] = Proc.new do |str|
+        Float(str)
+      end
+
+      CONVERTERS[Time] = Proc.new do |str|
+        Time.xmlschema(str)
+      end
+
+      attr_reader :name
+      def initialize(name, owner_class, options)
+        @name = name.to_s
+        @owner_class = owner_class
+        @options = options
+
+        # append_validations!
+        define_methods!
+      end
+
+      # I think this should live somewhere in Amo
+      def check_value!(value)
+        # Allow nil and Strings to fall back on the validations for typecasting
+        # Everything else gets checked with is_a?
+        if value.nil?
+          nil
+        elsif value.is_a?(String)
+          value
+        elsif value.is_a?(expected_type)
+          value
+        else
+          raise TypeError, "Expected #{expected_type.inspect} but got #{value.inspect}"
+        end
+      end
+
+      def expected_type
+        @options[:type] || String
+      end
+
+      def type_cast(value)
+        if value.is_a?(expected_type)
+          value
+        elsif (converter = CONVERTERS[expected_type]) && (value =~ FORMATS[expected_type])
+          converter.call(value)
+        else
+          value
+        end
+      end
+
+      def append_validations!
+        if f = FORMATS[expected_type]
+          @owner_class.validates_format_of @name, :with => f, :unless => lambda {|obj| obj.send(name).is_a? expected_type }, :allow_nil => @options[:allow_nil]
+        end
+      end
+
+      def define_methods!
+        @owner_class.define_attribute_methods(true)
+      end
+
+      def primary_key?
+        @options[:primary_key]
+      end
+
+    end
+
+  end
+end

data/lib/cramp/model/attribute_methods.rb

@@ -0,0 +1,80 @@
+# Copyright (c) 2009 Koziarski Software Ltd
+# 
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+module Cramp
+  module Model
+    module AttributeMethods
+
+      extend ActiveSupport::Concern
+      include ActiveModel::AttributeMethods
+
+      module ClassMethods
+        def attribute(name, options = {})
+          write_inheritable_hash(:model_attributes, {name => Attribute.new(name, self, options)})
+        end
+
+        def define_attribute_methods(force = false)
+          return unless model_attributes
+          undefine_attribute_methods if force
+          super(model_attributes.keys)
+        end
+      end
+  
+      included do
+        class_inheritable_hash :model_attributes
+        undef_method(:id) if method_defined?(:id)
+
+        attribute_method_suffix("", "=")
+      end
+  
+      def write_attribute(name, value)
+        if ma = self.class.model_attributes[name.to_sym]
+          value = ma.check_value!(value)
+        end
+        @attributes[name] = value
+      end
+
+      def read_attribute(name)
+        if ma = self.class.model_attributes[name]
+          ma.type_cast(@attributes[name])
+        else
+          @attributes[name]
+        end
+      end
+
+      def attributes=(attributes)
+        attributes.each do |(name, value)|
+          send("#{name}=", value)
+        end
+      end
+
+      protected
+
+      def attribute_method?(name)
+        @attributes.include?(name.to_sym) || model_attributes[name.to_sym]
+      end
+
+      private
+
+      def attribute(name)
+        read_attribute(name.to_sym)
+      end
+
+      def attribute=(name, value)
+        write_attribute(name.to_sym, value)
+      end
+
+    end
+  end
+end

data/lib/cramp/model/base.rb

@@ -0,0 +1,86 @@
+module Cramp
+  module Model
+    class Base
+
+      extend Finders
+      include AttributeMethods
+      include ActiveModel::Validations
+
+      class << self
+        def columns
+          @columns ||= arel_table.columns
+        end
+
+        def column_names
+          columns.map(&:name)
+        end
+
+        def primary_key
+          @primary_key ||= model_attributes.detect {|k, v| v.primary_key? }[0]
+        end
+
+        def instantiate(record)
+          object = allocate
+          object.instance_variable_set("@attributes", record.with_indifferent_access)
+          object
+        end
+      end
+
+      attr_reader :attributes
+
+      def initialize(attributes = {})
+        @new_record = true
+        @attributes = {}.with_indifferent_access
+        self.attributes = attributes
+      end
+
+      def new_record?
+        @new_record
+      end
+
+      def save(&block)
+        if valid?
+          new_record? ? create_record(&block) : update_record(&block)
+        else
+          block.arity == 1 ? block.call(Status.new(self, false)) : block.call if block
+        end
+      end
+
+      private
+
+      def create_record(&block)
+        self.class.arel_table.insert(arel_attributes(true)) do |new_id|
+          if new_id.present?
+            self.id = new_id
+            saved = true
+            @new_record = false
+          else
+            saved = false
+          end
+
+          block.arity == 1 ? block.call(Status.new(self, saved)) : block.call if block
+        end
+      end
+
+      def update_record(&block)
+        relation = self.class.arel_table.where(self.class[self.class.primary_key].eq(send(self.class.primary_key)))
+
+        relation.update(arel_attributes) do |updated_rows|
+          block.arity == 1 ? block.call(updated_rows) : block.call if block
+        end
+      end
+
+      def arel_attributes(exclude_primary_key = true, attribute_names = @attributes.keys)
+        attrs = {}
+
+        attribute_names.each do |name|
+          value = read_attribute(name)
+          attrs[self.class.arel_table[name]] = value
+        end
+
+        attrs
+      end
+
+    end
+  end
+end

data/lib/cramp/model/column.rb

@@ -0,0 +1,72 @@
+# Some of it yanked from Rails
+
+# Copyright (c) 2004-2009 David Heinemeier Hansson
+# 
+# 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.
+
+module Cramp
+  module Model
+    class Column < Struct.new(:name, :default, :sql_type, :null)
+      attr_reader :type
+
+      def initialize(name, default, sql_type, null)
+        super
+        @type = simplified_type(sql_type)
+      end
+
+      private
+
+      def simplified_type(field_type)
+        case field_type
+          when /int/i
+            :integer
+          when /float|double/i
+            :float
+          when /decimal|numeric|number/i
+            extract_scale(field_type) == 0 ? :integer : :decimal
+          when /datetime/i
+            :datetime
+          when /timestamp/i
+            :timestamp
+          when /time/i
+            :time
+          when /date/i
+            :date
+          when /clob/i, /text/i
+            :text
+          when /blob/i, /binary/i
+            :binary
+          when /char/i, /string/i
+            :string
+          when /boolean/i
+            :boolean
+        end
+      end
+
+      def extract_scale(sql_type)
+        case sql_type
+          when /^(numeric|decimal|number)\((\d+)\)/i then 0
+          when /^(numeric|decimal|number)\((\d+)(,(\d+))\)/i then $4.to_i
+        end
+      end
+
+    end
+  end
+end

data/lib/cramp/model/emysql_ext.rb

@@ -0,0 +1,21 @@
+class EventedMysql
+  def self.execute_now(query)
+    @n ||= 0
+    connection = connection_pool[@n]
+    @n = 0 if (@n+=1) >= connection_pool.size
+    connection.execute_now(query)
+  end
+
+  def execute_now(sql)
+    log 'mysql sending', sql
+    @mysql.query(sql)
+  rescue Mysql::Error => e
+    log 'mysql error', e.message
+    if DisconnectErrors.include? e.message
+      @@queue << [response, sql, cblk, eblk]
+      return close
+    else
+      raise e
+    end
+  end
+end

data/lib/cramp/model/engine.rb

@@ -0,0 +1,45 @@
+module Cramp
+  module Model
+    class Engine
+      include Quoting
+
+      def initialize(settings)
+        @settings = settings
+        @quoted_column_names, @quoted_table_names = {}, {}
+
+        EventedMysql.settings.update(settings)
+      end
+
+      def create(relation, &block)
+        EventedMysql.insert(relation.to_sql) {|rows| yield(rows) if block_given? }
+      end
+
+      def read(relation, &block)
+        EventedMysql.select(relation.to_sql) {|rows| yield(rows) }
+      end
+
+      def update(relation)
+        EventedMysql.update(relation.to_sql) {|rows| yield(rows) if block_given? }
+      end
+
+      def delete(relation)
+        EventedMysql.delete(relation.to_sql) {|rows| yield(rows) if block_given? }
+      end
+
+      def adapter_name
+        "Cramp MySQL Async Adapter"
+      end
+
+      def columns(table_name, name = nil)
+        sql = "SHOW FIELDS FROM #{quote_table_name(table_name)}"
+        columns = []
+        result = EventedMysql.execute_now(sql)
+
+        result.each { |field| columns << Column.new(field[0], field[4], field[1], field[2] == "YES") }
+        result.free
+        columns
+      end
+
+    end
+  end
+end

data/lib/cramp/model/evented_mysql.rb

@@ -0,0 +1,298 @@
+# Async MySQL driver for Ruby/EventMachine
+#   (c) 2008 Aman Gupta (tmm1)
+# http://github.com/tmm1/em-mysql
+
+require 'eventmachine'
+require 'fcntl'
+
+class Mysql
+  def result
+    @cur_result
+  end
+end
+
+class EventedMysql < EM::Connection
+  def initialize mysql, opts
+    @mysql = mysql
+    @fd = mysql.socket
+    @opts = opts
+    @current = nil
+    @@queue ||= []
+    @processing = false
+    @connected = true
+
+    log 'mysql connected'
+
+    self.notify_readable = true
+    EM.add_timer(0){ next_query }
+  end
+  attr_reader :processing, :connected, :opts
+  alias :settings :opts
+
+  DisconnectErrors = [
+    'query: not connected',
+    'MySQL server has gone away',
+    'Lost connection to MySQL server during query'
+  ] unless defined? DisconnectErrors
+
+  def notify_readable
+    log 'readable'
+    if item = @current
+      @current = nil
+      start, response, sql, cblk, eblk = item
+      log 'mysql response', Time.now-start, sql
+      arg = case response
+            when :raw
+              result = @mysql.get_result
+              @mysql.instance_variable_set('@cur_result', result)
+              @mysql
+            when :select
+              ret = []
+              result = @mysql.get_result
+              result.each_hash{|h| ret << h }
+              log 'mysql result', ret
+              ret
+            when :update
+              result = @mysql.get_result
+              @mysql.affected_rows
+            when :insert
+              result = @mysql.get_result
+              @mysql.insert_id
+            else
+              result = @mysql.get_result
+              log 'got a result??', result if result
+              nil
+            end
+
+      @processing = false
+      # result.free if result.is_a? Mysql::Result
+      next_query
+      cblk.call(arg) if cblk
+    else
+      log 'readable, but nothing queued?! probably an ERROR state'
+      return close
+    end
+  rescue Mysql::Error => e
+    log 'mysql error', e.message
+    if e.message =~ /Deadlock/
+      @@queue << [response, sql, cblk, eblk]
+      @processing = false
+      next_query
+    elsif DisconnectErrors.include? e.message
+      @@queue << [response, sql, cblk, eblk]
+      return close
+    elsif cb = (eblk || @opts[:on_error])
+      cb.call(e)
+      @processing = false
+      next_query
+    else
+      raise e
+    end
+  # ensure
+  #   res.free if res.is_a? Mysql::Result
+  #   @processing = false
+  #   next_query
+  end
+
+  def unbind
+    log 'mysql disconnect', $!
+    # cp = EventedMysql.instance_variable_get('@connection_pool') and cp.delete(self)
+    @connected = false
+
+    # XXX wait for the next tick until the current fd is removed completely from the reactor
+    #
+    # XXX in certain cases the new FD# (@mysql.socket) is the same as the old, since FDs are re-used
+    # XXX without next_tick in these cases, unbind will get fired on the newly attached signature as well
+    #
+    # XXX do _NOT_ use EM.next_tick here. if a bunch of sockets disconnect at the same time, we want
+    # XXX reconnects to happen after all the unbinds have been processed
+    EM.add_timer(0) do
+      log 'mysql reconnecting'
+      @processing = false
+      @mysql = EventedMysql._connect @opts
+      @fd = @mysql.socket
+
+      @signature = EM.attach_fd @mysql.socket, true
+      EM.set_notify_readable @signature, true
+      log 'mysql connected'
+      EM.instance_variable_get('@conns')[@signature] = self
+      @connected = true
+      make_socket_blocking
+      next_query
+    end
+  end
+
+  def execute sql, response = nil, cblk = nil, eblk = nil, &blk
+    cblk ||= blk
+
+    begin
+      unless @processing or !@connected
+        # begin
+        #   log 'mysql ping', @mysql.ping
+        #   # log 'mysql stat', @mysql.stat
+        #   # log 'mysql errno', @mysql.errno
+        # rescue
+        #   log 'mysql ping failed'
+        #   @@queue << [response, sql, blk]
+        #   return close
+        # end
+
+        @processing = true
+
+        log 'mysql sending', sql
+        @mysql.send_query(sql)
+      else
+        @@queue << [response, sql, cblk, eblk]
+        return
+      end
+    rescue Mysql::Error => e
+      log 'mysql error', e.message
+      if DisconnectErrors.include? e.message
+        @@queue << [response, sql, cblk, eblk]
+        return close
+      else
+        raise e
+      end
+    end
+
+    log 'queuing', response, sql
+    @current = [Time.now, response, sql, cblk, eblk]
+  end
+
+  def close
+    @connected = false
+    fd = detach
+    log 'detached fd', fd
+  end
+
+  private
+
+  def next_query
+    if @connected and !@processing and pending = @@queue.shift
+      response, sql, cblk, eblk = pending
+      execute(sql, response, cblk, eblk)
+    end
+  end
+  
+  def log *args
+    return unless @opts[:logging]
+    p [Time.now, @fd, (@signature[-4..-1] if @signature), *args]
+  end
+
+  public
+
+  def self.connect opts
+    unless EM.respond_to?(:watch) and Mysql.method_defined?(:socket)
+      raise RuntimeError, 'mysqlplus and EM.watch are required for EventedMysql'
+    end
+
+    if conn = _connect(opts)
+      EM.watch conn.socket, self, conn, opts
+    else
+      EM.add_timer(5){ connect opts }
+    end
+  end
+
+  self::Mysql = ::Mysql unless defined? self::Mysql
+
+  # stolen from sequel
+  def self._connect opts
+    opts = settings.merge(opts)
+
+    conn = Mysql.init
+
+    # set encoding _before_ connecting
+    if charset = opts[:charset] || opts[:encoding]
+      conn.options(Mysql::SET_CHARSET_NAME, charset)
+    end
+
+    conn.options(Mysql::OPT_LOCAL_INFILE, 'client')
+
+    conn.real_connect(
+      opts[:host] || 'localhost',
+      opts[:user] || opts[:username] || 'root',
+      opts[:password],
+      opts[:database],
+      opts[:port],
+      opts[:socket],
+      0 +
+      # XXX multi results require multiple callbacks to parse
+      # Mysql::CLIENT_MULTI_RESULTS +
+      # Mysql::CLIENT_MULTI_STATEMENTS +
+      (opts[:compress] == false ? 0 : Mysql::CLIENT_COMPRESS)
+    )
+    
+    # increase timeout so mysql server doesn't disconnect us
+    # this is especially bad if we're disconnected while EM.attach is
+    # still in progress, because by the time it gets to EM, the FD is
+    # no longer valid, and it throws a c++ 'bad file descriptor' error
+    # (do not use a timeout of -1 for unlimited, it does not work on mysqld > 5.0.60)
+    conn.query("set @@wait_timeout = #{opts[:timeout] || 2592000}")
+
+    # we handle reconnecting (and reattaching the new fd to EM)
+    conn.reconnect = false
+
+    # By default, MySQL 'where id is null' selects the last inserted id
+    # Turn this off. http://dev.rubyonrails.org/ticket/6778
+    conn.query("set SQL_AUTO_IS_NULL=0")
+
+    # get results for queries
+    conn.query_with_result = true
+
+    conn
+  rescue Mysql::Error => e
+    if cb = opts[:on_error]
+      cb.call(e)
+      nil
+    else
+      raise e
+    end
+  end
+end
+
+class EventedMysql
+  def self.settings
+    @settings ||= { :connections => 4, :logging => false }
+  end
+
+  def self.execute query, type = nil, cblk = nil, eblk = nil, &blk
+    unless nil#connection = connection_pool.find{|c| not c.processing and c.connected }
+      @n ||= 0
+      connection = connection_pool[@n]
+      @n = 0 if (@n+=1) >= connection_pool.size
+    end
+
+    connection.execute(query, type, cblk, eblk, &blk)
+  end
+
+  %w[ select insert update delete raw ].each do |type| class_eval %[
+
+    def self.#{type} query, cblk = nil, eblk = nil, &blk
+      execute query, :#{type}, cblk, eblk, &blk
+    end
+
+  ] end
+
+  def self.all query, type = nil, &blk
+    responses = 0
+    connection_pool.each do |c|
+      c.execute(query, type) do
+        responses += 1
+        blk.call if blk and responses == @connection_pool.size
+      end
+    end
+  end
+
+  def self.connection_pool
+    @connection_pool ||= (1..settings[:connections]).map{ EventedMysql.connect(settings) }
+    # p ['connpool', settings[:connections], @connection_pool.size]
+    # (1..(settings[:connections]-@connection_pool.size)).each do
+    #   @connection_pool << EventedMysql.connect(settings)
+    # end unless settings[:connections] == @connection_pool.size
+    # @connection_pool
+  end
+
+  def self.reset_connection_pool!
+    @connection_pool = nil
+  end
+end

data/lib/cramp/model/finders.rb

@@ -0,0 +1,33 @@
+module Cramp
+  module Model
+    module Finders
+
+      def all
+        Relation.new(self, arel_table)
+      end
+
+      def first(&block)
+        Relation.new(self, arel_table).limit(1).each(&block)
+      end
+
+      def where(relation)
+        Relation.new(self, arel_table.where(relation))
+      end
+
+      def [](attribute)
+        arel_table[attribute]
+      end
+
+      def arel_table
+        @arel_table ||= Arel::Table.new(table_name)
+      end
+
+      private
+
+      def table_name
+        @table_name || self.to_s.pluralize
+      end
+
+    end
+  end
+end

data/lib/cramp/model/quoting.rb

@@ -0,0 +1,114 @@
+# Yanked from Rails
+
+# Copyright (c) 2004-2009 David Heinemeier Hansson
+# 
+# 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.
+
+module Cramp
+  module Model
+    module Quoting
+      def quote_column_name(name)
+        @quoted_column_names[name] ||= "`#{name}`"
+      end
+
+      def quote_table_name(name)
+        @quoted_table_names[name] ||= quote_column_name(name).gsub('.', '`.`')
+      end
+
+      def quote(value, column = nil)
+        if value.kind_of?(String) && column && column.type == :binary && column.class.respond_to?(:string_to_binary)
+          s = value.unpack("H*")[0]
+          "x'#{s}'"
+        elsif value.kind_of?(BigDecimal)
+          value.to_s("F")
+        else
+          super
+        end
+      end
+
+      def quote(value, column = nil)
+        # records are quoted as their primary key
+        return value.quoted_id if value.respond_to?(:quoted_id)
+
+        case value
+          when String, ActiveSupport::Multibyte::Chars
+            value = value.to_s
+            if column && column.type == :binary && column.class.respond_to?(:string_to_binary)
+              "#{quoted_string_prefix}'#{quote_string(column.class.string_to_binary(value))}'" # ' (for ruby-mode)
+            elsif column && [:integer, :float].include?(column.type)
+              value = column.type == :integer ? value.to_i : value.to_f
+              value.to_s
+            else
+              "#{quoted_string_prefix}'#{quote_string(value)}'" # ' (for ruby-mode)
+            end
+          when NilClass                 then "NULL"
+          when TrueClass                then (column && column.type == :integer ? '1' : quoted_true)
+          when FalseClass               then (column && column.type == :integer ? '0' : quoted_false)
+          when Float, Fixnum, Bignum    then value.to_s
+          # BigDecimals need to be output in a non-normalized form and quoted.
+          when BigDecimal               then value.to_s('F')
+          else
+            if value.acts_like?(:date) || value.acts_like?(:time)
+              "'#{quoted_date(value)}'"
+            else
+              "#{quoted_string_prefix}'#{quote_string(value.to_yaml)}'"
+            end
+        end
+      end
+
+      # Quotes a string, escaping any ' (single quote) and \ (backslash)
+      # characters.
+      def quote_string(s)
+        s.gsub(/\\/, '\&\&').gsub(/'/, "''") # ' (for ruby-mode)
+      end
+
+      # Quotes the column name. Defaults to no quoting.
+      def quote_column_name(column_name)
+        column_name
+      end
+
+      # Quotes the table name. Defaults to column name quoting.
+      def quote_table_name(table_name)
+        quote_column_name(table_name)
+      end
+
+      def quoted_true
+        "'t'"
+      end
+
+      def quoted_false
+        "'f'"
+      end
+
+      def quoted_date(value)
+        if value.acts_like?(:time)
+          zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+          value.respond_to?(zone_conversion_method) ? value.send(zone_conversion_method) : value
+        else
+          value
+        end.to_s(:db)
+      end
+
+      def quoted_string_prefix
+        ''
+      end
+    end
+  end
+end

data/lib/cramp/model/relation.rb

@@ -0,0 +1,60 @@
+module Cramp
+  module Model
+    class Relation
+
+      def initialize(klass, relation)
+        @klass, @relation = klass, relation
+      end
+
+      def each(&block)
+        @relation.each do |row|
+          object = @klass.instantiate(row)
+          block.call(object)
+        end
+      end
+
+      def all(&block)
+        @relation.all do |rows|
+          objects = rows.map {|r| @klass.instantiate(r) }
+          block.call(objects)
+        end
+      end
+
+      def first(&block)
+        @relation.first do |row|
+          object = row ? @klass.instantiate(row) : nil
+          block.call(object)
+        end
+      end
+
+      def select(selects)
+        Relation.new(@klass, @relation.project(selects))
+      end
+
+      def where(conditions)
+        Relation.new(@klass, @relation.where(conditions))
+      end
+
+      def select(selects)
+        Relation.new(@klass, @relation.project(selects))
+      end
+
+      def group(groups)
+        Relation.new(@klass, @relation.group(groups))
+      end
+
+      def order(orders)
+        Relation.new(@klass, @relation.order(orders))
+      end
+
+      def limit(limits)
+        Relation.new(@klass, @relation.take(limits))
+      end
+
+      def offset(offsets)
+        Relation.new(@klass, @relation.skip(offsets))
+      end
+
+    end
+  end
+end

data/lib/cramp/model/status.rb

@@ -0,0 +1,16 @@
+module Cramp
+  module Model
+    class Status
+
+      def initialize(record, success)
+        @record = record
+        @success = success
+      end
+
+      def success?
+        @success
+      end
+
+    end
+  end
+end

data/lib/cramp/model.rb

@@ -0,0 +1,30 @@
+require 'cramp/model/evented_mysql'
+require 'cramp/model/emysql_ext'
+
+require 'mysqlplus'
+
+require 'arel'
+require 'cramp/model/arel_monkey_patches'
+
+require 'active_model'
+
+module Cramp
+  module Model
+    autoload :Quoting, "cramp/model/quoting"
+    autoload :Engine, "cramp/model/engine"
+    autoload :Column, "cramp/model/column"
+    autoload :Relation, "cramp/model/relation"
+
+    autoload :Base, "cramp/model/base"
+    autoload :Finders, "cramp/model/finders"
+    autoload :Attribute, "cramp/model/attribute"
+    autoload :AttributeMethods, "cramp/model/attribute_methods"
+    autoload :Status, "cramp/model/status"
+
+    def self.init(settings)
+      Arel::Table.engine = Cramp::Model::Engine.new(settings)
+    end
+
+  end
+end
+

data/lib/cramp.rb

@@ -0,0 +1,9 @@
+require 'eventmachine'
+
+require 'active_support'
+require 'active_support/concern'
+require 'active_support/core_ext'
+
+module Cramp
+  VERSION = '0.1'
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification 
+name: cramp
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Pratik Naik
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-23 00:00:00 +05:30
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 3.0.pre
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activemodel
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 3.0.pre
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: arel
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.2.pre
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.1.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mysqlplus
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.1.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.1.1
+    version: 
+description: "    Cramp provides ORM and controller layers for developing asynchronous web applications.\n"
+email: pratiknaik@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- lib/cramp/controller/base.rb
+- lib/cramp/controller/body.rb
+- lib/cramp/controller.rb
+- lib/cramp/model/arel_monkey_patches.rb
+- lib/cramp/model/attribute.rb
+- lib/cramp/model/attribute_methods.rb
+- lib/cramp/model/base.rb
+- lib/cramp/model/column.rb
+- lib/cramp/model/emysql_ext.rb
+- lib/cramp/model/engine.rb
+- lib/cramp/model/evented_mysql.rb
+- lib/cramp/model/finders.rb
+- lib/cramp/model/quoting.rb
+- lib/cramp/model/relation.rb
+- lib/cramp/model/status.rb
+- lib/cramp/model.rb
+- lib/cramp.rb
+has_rdoc: true
+homepage: http://m.onkey.org
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Async ORM and controller layer.
+test_files: []
+