raggi-async_sinatra 0.1.4

data/README.rdoc

@@ -0,0 +1,68 @@
+= async_sinatra (for Thin)
+    by James Tucker
+    http://ra66i.org
+    http://github.com/raggi/async_sinatra
+    http://libraggi.rubyforge.org/async_sinatra
+
+== DESCRIPTION:
+
+A Sinatra plugin to provide convenience whilst performing asynchronous
+responses inside of the Sinatra framework running under the Thin webserver.
+
+To properly utilise this package, some knowledge of EventMachine and/or
+asynchronous patterns is recommended.
+
+== SYNOPSIS:
+
+A quick example:
+
+ require 'sinatra/async'
+
+ class AsyncTest < Sinatra::Base
+   register Sinatra::Async
+
+   aget '/' do
+     body "hello async"
+   end
+
+   aget '/delay/:n' do |n|
+     EM.add_timer(n.to_i) { body { "delayed for #{n} seconds" } }
+   end
+
+ end
+
+See Sinatra::Async for more details.
+
+== REQUIREMENTS:
+
+* Sinatra (>= 0.9)
+* Thin    (>= 1.2)
+
+== INSTALL:
+
+* gem install async_sinatra
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 James Tucker
+
+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/Rakefile

@@ -0,0 +1,96 @@
+#!/usr/bin/env rake
+require 'rake/clean'
+
+task :default => :spec
+
+def spec(file = Dir['*.gemspec'].first)
+  @spec ||=
+  begin
+    require 'rubygems/specification'
+    Thread.abort_on_exception = true
+    data = File.read(file)
+    spec = nil
+    Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+    spec.instance_variable_set(:@filename, file)
+    def spec.filename; @filename; end
+    spec
+  end
+end
+
+def manifest; @manifest ||= `git ls-files`.split("\n").reject{|s|s=~/\.gemspec$|\.gitignore$/}; end
+
+require 'rake/gempackagetask'
+def gem_task; @gem_task ||= Rake::GemPackageTask.new(spec); end
+gem_task.define
+Rake::Task[:clobber].enhance [:clobber_package]
+
+require 'rake/testtask'
+Rake::TestTask.new(:spec) do |t|
+  t.test_files = spec.test_files
+  t.ruby_opts = ['-rubygems'] if defined? Gem
+  t.warning = true
+end unless spec.test_files.empty?
+
+require 'rake/rdoctask'
+df = begin; require 'rdoc/generator/darkfish'; true; rescue LoadError; end
+rdtask = Rake::RDocTask.new do |rd|
+  rd.title = spec.name
+  rd.main = spec.extra_rdoc_files.first
+  lib_rexp = spec.require_paths.map { |p| Regexp.escape p }.join('|')
+  rd.rdoc_files.include(*manifest.grep(/^(?:#{lib_rexp})/))
+  rd.rdoc_files.include(*spec.extra_rdoc_files)
+  rd.template = 'darkfish' if df
+end
+
+Rake::Task[:clobber].enhance [:clobber_rdoc]
+
+require 'yaml'
+require 'rake/contrib/sshpublisher'
+desc "Publish rdoc to rubyforge"
+task :publish => rdtask.name do
+  rf_cfg = File.expand_path '~/.rubyforge/user-config.yml'
+  host = "#{YAML.load_file(rf_cfg)['username']}@rubyforge.org"
+  remote_dir = "/var/www/gforge-projects/#{spec.rubyforge_project}/#{spec.name}/"
+  Rake::SshDirPublisher.new(host, remote_dir, rdtask.rdoc_dir).upload
+end
+
+desc 'Generate and open documentation'
+task :docs => :rdoc do
+  path = rdtask.send :rdoc_target
+  case RUBY_PLATFORM
+  when /darwin/       ; sh "open #{path}"
+  when /mswin|mingw/  ; sh "start #{path}"
+  else 
+    sh "firefox #{path}"
+  end
+end
+
+desc "Regenerate gemspec"
+task :gemspec => spec.filename
+
+task spec.filename do
+  spec.files = manifest
+  spec.test_files = manifest.grep(/(?:spec|test)\/*.rb/)
+  open(spec.filename, 'w') { |w| w.write spec.to_ruby }
+end
+
+desc "Bump version from #{spec.version} to #{spec.version.to_s.succ}"
+task :bump do
+  spec.version = spec.version.to_s.succ
+end
+
+desc "Tag version #{spec.version}"
+task :tag do
+  tagged = Dir.new('.git/refs/tags').entries.include? spec.version.to_s
+  if tagged
+    warn "Tag #{spec.version} already exists"
+  else
+    # TODO release message in tag message
+    sh "git tag #{spec.version}"
+  end
+end
+
+desc "Release #{gem_task.gem_file} to rubyforge"
+task :release => [:tag, :gem, :publish] do |t|
+  sh "rubyforge add_release #{spec.rubyforge_project} #{spec.name} #{spec.version} #{gem_task.package_dir}/#{gem_task.gem_file}"
+end

data/examples/basic.ru

@@ -0,0 +1,17 @@
+#!/usr/bin/env rackup -Ilib:../lib -s thin
+require 'sinatra/async'
+
+class AsyncTest < Sinatra::Base
+  register Sinatra::Async
+
+  aget '/' do
+    body "hello async"
+  end
+
+  aget '/delay/:n' do |n|
+    EM.add_timer(n.to_i) { body { "delayed for #{n} seconds" } }
+  end
+
+end
+
+run AsyncTest.new

data/lib/sinatra/async.rb

@@ -0,0 +1,84 @@
+require 'sinatra/base'
+
+module Sinatra #:nodoc:
+
+  # Normally Sinatra expects that the completion of a request is # determined
+  # by the block exiting, and returning a value for the body.
+  #
+  # In an async environment, we want to tell the webserver that we're not going
+  # to provide a response now, but some time in the future.
+  #
+  # The a* methods provide a method for doing this, by informing the server of
+  # our asynchronous intent, and then scheduling our action code (your block)
+  # as the next thing to be invoked by the server.
+  #
+  # This code can then do a number of things, including waiting (asynchronously)
+  # for external servers, services, and whatnot to complete. When ready to send
+  # the real response, simply setup your environment as you normally would for 
+  # sinatra (using #content_type, #headers, etc). Finally, you complete your
+  # response body by calling the #body method. This will push your body into the
+  # response object, and call out to the server to actually send that data.
+  #
+  # == Example
+  #  require 'sinatra/async'
+  #  
+  #  class AsyncTest < Sinatra::Base
+  #    register Sinatra::Async
+  #  
+  #    aget '/' do
+  #      body "hello async"
+  #    end
+  #  
+  #    aget '/delay/:n' do |n|
+  #      EM.add_timer(n.to_i) { body { "delayed for #{n} seconds" } }
+  #    end
+  #  
+  #  end
+  module Async
+    # Similar to Sinatra::Base#get, but the block will be scheduled to run
+    # during the next tick of the EventMachine reactor. In the meantime,
+    # Thin will hold onto the client connection, awaiting a call to 
+    # Async#body with the response.
+    def aget(path, opts={}, &block)
+      conditions = @conditions.dup
+      aroute('GET', path, opts, &block)
+
+      @conditions = conditions
+      aroute('HEAD', path, opts, &block)
+    end
+
+    # See #aget.
+    def aput(path, opts={}, &bk); aroute 'PUT', path, opts, &bk; end
+    # See #aget.
+    def apost(path, opts={}, &bk); aroute 'POST', path, opts, &bk; end
+    # See #aget.
+    def adelete(path, opts={}, &bk); aroute 'DELETE', path, opts, &bk; end
+    # See #aget.
+    def ahead(path, opts={}, &bk); aroute 'HEAD', path, opts, &bk; end
+
+    private
+    def aroute(*args, &block) #:nodoc:
+      self.send :route, *args do |*bargs|
+        mc = class << self; self; end
+        mc.send :define_method, :__async_callback, &block
+        EM.next_tick { send(:__async_callback, *bargs) }
+        throw :async      
+      end
+    end
+
+    module Helpers
+      # Send the given body or block as the final response to the asynchronous 
+      # request.
+      def body(*args, &blk)
+        super
+        request.env['async.callback'][
+          [response.status, response.headers, response.body]
+        ] if respond_to?(:__async_callback)
+      end
+    end
+
+    def self.registered(app) #:nodoc:
+      app.helpers Helpers
+    end
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: raggi-async_sinatra
+version: !ruby/object:Gem::Version 
+  version: 0.1.4
+platform: ruby
+authors: 
+- James Tucker
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-24 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: thin
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.4.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.8.3
+    version: 
+description: Asynchronous response API for Sinatra and Thin
+email: raggi@rubyforge.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- examples/basic.ru
+- lib/sinatra/async.rb
+has_rdoc: true
+homepage: http://libraggi.rubyforge.org/async_sinatra
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Async Sinatra
+- --main
+- README.rdoc
+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: libraggi
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Asynchronous response API for Sinatra and Thin
+test_files: []
+