sinatra-diet 0.1.0

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Samuel Cochran
+
+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.md

@@ -0,0 +1,101 @@
+# Sinatra Diet
+
+*Warning:* This is stuff I'm playing with, definitely not ready for anything production.
+
+[Sinatra][sinatra] on a Diet gets [Thin][thin] and [Skinny][skinny], asynchronously
+
+Sometimes Sinatra can get a bit fat--he's squeezing through the doorway, gets stuck, and nobody else can get through for a while. It's time to go on a diet to get [Thin][thin] and [Skinny][skinny].
+
+One of Thin's greatest strength is asynchronous responses. This adds two ways to do so from within Sinatra: plain asynchronous responses and WebSockets (via [Skinny][skinny]).
+
+This is actually two Sinatra extensions:
+
+## Sinatra::Async
+
+I know there's already [a sinatra-async extension](http://github.com/tmm1/async_sinatra) but I felt it was overly complex and didn't quite add what I wanted. My take on asynchronous Sinatra tried to be a little simpler. For the timeless classic:
+
+    register Sinatra::Async
+    
+    get '/' do
+      async do
+        "Hello, World"
+      end
+    end
+
+This literally just delays response to the next available EventMachine tick.
+
+If you actually want to wait on a long-running asynchronous operation you have a couple of options. You can yield a deferrable and succeed it with the response:
+
+    get '/long' do
+      async do
+        @deferrable = EM::Deferrable.new
+      end
+    end
+    
+    # somewhere else:
+    @deferrable.succeed "Hello, world!"
+
+You can also use a long-running operation which will call #async\_respond explicitly. EM::Timers, EM::PeriodicTimers and nil responses to an async block mean you'll call #async\_respond later:
+
+    get '/long' do
+      async do
+        EventMachine::Timer.new(2) do
+          async_respond 'Hello, world!'
+        end
+      end
+    end
+
+## Sinatra::WebSocket
+
+Build websockets simply and easily using a Sinatra-inspired DSL:
+
+    register Sinatra::Async
+    
+    websocket do |client, message|
+      client.send "You said: #{message}"
+    end
+
+They catch GET websocket requests only, by default. You can also mount them on a path and give them explicit options:
+
+    websocket '/hello',
+      :on_handshake => proc do |client|
+        client.send "Hi!"
+        client.finish!
+      end
+
+The clients are Skinny::WebSocket instances, and you can supply any options you would normally pass to an instance in the handler call:
+
+    websocket '/thing',
+      :protocol => "adder",
+      :on_message => proc do |client, message|
+        client.send message.split(' ').compact.map(&:to_i).inject(0, &:+)
+      end
+
+Keep in mind that the proc callbacks supplied as options here are executed in the scope in which they're defined, here in the class scope of your sinatra app. This is _by design_--executing each handler inside a Sinatra instance means that instance (which is copied for every request) must hang around for the WebSocket connection's entire lifetime. If you want this, please implement it yourself.
+
+Don't forget that the websocket client connection has a copy of the request's environment (as #env) which you can use inside callbacks.
+
+## Caveats
+
+*Be aware:* Long-running requests will keep a whole copy of your Sinatra app around until you complete them. Be careful to close every request and websocket you handle asynchronously or you'll find yourself in memory leak city.
+
+This stuff only works on Thin. Patches for other EventMachine-based servers are welcome. Other wild and exotic servers are also considered, if you're brave! I'm looking at [ControlTower][controltower], mainly.
+
+## TODO
+
+ * Lightweight WebSocket channels.
+ * ???
+ * Profit
+
+## Copyright
+
+Copyright (c) 2010 Samuel Cochran. See LICENSE for details.
+
+## P.S.
+
+Do I get points for taking a metaphor too far?
+
+  [controltower]: http://github.com/MacRuby/ControlTower
+  [skinny]: http://github.com/sj26/skinny
+  [sinatra]: http://github.com/sinatra/sinatra
+  [thin]: http://github.com/macournoyer/thin

data/Rakefile

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "sinatra-diet"
+    gem.summary = %Q{Sinatra on a Diet gets Thin and Skinny}
+    gem.description = %Q{Sinatra can be aynchronous and provide WebSockets using Thin and Skinny.}
+    gem.email = "sj26@sj26.com"
+    gem.homepage = "http://github.com/sj26/sinatra-diet"
+    gem.authors = ["Samuel Cochran"]
+    
+    gem.add_dependency "sinatra", ">= 0"
+    gem.add_dependency "thin", ">= 0"
+    gem.add_dependency "skinny", ">= 0.1.2"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end

data/VERSION

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

data/examples/async.ru

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'sinatra/base'
+require 'sinatra-diet'
+
+class Application < Sinatra::Base
+  register Sinatra::Async
+  
+  get '/' do
+    async do 
+      'Hello, world!'
+    end
+  end
+end
+
+run Application

data/examples/chat.ru

@@ -0,0 +1,69 @@
+require 'rubygems'
+require 'sinatra/base'
+require 'sinatra-diet'
+
+class Application < Sinatra::Base
+  register Sinatra::WebSocket
+  
+  def self.listeners
+    @@listeners ||= []
+  end
+  
+  def self.said
+    @@said ||= []
+  end
+  
+  def self.say what
+    said << what
+    EM.next_tick do
+      listeners.each do |listener|
+        listener.send_message what
+      end
+    end
+  end
+  
+  websocket '/',
+    :on_handshake => proc { |client| listeners << client },
+    :on_message => proc { |client, message| say message },
+    :on_close => proc { |client| listeners.delete client }
+  
+  get '/' do
+    <<-HTML
+    <!DOCTYPE html>
+    <html>
+      <head>
+        <title>Simple Chat</title>
+        <script src="http://code.jquery.com/jquery.js"></script>
+        <script type="text/javascript">
+          jQuery(function ($) {
+            var websocket = new WebSocket("#{request.url.sub(/^http/, 'ws')}"),
+              $form = $('form'), $message = $('input[name="message"]', $form);
+            websocket.onmessage = function(message) {
+              $('#said').prepend(message.data + "\\n");
+            };
+            $form.submit(function () {
+              websocket.send($message.val());
+              $message.val("");
+              return false;
+            });
+            $message.focus();
+          });
+        </script>
+      </head>
+      <body>
+        <form action="/say" method="post">
+          <input type="text" name="message" style="width: 100%;" />
+          <pre id="said" style="height: 20em; overflow: auto; border: 1px inset;">#{self.class.said.reverse.collect { |message| message + "\n" }.join ''}</pre>
+        </form>
+      </body>
+    </html>
+    HTML
+  end
+  
+  post '/say' do
+    self.class.say params[:message]
+    redirect '/'
+  end
+end
+
+run Application

data/examples/delayed.ru

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'sinatra/base'
+require 'sinatra-diet'
+
+class Application < Sinatra::Base
+  register Sinatra::Async
+  
+  get '/' do
+    async do
+      EventMachine::Timer.new(2) do
+        async_respond 'Hello, world!'
+      end
+    end
+  end
+end
+
+run Application

data/examples/echo.ru

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'sinatra/base'
+require 'sinatra-diet'
+
+class Application < Sinatra::Base
+  register Sinatra::WebSocket
+  
+  get '/' do
+    '<script>' +
+    'var websocket = new WebSocket("ws://localhost:3000/echo");' +
+    'websocket.onmessage=function(message){' +
+    'document.getElementById(\'transcript\').innerHTML+=message.data+"\n";' +
+    '}' +
+    '</script>' +
+    '<form onsubmit="websocket.send(this.message.value);this.message.value=\'\';return false">' +
+    '<input name="message" type="text" />' +
+    '</form>' +
+    '<pre id="transcript"></pre>'
+  end
+  
+  websocket '/echo' do |connection, message|
+    connection.send_message "You said: #{message}"
+  end
+end
+
+run Application

data/lib/sinatra-diet.rb

@@ -0,0 +1,2 @@
+require 'sinatra/async'
+require 'sinatra/websocket'

data/lib/sinatra/async.rb

@@ -0,0 +1,81 @@
+module Sinatra::Async
+  def self.registered base
+    base.send :include, InstanceMethods
+  end
+  
+  module InstanceMethods
+    # Repond to this request asynchronously.
+    # 
+    # Can be passed a block or method name which will be queued for
+    # execution, or just aborts the current flow and presumes
+    # you'll respond later.
+    # 
+    # The return value of the supplied block or method will be used
+    # as a response, as per a normal Sinatra route handler, unless:
+    # 
+    #  * If it is an EM::Deferrable, we will respond as a succeed
+    #    callback.
+    # 
+    #  * If it is nil, is an EM::Timer or EM::PeriodicTimer we
+    #    presume you'll respond later using #async_respond.
+    def async method_name=nil, &block
+      raise RuntimeError, 'Not running in async capable server -- try Thin' unless env.has_key?('async.callback')
+      
+      block ||= method method_name if method_name
+      
+      if block
+        EM.next_tick do
+          catch :async do
+            returned = invoke { route_eval &block }
+            
+            if returned.is_a? EventMachine::Deferrable
+              returned.callback do |*args|
+                invoke { throw :halt, args.first } unless args.empty?
+                async_call!
+              end
+            elsif returned.is_a?(EventMachine::Timer) || returned.is_a?(EventMachine::PeriodicTimer)
+              returned = nil
+            end
+            
+            async_call! unless returned.nil?
+          end
+        end
+      end
+    
+      throw :async
+    end
+    
+    # Respond to an existing asynchronous request.
+    def async_respond response
+      invoke { throw :halt, response }
+      async_call!
+    end
+  
+    # Resumes #call! and sends an asynchronous response
+    # 
+    # To DRY this up we'd need to break up Sinatra::Base#call!
+    def async_call!
+      invoke { error_block! response.status }
+    
+      unless @response['Content-Type']
+        if body.respond_to?(:to_ary) and body.first.respond_to? :content_type
+          content_type body.first.content_type
+        else
+          content_type :html
+        end
+      end
+
+      status, header, body = @response.finish
+
+      # Never produce a body on HEAD requests. Do retain the Content-Length
+      # unless it's "0", in which case we assume it was calculated erroneously
+      # for a manual HEAD response and remove it entirely.
+      if @env['REQUEST_METHOD'] == 'HEAD'
+        body = []
+        header.delete('Content-Length') if header['Content-Length'] == '0'
+      end
+
+      env['async.callback'].call [status, header, body]
+    end
+  end
+end

data/lib/sinatra/websocket.rb

@@ -0,0 +1,22 @@
+require 'skinny'
+
+module Sinatra::WebSocket
+  WEBSOCKET_OPTIONS = [:protocol, :on_open, :on_start, :on_handshake, :on_message, :on_error, :on_finish, :on_close]
+  
+  def self.registered base
+    base.send :include, Skinny::Helpers
+  end
+  
+  def websocket path='*', options={}, &block
+    # No nice way to do this in core?
+    websocket_options = options.select { |key, value| WEBSOCKET_OPTIONS.include? key }
+    options.reject! { |key, value| WEBSOCKET_OPTIONS.include? key }
+    
+    condition { websocket? }
+    
+    route 'GET', path, options do
+      websocket! websocket_options.dup, &block
+      throw :async
+    end
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification 
+name: sinatra-diet
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Samuel Cochran
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-01 00:00:00 +08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: thin
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: skinny
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 2
+        version: 0.1.2
+  type: :runtime
+  version_requirements: *id003
+description: Sinatra can be aynchronous and provide WebSockets using Thin and Skinny.
+email: sj26@sj26.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- examples/async.ru
+- examples/chat.ru
+- examples/delayed.ru
+- examples/echo.ru
+- lib/sinatra-diet.rb
+- lib/sinatra/async.rb
+- lib/sinatra/websocket.rb
+has_rdoc: true
+homepage: http://github.com/sj26/sinatra-diet
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Sinatra on a Diet gets Thin and Skinny
+test_files: []
+