cramp 0.5 → 0.6

data/lib/cramp/controller/abstract.rb

@@ -0,0 +1,59 @@
+module Cramp
+  module Controller
+    class Abstract
+
+      include Callbacks
+
+      class << self
+        def call(env)
+          controller = new(env).process
+        end
+      end
+
+      def initialize(env)
+        @env = env
+      end
+
+      def process
+        EM.next_tick { before_start }
+        ASYNC_RESPONSE
+      end
+
+      def continue
+        init_async_body
+
+        status, headers = respond_with
+        send_initial_response(status, headers, @body)
+
+        EM.next_tick { start } if respond_to?(:start)
+        EM.next_tick { on_start }
+      end
+
+      def respond_with
+        [200, {'Content-Type' => 'text/html'}]
+      end
+
+      def init_async_body
+        @body = Body.new
+
+        if self.class.on_finish_callbacks.any?
+          @body.callback { on_finish }
+          @body.errback { on_finish }
+        end
+      end
+
+      def finish
+        @body.succeed
+      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 halt(status, headers = {}, halt_body = '')
+        send_initial_response(status, headers, halt_body)
+      end
+
+    end
+  end
+end

data/lib/cramp/controller/action.rb

@@ -0,0 +1,22 @@
+module Cramp
+  module Controller
+    class Action < Abstract
+
+      include PeriodicTimer
+      include KeepConnectionAlive
+
+      def request
+        @request ||= Rack::Request.new(@env)
+      end
+
+      def params
+        @params ||= @env['usher.params']
+      end
+
+      def render(body)
+        @body.call(body)
+      end
+
+    end
+  end
+end

data/lib/cramp/controller/body.rb

@@ -1,13 +1,15 @@
-#  Copyright 2008 James Tucker <raggi@rubyforge.org>.
+# Copyright 2008 James Tucker <raggi@rubyforge.org>.
 
 module Cramp
   module Controller
     class Body
-
       include EventMachine::Deferrable
 
       def initialize
         @queue = []
+
+        # Make sure to flush out the queue before closing the connection
+        callback { flush }
       end
 
       def call(body)
@@ -24,14 +26,21 @@ module Cramp
         @deferred_status != :unknown
       end
 
-      private
+      def flush
+        return unless @body_callback
+
+        until @queue.empty?
+          @queue.shift.each {|chunk| @body_callback.call(chunk) }
+        end
+      end
 
       def schedule_dequeue
         return unless @body_callback
+
         EventMachine.next_tick do
           next unless body = @queue.shift
 
-          body.each{|chunk| @body_callback.call(chunk) }
+          body.each {|chunk| @body_callback.call(chunk) }
           schedule_dequeue unless @queue.empty?
         end
       end

data/lib/cramp/controller/callbacks.rb

@@ -0,0 +1,58 @@
+module Cramp
+  module Controller
+    module Callbacks
+
+      extend ActiveSupport::Concern
+
+      ASYNC_RESPONSE = [-1, {}, []].freeze
+      DEFAULT_STATUS = 200
+      DEFAULT_HEADERS =  { 'Content-Type' => 'text/html' }.freeze
+
+      included do
+        class_inheritable_accessor :default_status, :default_headers, :instance_reader => false
+        self.default_status = DEFAULT_STATUS
+        self.default_headers = DEFAULT_HEADERS
+
+        class_inheritable_accessor :before_start_callbacks, :on_finish_callbacks, :on_start_callback, :instance_reader => false
+        self.before_start_callbacks = []
+        self.on_finish_callbacks = []
+        self.on_start_callback = []
+      end
+
+      module ClassMethods
+        def before_start(*methods)
+          self.before_start_callbacks += methods
+        end
+
+        def on_finish(*methods)
+          self.on_finish_callbacks += methods
+        end
+
+        def on_start(*methods)
+          self.on_start_callback += methods
+        end
+      end
+
+      def before_start(n = 0)
+        if callback = self.class.before_start_callbacks[n]
+          EM.next_tick { send(callback) { before_start(n+1) } }
+        else
+          continue
+        end
+      end
+
+      def on_start
+        self.class.on_start_callback.each do |callback|
+          EM.next_tick { send(callback) }
+        end
+      end
+
+      def on_finish
+        self.class.on_finish_callbacks.each do |callback|
+          EM.next_tick { send(callback) }
+        end
+      end
+
+    end
+  end
+end

data/lib/cramp/controller/keep_connection_alive.rb

@@ -0,0 +1,21 @@
+module Cramp
+  module Controller
+    module KeepConnectionAlive
+
+      extend ActiveSupport::Concern
+      include PeriodicTimer
+
+      module ClassMethods
+        def keep_connection_alive(options = {})
+          options = { :every => 15 }.merge(options)
+          periodic_timer :keep_connection_alive, options
+        end
+      end
+
+      def keep_connection_alive
+        render " "
+      end
+
+    end
+  end
+end

data/lib/cramp/controller/periodic_timer.rb

@@ -0,0 +1,51 @@
+module Cramp
+  module Controller
+    module PeriodicTimer
+
+      extend ActiveSupport::Concern
+
+      included do
+        class_inheritable_accessor :periodic_timers, :instance_reader => false
+        self.periodic_timers ||= []
+      end
+
+      module ClassMethods
+        def periodic_timer(method, options = {})
+          self.periodic_timers << [method, options]
+        end
+      end
+
+      def initialize(*)
+        super
+        @timers = []
+      end
+
+      def continue
+        super
+        EM.next_tick { start_periodic_timers }
+      end
+
+      def init_async_body
+        super
+
+        if self.class.periodic_timers.any?
+          @body.callback { stop_periodic_timers }
+          @body.errback { stop_periodic_timers }
+        end
+      end
+
+      private
+
+      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
+
+    end
+  end
+end

data/lib/cramp/controller/rendering.rb

@@ -0,0 +1,13 @@
+module Cramp
+  module Controller
+    module Rendering
+
+      extend ActiveSupport::Concern
+
+      def render(body)
+        @body.call(body)
+      end
+
+    end
+  end
+end

data/lib/cramp/controller/test_case.rb

@@ -0,0 +1,57 @@
+require 'active_support'
+require 'active_support/test_case'
+
+module Cramp
+  module Controller
+    class TestCase < ::ActiveSupport::TestCase
+
+      setup :create_request
+
+      def create_request
+        @request = Rack::MockRequest.new(app)
+      end
+
+      def get(path, options = {}, headers = {}, &block)
+        callback = options.delete(:callback) || block
+        headers = headers.merge('async.callback' => callback)
+
+        EM.run { @request.get(path, headers) }
+      end
+
+      def get_body(path, options = {}, headers = {}, &block)
+        callback = options.delete(:callback) || block
+        response_callback = proc {|response| response[-1].each {|chunk| callback.call(chunk) } }
+        headers = headers.merge('async.callback' => response_callback)
+
+        EM.run { @request.get(path, headers) }
+      end
+
+      def get_body_chunks(path, options = {}, headers = {}, &block)
+        callback = options.delete(:callback) || block
+        count = options.delete(:count) || 1
+
+        stopping = false
+        chunks = []
+
+        get_body(path, options, headers) do |body_chunk|
+          chunks << body_chunk unless stopping
+
+          if chunks.count >= count
+            stopping = true
+            callback.call(chunks) if callback
+            EM.next_tick { EM.stop }
+          end
+        end
+      end
+
+      def app
+        raise "Please define a method called 'app' returning an async Rack Application"
+      end
+
+      def stop
+        EM.stop
+      end
+    end
+
+  end
+end

data/lib/cramp/controller.rb

@@ -1,14 +1,15 @@
-$:.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 'cramp'
 require 'usher'
 require 'rack'
 
 module Cramp
   module Controller
-    autoload :Base, "cramp/controller/base"
+    autoload :Action, "cramp/controller/action"
     autoload :Body, "cramp/controller/body"
+    autoload :PeriodicTimer, "cramp/controller/periodic_timer"
+    autoload :KeepConnectionAlive, "cramp/controller/keep_connection_alive"
+    autoload :Abstract, "cramp/controller/abstract"
+    autoload :Callbacks, "cramp/controller/callbacks"
+    autoload :TestCase, "cramp/controller/test_case"
   end
 end

data/lib/cramp/core_ext.rb

@@ -0,0 +1,4 @@
+module Kernel
+  alias :'_' :method
+  alias :callback :method
+end

data/lib/cramp/model/base.rb

@@ -38,17 +38,21 @@ module Cramp
         @new_record
       end
 
-      def save(&block)
+      def save(callback = nil, &block)
+        callback ||= block
+
         if valid?
-          new_record? ? create_record(&block) : update_record(&block)
+          new_record? ? create_record(callback) : update_record(callback)
         else
-          block.arity == 1 ? block.call(Status.new(self, false)) : block.call if block
+          callback.arity == 1 ? callback.call(Status.new(self, false)) : callback.call if callback
         end
       end
 
       private
 
-      def create_record(&block)
+      def create_record(callback = nil, &block)
+        callback ||= block
+
         self.class.arel_table.insert(arel_attributes(true)) do |new_id|
           if new_id.present?
             self.id = new_id
@@ -58,15 +62,17 @@ module Cramp
             saved = false
           end
 
-          block.arity == 1 ? block.call(Status.new(self, saved)) : block.call if block
+          callback.arity == 1 ? callback.call(Status.new(self, saved)) : callback.call if callback
         end
       end
 
-      def update_record(&block)
+      def update_record(callback = nil, &block)
+        callback ||= 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
+          callback.arity == 1 ? callback.call(updated_rows) : callback.call if callback
         end
       end
 

data/lib/cramp/model/finders.rb

@@ -2,17 +2,7 @@ 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
+      delegate :all, :first, :each, :where, :select, :group, :order, :limit, :offset, :to => :relation
 
       def [](attribute)
         arel_table[attribute]
@@ -22,6 +12,10 @@ module Cramp
         @arel_table ||= Arel::Table.new(table_name)
       end
 
+      def relation
+        Relation.new(self, arel_table)
+      end
+
       private
 
       def table_name

data/lib/cramp/model/relation.rb

@@ -6,37 +6,39 @@ module Cramp
         @klass, @relation = klass, relation
       end
 
-      def each(&block)
+      def each(callback = nil, &block)
+        callback ||= block
+
         @relation.each do |row|
           object = @klass.instantiate(row)
-          block.call(object)
+          callback.call(object)
         end
       end
 
-      def all(&block)
+      def all(callback = nil, &block)
+        callback ||= block
+
         @relation.all do |rows|
           objects = rows.map {|r| @klass.instantiate(r) }
-          block.call(objects)
+          callback.call(objects)
         end
       end
 
-      def first(&block)
+      def first(callback = nil, &block)
+        callback ||= block
+
         @relation.first do |row|
           object = row ? @klass.instantiate(row) : nil
-          block.call(object)
+          callback.call(object)
         end
       end
 
-      def select(selects)
-        Relation.new(@klass, @relation.project(selects))
-      end
-
-      def where(conditions)
-        Relation.new(@klass, @relation.where(conditions))
+      def where(*conditions)
+        Relation.new(@klass, @relation.where(*conditions))
       end
 
-      def select(selects)
-        Relation.new(@klass, @relation.project(selects))
+      def select(*selects)
+        Relation.new(@klass, @relation.project(*selects))
       end
 
       def group(groups)

data/lib/cramp/model/status.rb

@@ -2,6 +2,8 @@ module Cramp
   module Model
     class Status
 
+      attr_reader :record
+
       def initialize(record, success)
         @record = record
         @success = success

data/lib/cramp/model.rb

@@ -1,3 +1,4 @@
+require 'cramp'
 require 'cramp/model/evented_mysql'
 require 'cramp/model/emysql_ext'
 
@@ -25,6 +26,14 @@ module Cramp
       Arel::Table.engine = Cramp::Model::Engine.new(settings)
     end
 
+    def self.select(query, callback = nil, &block)
+      callback ||= block
+
+      EventedMysql.select(query) do |rows|
+        callback.arity == 1 ? callback.call(rows) : callback.call if callback
+      end
+    end
+
   end
 end
 

data/lib/cramp.rb

@@ -1,9 +1,12 @@
 require 'eventmachine'
+EM.epoll
 
 require 'active_support'
-require 'active_support/concern'
 require 'active_support/core_ext'
+require 'active_support/concern'
+
+require 'cramp/core_ext'
 
 module Cramp
-  VERSION = '0.5'
+  VERSION = '0.6'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: cramp
 version: !ruby/object:Gem::Version 
-  version: "0.5"
+  version: "0.6"
 platform: ruby
 authors: 
 - Pratik Naik
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-23 00:00:00 +05:30
+date: 2010-01-07 00:00:00 +05:30
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -93,9 +93,16 @@ extra_rdoc_files: []
 files: 
 - README
 - MIT-LICENSE
-- lib/cramp/controller/base.rb
+- lib/cramp/controller/abstract.rb
+- lib/cramp/controller/action.rb
 - lib/cramp/controller/body.rb
+- lib/cramp/controller/callbacks.rb
+- lib/cramp/controller/keep_connection_alive.rb
+- lib/cramp/controller/periodic_timer.rb
+- lib/cramp/controller/rendering.rb
+- lib/cramp/controller/test_case.rb
 - lib/cramp/controller.rb
+- lib/cramp/core_ext.rb
 - lib/cramp/model/arel_monkey_patches.rb
 - lib/cramp/model/attribute.rb
 - lib/cramp/model/attribute_methods.rb

data/lib/cramp/controller/base.rb

@@ -1,114 +0,0 @@
-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