rufus-sixjo 0.1.0

data/README.txt

@@ -0,0 +1,87 @@
+
+= 'rufus-sixjo'
+
+== what is it ?
+
+A 'Rack application' for
+
+
+== features
+
+not many.
+
+
+== getting it
+
+    sudo gem install -y rufus-sixjo
+
+or download[http://rubyforge.org/frs/?group_id=4812] it from RubyForge.
+
+
+== usage
+
+see under the examples/ directory : http://github.com/jmettraux/rufus-sixjo/tree/master/examples
+
+It goes like :
+
+    require 'rubygems'
+    require 'rufus/sixjo' # gem 'rufus-sixjo'
+    
+    module ExampleOne
+    
+      extend Rufus::Sixjo
+      
+      get '/toto' do
+        "nada at #{request.path_info}"
+      end
+    end
+      
+    app = Rack::Builder.new do
+      
+      use Rack::CommonLogger
+      use Rack::ShowExceptions
+      run ExampleOne.new_sixjo_rack_app(nil)
+    end
+    
+    Rack::Handler::Mongrel.run app, :Port => 2042
+
+
+== dependencies
+
+the 'rack' gem
+
+
+== mailing list
+
+On the Rufus-Ruby list[http://groups.google.com/group/rufus-ruby] :
+
+    http://groups.google.com/group/rufus-ruby
+
+
+== issue tracker
+
+    http://rubyforge.org/tracker/?atid=18584&group_id=4812&func=browse
+
+
+== source
+
+http://github.com/jmettraux/rufus-sixjo
+
+    git clone git://github.com/jmettraux/rufus-sixjo.git
+
+
+== author
+
+John Mettraux, jmettraux@gmail.com,
+http://jmettraux.wordpress.com
+
+
+== the rest of Rufus
+
+http://rufus.rubyforge.org
+
+
+== license
+
+MIT
+

data/lib/rufus/sixjo.rb

@@ -0,0 +1,353 @@
+#
+#--
+# Copyright (c) 2008, John Mettraux, jmettraux@gmail.com
+#
+# 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.
+#++
+#
+
+#
+# "made in Japan"
+#
+
+require 'erb'
+require 'rack'
+
+
+class Rack::Request
+
+  def content
+    @env['rack.request.form_vars']
+  end
+end
+
+class Rack::Response
+
+  def location= (l)
+    header['Location'] = l
+  end
+  def content_type= (t)
+    header['Content-type'] = t
+  end
+end
+
+
+module Rufus
+
+  module Sixjo
+
+    VERSION = "0.1.0"
+
+    #
+    # Sixjo's Rack app
+    #
+    class App
+
+      attr_reader :environment
+
+      def initialize (next_app, routes, helpers, configures, options)
+
+        @next_app = next_app
+        @routes = routes || [] # the 'no route' case is rather useless...
+        @helpers = helpers || []
+
+        #@prefix = options[:prefix] || ''
+        #@rprefix = Regexp.new(@prefix)
+
+        @environment = options[:environment] || 'development'
+        @environment = @environment.to_s
+
+        #
+        # run the configure blocks
+
+        (configures || []).each do |envs, block|
+          instance_eval(&block) if envs.empty? or envs.include?(@environment)
+        end
+      end
+
+      def application
+        self
+      end
+
+      def call (env)
+
+        block = nil
+
+        begin
+          block = lookup_block(env)
+        rescue => e
+          #puts e
+          #puts e.backtrace
+          return [ 400, {}, e.to_s ]
+        end
+
+        if block
+          Context.service(self, block, @helpers, env)
+        elsif @next_app
+          @next_app.call(env)
+        else
+          [ 404, {}, [ "not found #{env['PATH_INFO']}" ] ]
+        end
+      end
+
+      protected
+
+        H_METHODS = [ 'GET', 'POST', 'PUT', 'DELETE', 'HEAD', 'OPTIONS' ]
+        R_METHOD = /_method=(put|delete|PUT|DELETE)/
+        R_MULTIPART = /^multipart\/form-data;/
+
+        def lookup_block (env)
+
+          request_method = get_request_method(env)
+
+          @routes.each do |verb, route, block|
+            next unless request_method == verb
+            next unless route.match?(env)
+            return block
+          end
+
+          nil
+        end
+
+        def get_request_method (env)
+
+          rm = env['X-HTTP-Method-Override'] || env['REQUEST_METHOD']
+          rm = rm.upcase
+
+          #puts env.inspect
+
+          if rm == 'POST'
+            md = R_METHOD.match(env['QUERY_STRING'])
+            rm = md[1].upcase if md
+
+            ct = env['CONTENT_TYPE']
+
+            if ct and R_MULTIPART.match(ct)
+              request = Rack::Request.new(env)
+              env['_rack_request'] = request # no need to rebuild later
+              hidden_method = request.POST['_method']
+              rm = hidden_method.upcase if hidden_method
+            end
+          end
+
+          raise "unknown HTTP method '#{rm}'" unless H_METHODS.include?(rm)
+
+          rm
+        end
+    end
+
+    #
+    # ERB views
+    #
+    module Erb
+
+      #
+      # a local [context] for ERB views
+      #
+      class Local
+
+        def initialize (context, locals)
+          @context = context
+          @locals = locals
+        end
+
+        def method_missing (m, *args)
+
+          l = @locals[m.to_sym]
+          return l if l != nil
+
+          @context.send(m, *args)
+        end
+
+        #def application; @context.application; end
+        #def request; @context.request; end
+        #def response; @context.response; end
+
+        def get_binding
+          binding
+        end
+      end
+
+      def erb (template, options = {})
+
+        content = File.open("views/#{template}.erb").read
+
+        l = options[:locals]
+        l = Local.new(self, l || {}) unless l.is_a?(Local)
+
+        ::ERB.new(content).result(l.get_binding)
+      end
+    end
+
+    #
+    # The context in which an HTTP request is handled
+    #
+    class Context
+
+      include Erb
+
+      def metaclass
+        class << self
+          self
+        end
+      end
+
+      attr_reader :application
+      attr_reader :request, :response
+
+      def initialize (app, env)
+
+        @application = app
+        @request = env.delete('_rack_request') || Rack::Request.new(env)
+        @response = Rack::Response.new
+
+        @params = @request.params.merge(@request.env['_ROUTE_PARAMS'])
+        @params = @params.inject({}) { |r, (k, v)| r[k.to_sym] = v; r }
+      end
+
+      def self.service (app, block, helpers, env)
+
+        r = self.new(app, env)
+
+        helpers.each { |h| r.instance_eval &h }
+
+        r.metaclass.instance_eval { define_method :call, &block }
+
+        begin
+
+          caught = catch :done do
+            r.response.body = r.call || []
+            nil
+          end
+
+          if caught
+            #puts caught.inspect
+            r.response.status = caught[0]
+            r.response.body = caught[1]
+          end
+
+        rescue Exception => e
+
+          r.response.status = 500
+          r.response.content_type = 'text/plain'
+          r.response.body = e.to_s + "\n" + e.backtrace.join("\n")
+        end
+
+        r.response.finish
+      end
+
+      def params
+        @params
+      end
+
+      def redirect (path, status=303, body=nil)
+        @response.status = status
+        @response.location = path
+        @response.body = body || "#{status} redirecting to #{path}"
+        throw :done
+      end
+    end
+
+    #
+    # Wrapping all the details about route.match?(path) here...
+    #
+    class Route
+
+      C_CHAR = '[^/?:,&#\.]'
+      R_PARAM = /:(#{C_CHAR}+)/ # capturing route params
+      R_FORMAT = /\.(#{C_CHAR}+)$/ # capturing the resource/file format
+
+      def initialize (route, options)
+
+        @param_keys = []
+
+        @regex = route.gsub(R_PARAM) do
+          @param_keys << $1.to_sym
+          "(#{C_CHAR}+)" # ready to capture param values
+        end
+
+        @regex = /^#{@regex}(?:\.(#{C_CHAR}+))?$/
+
+        # TODO : do something with the options :agent, :accept, ...
+      end
+
+      def match? (env)
+
+        m = env['PATH_INFO'].match(@regex)
+
+        return false unless m
+
+        values = m.to_a[1..-1]
+        params = @param_keys.zip(values).inject({}) { |r, (k, v)| r[k] = v; r }
+
+        env['_ROUTE_PARAMS'] = params
+
+        env['_FORMAT'] = values.last if values.length > @param_keys.length
+
+        true
+      end
+    end
+
+    #--
+    # the methods for registering the routes
+    #++
+    [ :post, :get, :put, :delete ].each do |v|
+      module_eval <<-EOS
+        def #{v} (rt, opts={}, &blk)
+          (@routes ||= []) << [ '#{v.to_s.upcase}', Route.new(rt, opts), blk ]
+        end
+      EOS
+    end
+
+    #
+    # for example :
+    #
+    #   helpers do
+    #     def hello
+    #       "hello #{params['who']}"
+    #     end
+    #   end
+    #
+    def helpers (&block)
+
+      (@helpers ||= []) << block
+    end
+
+    #
+    # Code in the 'configure' block will be run inside the application
+    # instance.
+    #
+    def configure (*envs, &block)
+
+      (@configures ||= []) << [ envs.collect { |e| e.to_s }, block ]
+    end
+
+    #
+    # Packages the routing info into a Rack application, suitable for
+    # insertion into a Rack app chain.
+    #
+    # Returns an instance of Rufus::Sixjo::App
+    #
+    def new_sixjo_rack_app (next_app, options={})
+
+      App.new(next_app, @routes, @helpers, @configures, options)
+    end
+  end
+end
+

data/test/ft_0_simple.rb

@@ -0,0 +1,52 @@
+
+#
+# Testing rufus-sixjo
+#
+# jmettraux at gmail.org
+#
+# Fri Aug  8 15:14:45 JST 2008
+#
+
+require 'test/unit'
+require 'testmixins'
+
+#
+# the "test" app
+#
+module Simple
+  extend Rufus::Sixjo
+
+  get '/toto' do
+    "toto"
+  end
+
+  get '/toto/:id' do
+    "toto with id #{params[:id]} .#{request.env['_FORMAT']}"
+  end
+end
+
+class SimpleTest < Test::Unit::TestCase
+  include SixjoTestMixin
+
+  def setup
+    @app = Simple.new_sixjo_rack_app(nil, :environment => 'test')
+  end
+
+  def test_0
+
+    assert_equal 404, get('/nada').status
+
+    assert_equal 200, get('/toto').status
+    assert_equal "toto", @response.body
+
+    assert_equal 200, get('/toto/3').status
+    assert_equal "toto with id 3 .", @response.body
+
+    assert_equal 200, get('/toto/3.json').status
+    assert_equal "toto with id 3 .json", @response.body
+
+    assert_equal 200, get('/toto/3.json?q=nada').status
+    assert_equal "toto with id 3 .json", @response.body
+  end
+end
+

data/test/ft_1_helpers.rb

@@ -0,0 +1,46 @@
+
+#
+# Testing rufus-sixjo
+#
+# jmettraux at gmail.org
+#
+# Sat Aug  9 00:03:47 JST 2008
+#
+
+require 'test/unit'
+require 'testmixins'
+
+#
+# the "test" app
+#
+module WithHelper
+  extend Rufus::Sixjo
+
+  get '/hello' do
+    "hello #{hello}"
+  end
+
+  helpers do
+    def hello
+      params[:target]
+    end
+  end
+end
+
+class HelpersTest < Test::Unit::TestCase
+  include SixjoTestMixin
+
+  def setup
+    @app = WithHelper.new_sixjo_rack_app(nil, :environment => 'test')
+  end
+
+  def test_0
+
+    assert_equal 200, get('/hello').status
+    assert_equal "hello ", @response.body
+
+    assert_equal 200, get('/hello?target=world').status
+    assert_equal "hello world", @response.body
+  end
+end
+

data/test/ft_2_redirect.rb

@@ -0,0 +1,37 @@
+
+#
+# Testing rufus-sixjo
+#
+# jmettraux at gmail.org
+#
+# Mon Aug 11 17:23:23 JST 2008
+#
+
+require 'test/unit'
+require 'testmixins'
+
+#
+# the "test" app
+#
+module RedirectApp
+  extend Rufus::Sixjo
+
+  get '/' do
+    redirect '/elsewhere'
+  end
+end
+
+class RedirectTest < Test::Unit::TestCase
+  include SixjoTestMixin
+
+  def setup
+    @app = RedirectApp.new_sixjo_rack_app(nil, :environment => 'test')
+  end
+
+  def test_0
+    assert_equal 303, get('/').status
+    assert_equal '/elsewhere', @response.location
+    assert_equal "303 redirecting to /elsewhere", @response.body
+  end
+end
+

data/test/ft_3_erb.rb

@@ -0,0 +1,71 @@
+
+#
+# Testing rufus-sixjo
+#
+# jmettraux at gmail.org
+#
+# Mon Aug 11 19:09:58 JST 2008
+#
+
+require 'test/unit'
+require 'fileutils'
+require 'testmixins'
+
+#
+# the "test" app
+#
+module ErbApp
+  extend Rufus::Sixjo
+
+  get '/' do
+    erb 'view0'
+  end
+
+  get '/good' do
+    erb 'view0', :locals => { :life => 'good' }
+  end
+
+  get '/good2' do
+    erb :view0, :whatever => true, :locals => { :life => 'good' }
+  end
+
+  get '/reckless' do
+    erb :view1
+  end
+end
+
+class ErbTest < Test::Unit::TestCase
+  include SixjoTestMixin
+
+  def setup
+
+    @app = ErbApp.new_sixjo_rack_app(nil, :environment => 'test')
+
+    FileUtils.mkdir('views') unless File.exist?('views')
+
+    fn = 'views/view0.erb'
+
+    FileUtils.rm(fn) if File.exist?(fn)
+    File.open(fn, 'w') { |f| f.write "this is view0, life is <%= life %>" }
+
+    fn = 'views/view1.erb'
+
+    FileUtils.rm(fn) if File.exist?(fn)
+    File.open(fn, 'w') { |f| f.write "<%= request.path_info %>" }
+  end
+
+  def test_0
+
+    assert_equal 500, get('/').status
+
+    assert_equal 200, get('/good').status
+    assert_equal 'this is view0, life is good', @response.body.strip
+
+    assert_equal 200, get('/good2').status
+    assert_equal 'this is view0, life is good', @response.body.strip
+
+    assert_equal 200, get('/reckless').status
+    assert_equal '/reckless', @response.body.strip
+  end
+end
+

data/test/ft_4_configure.rb

@@ -0,0 +1,61 @@
+
+#
+# Testing rufus-sixjo
+#
+# jmettraux at gmail.org
+#
+# Tue Aug 12 13:38:16 JST 2008
+#
+
+require 'test/unit'
+require 'testmixins'
+
+#
+# the "test" app
+#
+module ConfigureApp
+  extend Rufus::Sixjo
+
+  configure do
+    $apple = 'pomme'
+    @pear = 'poire'
+  end
+
+  configure :production, :development do
+    $peach = 'pe^che'
+  end
+
+  get '/' do
+    "apple is #{$apple}"
+  end
+
+  get '/pear' do
+    "pear is #{application.instance_variable_get(:@pear)}"
+  end
+
+  get '/peach' do
+    "peach is #{$peach}"
+  end
+end
+
+class ConfigureTest < Test::Unit::TestCase
+  include SixjoTestMixin
+
+  def setup
+
+    @app = ConfigureApp.new_sixjo_rack_app(nil, :environment => 'test')
+  end
+
+  def test_0
+
+    assert_equal 200, get('/').status
+    assert_equal 'apple is pomme', @response.body.strip
+
+    assert_equal 200, get('/pear').status
+    assert_equal 'pear is poire', @response.body.strip
+
+    assert_equal 200, get('/peach').status
+    assert_equal 'peach is', @response.body.strip
+  end
+end
+

data/test/ft_5_put.rb

@@ -0,0 +1,97 @@
+
+#
+# Testing rufus-sixjo
+#
+# jmettraux at gmail.org
+#
+# Tue Aug 12 23:36:22 JST 2008
+#
+
+require 'test/unit'
+require 'testmixins'
+
+#
+# the "test" app
+#
+module PutApp
+  extend Rufus::Sixjo
+
+  post '/' do
+    #puts request.inspect
+    #request.env['rack.input'].read
+    request.content
+  end
+
+  put '/car' do
+    "put : #{request.content || params[:brand]}"
+  end
+
+  delete '/car/:id' do
+  end
+end
+
+class PutTest < Test::Unit::TestCase
+  include SixjoTestMixin
+
+  def setup
+
+    @app = PutApp.new_sixjo_rack_app(nil, :environment => 'test')
+  end
+
+  def test_0
+
+    #puts post('/', { :input => 'toto' }).body
+    assert_equal 200, post('/', { :input => 'toto' }).status
+    assert_equal 'toto', @response.body
+
+    assert_equal 200, put('/car', { :input => 'datsun' }).status
+    assert_equal 'put : datsun', @response.body
+
+    assert_equal 200, post('/car?_method=put', { :input => 'nissan' }).status
+    assert_equal 'put : nissan', @response.body
+
+    assert_equal 404, post('/car', { :input => 'mercedes', :_method => 'put' }).status
+    #assert_equal 'put : mercedes', @response.body
+
+    assert_equal 200, delete('/car/fr154147', {}).status
+    assert_equal '', @response.body
+  end
+
+  def test_1
+
+    assert_equal(
+      200,
+      post(
+        '/car',
+        { :input => 'lada', 'X-HTTP-Method-Override' => 'put' }).status)
+    assert_equal 'put : lada', @response.body
+
+    assert_equal(
+      400,
+      post(
+        '/car',
+        { :input => 'lada', 'X-HTTP-Method-Override' => 'push' }).status)
+    assert_equal "unknown HTTP method 'PUSH'", @response.body
+  end
+
+  def test_2
+
+    data = {
+      "_method" => "put",
+      "brand" => "ford"
+    }
+    form_data = encode_multipart(data)
+
+    assert_equal(
+      200,
+      post(
+        '/car',
+        {
+          :input => form_data,
+          'CONTENT_LENGTH' => form_data.length.to_s,
+          'CONTENT_TYPE' => 'multipart/form-data; boundary=AaB03x'
+        }).status)
+    assert_equal 'put : ford', @response.body
+  end
+end
+

data/test/test.rb

@@ -0,0 +1,8 @@
+
+require 'ft_0_simple'
+require 'ft_1_helpers'
+require 'ft_2_redirect'
+require 'ft_3_erb'
+require 'ft_4_configure'
+require 'ft_5_put'
+

data/test/testmixins.rb

@@ -0,0 +1,40 @@
+
+#
+# Testing rufus-sixjo
+#
+# jmettraux at gmail.org
+#
+# Fri Aug  8 18:01:29 JST 2008
+#
+
+require 'rubygems'
+require 'rufus/sixjo'
+
+
+module SixjoTestMixin
+
+  [ :post, :get, :put, :delete ].each do |v|
+    module_eval <<-EOS
+      def #{v} (path, options={})
+        @response = \
+          Rack::MockRequest.new(@app).request('#{v}'.upcase, path, options)
+        @response
+      end
+    EOS
+  end
+
+  MFD_BOUNDARY = "AaB03x"
+
+  def encode_multipart (data = {})
+    ret = ""
+    data.each do |key, value|
+      next if value == nil or value.strip == ''
+      ret << "--#{MFD_BOUNDARY}\r\n"
+      ret << "Content-Disposition: form-data; name=\"#{key}\"\r\n\r\n"
+      ret << value
+      ret << "\r\n"
+    end
+    ret << "--#{MFD_BOUNDARY}--\r\n"
+  end
+end
+

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: rufus-sixjo
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- John Mettraux
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-15 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: john at gmail dot com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+files: 
+- lib/rufus
+- lib/rufus/sixjo.rb
+- test/ft_0_simple.rb
+- test/ft_1_helpers.rb
+- test/ft_2_redirect.rb
+- test/ft_3_erb.rb
+- test/ft_4_configure.rb
+- test/ft_5_put.rb
+- test/test.rb
+- test/testmixins.rb
+- README.txt
+has_rdoc: true
+homepage: http://rufus.rubyforge.org/rufus-sixjo
+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: 
+- rack
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: a rack application
+test_files: 
+- test/test.rb