bike 0.2.1 → 0.2.2

data/README.rdoc

@@ -5,7 +5,7 @@ You can make various apps such like blog, forum, contact form by putting single
 
 == Wiki
 
-http://wiki.github.com/afunai/bike/
+http://github.com/afunai/bike/wiki
 
 == Features
 
@@ -107,7 +107,7 @@ See the URL:
   http://localhost:9292/fab/
 
 You have just created your first app. Open a bottle of your favorite drink and make yourself comfortable.
-When you need more complicated tricks, HTMLs under skin/examples/ will be your help. Also, you should check out the wiki: http://wiki.github.com/afunai/bike/
+When you need more complicated tricks, HTMLs under skin/examples/ will be your help. Also, you should check out the wiki: http://github.com/afunai/bike/wiki
 
 == Note on Patches/Pull Requests
  

data/lib/_field.rb

@@ -111,6 +111,10 @@ class Bike::Field
     roles
   end
 
+  def workflow
+    @workflow ||= Bike::Workflow.instance self
+  end
+
   def permit?(action)
     return false if action == :create && @result == :load
     return true unless my[:sd]

data/lib/_response.rb

@@ -0,0 +1,89 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+module Bike::Response
+
+  module_function
+
+  def ok(result = {})
+    body = result[:body].to_s
+    return not_found(result) if body.empty?
+    [
+      200,
+      (
+        result[:headers] ||
+        {
+          'Content-Type'   => 'text/html',
+          'Content-Length' => body.size.to_s,
+        }
+      ),
+      [body],
+    ]
+  end
+
+  def no_content(result = {})
+    [
+      204,
+      (result[:headers] || {}),
+      []
+    ]
+  end
+
+  def see_other(result = {})
+    body = <<_html
+<a href="#{result[:location]}">see other</a>
+_html
+    [
+      303,
+      {
+        'Content-Type'   => 'text/html',
+        'Content-Length' => body.size.to_s,
+        'Location'       => result[:location],
+      },
+      [body]
+    ]
+  end
+
+  def forbidden(result = {})
+    body = result[:body] || 'Forbidden'
+    [
+      403,
+      {
+        'Content-Type'   => 'text/html',
+        'Content-Length' => body.size.to_s,
+      },
+      [body],
+    ]
+  end
+
+  def not_found(result = {})
+    body = result[:body] || 'Not Found'
+    [
+      404,
+      {
+        'Content-Type'   => 'text/html',
+        'Content-Length' => body.size.to_s,
+      },
+      [body]
+    ]
+  end
+
+  def unprocessable_entity(result = {})
+    body = result[:body].to_s
+    return not_found(result) if body.empty?
+    [
+      422,
+      (
+        result[:headers] ||
+        {
+          'Content-Type'   => 'text/html',
+          'Content-Length' => body.size.to_s,
+        }
+      ),
+      [body],
+    ]
+  end
+
+end

data/lib/_workflow/_workflow.rb

@@ -25,12 +25,34 @@ class Bike::Workflow
     :delete => 0b11111,
   }
 
-  def self.instance(sd)
-    klass = sd[:workflow].to_s.capitalize
+  module SD
+    def _get(arg)
+      if _hide? arg
+        # hidden
+      elsif arg[:action] == :create
+        item_instance '_001'
+        _get_by_tmpl({:action => :create, :conds => {:id => '_001'}}, my[:tmpl][:index])
+      else
+        super
+      end
+    end
+
+    def _get_by_self_reference(arg)
+      super unless _hide? arg
+    end
+
+    def _hide?(arg)
+      (arg[:p_action] && arg[:p_action] != :read) ||
+      (arg[:orig_action] == :read && arg[:action] == :submit)
+    end
+  end
+
+  def self.instance(f)
+    klass = (f[:sd] && f[:sd][:workflow]).to_s.capitalize
     if klass != ''
-      self.const_get(klass).new sd
+      self.const_get(klass).new f
     else
-      self.new sd
+      self.new f
     end
   end
 
@@ -40,16 +62,56 @@ class Bike::Workflow
     }.collect{|r| Bike::I18n._ r }
   end
 
-  attr_reader :sd
+  attr_reader :f
 
-  def initialize(sd)
-    @sd = sd
+  def initialize(f)
+    @f = f
   end
 
   def default_sub_items
     self.class.const_get :DEFAULT_SUB_ITEMS
   end
 
+  def default_meta
+    self.class.const_get :DEFAULT_META
+  end
+
+  def sd_module
+    self.class.const_get :SD
+  end
+
+  def call(method, params)
+    (method == 'post') ? post(params) : get(params)
+  rescue Bike::Error::Forbidden
+    if params[:action] && Bike.client == 'nobody'
+      params[:dest_action] ||= (method == 'post') ? :index : params[:action]
+      params[:action] = :login
+    end
+    Bike::Response.unprocessable_entity(:body => __g_default(params)) rescue Bike::Response.forbidden
+# TODO: rescue Error::System etc.
+  end
+
+  def get(params)
+    if @f.is_a? Bike::File
+      body = (params[:sub_action] == :small) ? @f.thumbnail : @f.body
+      Bike::Response.ok(
+        :headers => {
+          'Content-Type'   => @f.val['type'],
+          'Content-Length' => body.to_s.size.to_s,
+        },
+        :body    => body
+      )
+    else
+      m = "_g_#{params[:action]}"
+      respond_to?(m, true) ? __send__(m, params) : _g_default(params)
+    end
+  end
+
+  def post(params)
+    m = "_p_#{params[:action]}"
+    respond_to?(m, true) ? __send__(m, params) : _p_default(params)
+  end
+
   def permit?(roles, action)
     case action
       when :login, :done, :message
@@ -62,28 +124,139 @@ class Bike::Workflow
     end
   end
 
-  def _get(arg)
-    @sd.instance_eval {
-      if arg[:action] == :create
-        item_instance '_001'
-        _get_by_tmpl({:action => :create, :conds => {:id => '_001'}}, my[:tmpl][:index])
+  private
+
+  def _g_default(params)
+    Bike::Response.ok :body => __g_default(params)
+  end
+
+  def __g_default(params)
+    f = @f
+    params[:action] ||= f.default_action
+    until f.is_a? Bike::Set::Static::Folder
+      params = {
+        :action     => (f.default_action == :read) ? :read : nil,
+        :sub_action => f.send(:summary?, params) ? nil : (params[:sub_action] || :detail),
+        f[:id]      => params,
+      }
+      params[:conds] = {:id => f[:id]} if f[:parent].is_a? Bike::Set::Dynamic
+      f = f[:parent]
+    end if f.is_a? Bike::Set::Dynamic
+
+    f.get(params)
+  end
+
+  def _p_default(params)
+    res = __p_validate params
+    return res if res
+
+    __p_set_transaction
+    __p_update params
+
+    if params[:status]
+      if @f[:folder].commit :persistent
+        Bike.transaction[@f[:tid]] = __p_result_summary
+        id_step = __p_result_step(params) if @f[:parent] == @f[:folder] && __p_next_action != :done
+        Bike::Response.see_other(
+          :location => "#{Bike.uri}/#{@f[:tid]}#{@f[:path]}/#{id_step}#{__p_next_action}.html"
+        )
+      else
+        params = {:action => :update}
+        params[:conds] = {:id => @f.errors.keys}
+        Bike::Response.unprocessable_entity :body => __g_default(params)
       end
-    }
+    else
+      @f.commit :temp
+      id_step = __p_result_step(params)
+      Bike::Response.see_other(
+        :location => "#{Bike.uri}/#{@f[:tid]}/#{id_step}update.html"
+      )
+    end
   end
 
-  def _hide?(arg)
-    (arg[:p_action] && arg[:p_action] != :read) ||
-    (arg[:orig_action] == :read && arg[:action] == :submit)
+  def _p_preview(params)
+    res = __p_validate params
+    return res if res
+
+    __p_set_transaction
+    __p_update params
+
+    if @f.commit(:temp) || params[:sub_action] == :delete
+      id_step = __p_result_step(params)
+      action = "preview_#{params[:sub_action]}"
+      Bike::Response.see_other(
+        :location => "#{Bike.uri}/#{@f[:tid]}/#{id_step}#{action}.html"
+      )
+    else
+      params = {:action => :update}
+      params[:conds] = {:id => @f.errors.keys}
+      Bike::Response.unprocessable_entity(:body => __g_default(params))
+    end
   end
 
-  def before_commit
+  def _p_login(params)
+    user = Bike::Set::Static::Folder.root.item('_users', 'main', params['id'].to_s)
+    if user && params['pw'].to_s.crypt(user.val('password')) == user.val('password')
+      Bike.client = params['id']
+    else
+      Bike.client = nil
+      raise Bike::Error::Forbidden
+    end
+    path   = Bike::Path.path_of params[:conds]
+    action = (params[:dest_action] =~ /\A\w+\z/) ? params[:dest_action] : 'index'
+    Bike::Response.see_other(
+      :location => "#{Bike.uri}#{@f[:path]}/#{path}#{action}.html"
+    )
   end
 
-  def after_commit
+  def _p_logout(params)
+    return Bike::Response.forbidden(:body => 'invalid token') unless params[:token] == Bike.token
+
+    Bike.client = nil
+    path = Bike::Path.path_of params[:conds]
+    Bike::Response.see_other(
+      :location => "#{Bike.uri}#{@f[:path]}/#{path}index.html"
+    )
+  end
+  alias :_g_logout :_p_logout
+
+  def __p_validate(params)
+    if params[:token] != Bike.token
+      Bike::Response.forbidden(:body => 'invalid token')
+    elsif Bike.transaction[@f[:tid]] && !Bike.transaction[@f[:tid]].is_a?(Bike::Field)
+      Bike::Response.unprocessable_entity(:body => 'transaction expired')
+    end
+  end
+
+  def __p_set_transaction
+    Bike.transaction[@f[:tid]] ||= @f if @f[:tid] =~ Bike::REX::TID
+  end
+
+  def __p_update(params)
+    @f.update params
+  end
+
+  def __p_result_summary
+    (@f.result || {}).values.inject({}) {|summary, item|
+      item_result = item.result.is_a?(::Symbol) ? item.result : :update
+      summary[item_result] = summary[item_result].to_i + 1
+      summary
+    }
+  end
+
+  def __p_result_step(params)
+    if @f.result
+      id = @f.result.values.collect {|item| item[:id] }
+    else
+      id = params.keys.select {|id|
+        id.is_a?(::String) && (id[Bike::REX::ID] || id[Bike::REX::ID_NEW])
+      }
+    end
+    Bike::Path.path_of(:id => id)
   end
 
-  def next_action(base)
-    (!base.result || base.result.values.all? {|item| item.permit? :read }) ? :read_detail : :done
+  def __p_next_action
+    (!@f.result || @f.result.values.all? {|item| item.permit? :read }) ? :read_detail : :done
   end
 
 end

data/lib/_workflow/attachment.rb

@@ -17,14 +17,11 @@ class Bike::Workflow::Attachment < Bike::Workflow
     :delete => 0b00000,
   }
 
-  def permit?(roles, action)
-    (action == :login) ||
-    (@sd[:parent] && @sd[:parent].permit?(action))
-  end
-
-  def _get(arg)
-    @sd.instance_eval {
-      if arg[:action] == :create || arg[:action] == :update
+  module SD
+    def _get(arg)
+      if _hide? arg
+        # hidden
+      elsif arg[:action] == :create || arg[:action] == :update
         new_item = item_instance '_001'
 
         item_outs = _g_default(arg) {|item, item_arg|
@@ -39,12 +36,23 @@ _html
         }
         tmpl = my[:tmpl][:index].gsub('$()', item_outs)
         _get_by_tmpl({:p_action => arg[:p_action], :action => :update}, tmpl)
+      else
+        super
       end
-    }
+    end
+
+    def _get_by_self_reference(arg)
+      super unless _hide? arg
+    end
+
+    def _hide?(arg)
+      arg[:action] == :submit
+    end
   end
 
-  def _hide?(arg)
-    arg[:action] == :submit
+  def permit?(roles, action)
+    (action == :login) ||
+    (@f[:parent] && @f[:parent].permit?(action))
   end
 
 end

data/lib/_workflow/register.rb

@@ -24,15 +24,18 @@ class Bike::Workflow::Register < Bike::Workflow
     :delete => 0b11100,
   }
 
-  def before_commit
-    @sd.send(:pending_items).each {|id, item|
+  private
+
+  def __p_update(params)
+    super
+    @f.send(:pending_items).each {|id, item|
       if id =~ Bike::REX::ID_NEW
         item.item('_owner').instance_variable_set(:@val, item.item('_id').val)
       end
     }
   end
 
-  def next_action(base)
+  def __p_next_action
     (Bike.client == 'nobody') ? :done : super
   end
 

data/lib/bike.rb

@@ -114,158 +114,16 @@ class Bike
     else
       base = Bike::Path.base_of path
     end
-    return response_not_found unless base
+    return Bike::Response.not_found unless base
 
     base[:tid] = tid
     Bike.current[:base] = base
 
-    begin
-      if params[:action] == :logout && params[:token] == Bike.token
-        logout(base, params)
-      elsif method == 'get'
-        get(base, params)
-      elsif params[:action] == :login
-        login(base, params)
-      elsif params[:action] == :preview
-        preview(base, params)
-      elsif params[:token] != Bike.token
-        response_forbidden(:body => 'invalid token')
-      elsif Bike.transaction[tid] && !Bike.transaction[tid].is_a?(Bike::Field)
-        response_unprocessable_entity(:body => 'transaction expired')
-      else
-        begin
-          post(base, params)
-        rescue Bike::Error::Forbidden
-          response_forbidden
-        end
-      end
-    rescue Bike::Error::Forbidden
-      if params[:action] && Bike.client == 'nobody'
-        params[:dest_action] = (method == 'post') ? :index : params[:action]
-        params[:action] = :login
-      end
-      response_unprocessable_entity(:body => _get(base, params)) rescue response_forbidden
-# TODO: rescue Error::System etc.
-    end
+    base.workflow.call(method, params)
   end
 
   private
 
-  def login(base, params)
-    user = Bike::Set::Static::Folder.root.item('_users', 'main', params['id'].to_s)
-    if user && params['pw'].to_s.crypt(user.val('password')) == user.val('password')
-      Bike.client = params['id']
-    else
-      Bike.client = nil
-      raise Bike::Error::Forbidden
-    end
-    path   = Bike::Path.path_of params[:conds]
-    action = (params['dest_action'] =~ /\A\w+\z/) ? params['dest_action'] : 'index'
-    response_see_other(
-      :location => "#{Bike.uri}#{base[:path]}/#{path}#{action}.html"
-    )
-  end
-
-  def logout(base, params)
-    Bike.client = nil
-    path = Bike::Path.path_of params[:conds]
-    response_see_other(
-      :location => "#{Bike.uri}#{base[:path]}/#{path}index.html"
-    )
-  end
-
-  def get(base, params)
-    if base.is_a? Bike::File
-      body = (params[:sub_action] == :small) ? base.thumbnail : base.body
-      response_ok(
-        :headers => {
-          'Content-Type'   => base.val['type'],
-          'Content-Length' => body.to_s.size.to_s,
-        },
-        :body    => body
-      )
-    else
-      response_ok :body => _get(base, params)
-    end
-  end
-
-  def preview(base, params)
-    Bike.transaction[base[:tid]] ||= base if base[:tid] =~ Bike::REX::TID
-
-    base.update params
-    if base.commit(:temp) || params[:sub_action] == :delete
-      id_step = result_step(base, params)
-      action = "preview_#{params[:sub_action]}"
-      response_see_other(
-        :location => "#{Bike.uri}/#{base[:tid]}/#{id_step}#{action}.html"
-      )
-    else
-      params = {:action => :update}
-      params[:conds] = {:id => base.errors.keys}
-      return response_unprocessable_entity(:body => _get(base, params))
-    end
-  end
-
-  def post(base, params)
-    Bike.transaction[base[:tid]] ||= base if base[:tid] =~ Bike::REX::TID
-
-    base.update params
-    if params[:status]
-      if base[:folder].commit :persistent
-        Bike.transaction[base[:tid]] = result_summary base
-        action = base.workflow.next_action base
-        id_step = result_step(base, params) if base[:parent] == base[:folder] && action != :done
-        response_see_other(
-          :location => "#{Bike.uri}/#{base[:tid]}#{base[:path]}/#{id_step}#{action}.html"
-        )
-      else
-        params = {:action => :update}
-        params[:conds] = {:id => base.errors.keys}
-        response_unprocessable_entity :body => _get(base, params)
-      end
-    else
-      base.commit :temp
-      id_step = result_step(base, params)
-      response_see_other(
-        :location => "#{Bike.uri}/#{base[:tid]}/#{id_step}update.html"
-      )
-    end
-  end
-
-  def result_summary(base)
-    (base.result || {}).values.inject({}) {|summary, item|
-      item_result = item.result.is_a?(::Symbol) ? item.result : :update
-      summary[item_result] = summary[item_result].to_i + 1
-      summary
-    }
-  end
-
-  def result_step(base, params)
-    if base.result
-      id = base.result.values.collect {|item| item[:id] }
-    else
-      id = params.keys.select {|id|
-        id.is_a?(::String) && (id[Bike::REX::ID] || id[Bike::REX::ID_NEW])
-      }
-    end
-    Bike::Path.path_of(:id => id)
-  end
-
-  def _get(f, params)
-    params[:action] ||= f.default_action
-    until f.is_a? Bike::Set::Static::Folder
-      params = {
-        :action     => (f.default_action == :read) ? :read : nil,
-        :sub_action => f.send(:summary?, params) ? nil : (params[:sub_action] || :detail),
-        f[:id]      => params,
-      }
-      params[:conds] = {:id => f[:id]} if f[:parent].is_a? Bike::Set::Dynamic
-      f = f[:parent]
-    end if f.is_a? Bike::Set::Dynamic
-
-    f.get params
-  end
-
   def params_from_request(req)
     params = {
       :action     => Bike::Path.action_of(req.path_info),
@@ -306,6 +164,8 @@ class Bike
         hash[item_id][:self] = val
       elsif item_id == '_token'
         hash[:token] = val
+      elsif item_id == 'dest_action'
+        hash[:dest_action] = val
       else
         hash[item_id] = val
       end
@@ -314,83 +174,4 @@ class Bike
     }
   end
 
-  def response_ok(result = {})
-    body = result[:body].to_s
-    return response_not_found(result) if body.empty?
-    [
-      200,
-      (
-        result[:headers] ||
-        {
-          'Content-Type'   => 'text/html',
-          'Content-Length' => body.size.to_s,
-        }
-      ),
-      [body],
-    ]
-  end
-
-  def response_no_content(result = {})
-    [
-      204,
-      (result[:headers] || {}),
-      []
-    ]
-  end
-
-  def response_see_other(result = {})
-    body = <<_html
-<a href="#{result[:location]}">see other</a>
-_html
-    [
-      303,
-      {
-        'Content-Type'   => 'text/html',
-        'Content-Length' => body.size.to_s,
-        'Location'       => result[:location],
-      },
-      [body]
-    ]
-  end
-
-  def response_forbidden(result = {})
-    body = result[:body] || 'Forbidden'
-    [
-      403,
-      {
-        'Content-Type'   => 'text/html',
-        'Content-Length' => body.size.to_s,
-      },
-      [body],
-    ]
-  end
-
-  def response_not_found(result = {})
-    body = result[:body] || 'Not Found'
-    [
-      404,
-      {
-        'Content-Type'   => 'text/html',
-        'Content-Length' => body.size.to_s,
-      },
-      [body]
-    ]
-  end
-
-  def response_unprocessable_entity(result = {})
-    body = result[:body].to_s
-    return response_not_found(result) if body.empty?
-    [
-      422,
-      (
-        result[:headers] ||
-        {
-          'Content-Type'   => 'text/html',
-          'Content-Length' => body.size.to_s,
-        }
-      ),
-      [body],
-    ]
-  end
-
 end

data/lib/set/dynamic.rb

@@ -7,20 +7,21 @@ class Bike::Set::Dynamic < Bike::Field
 
   include Bike::Set
 
-  attr_reader :storage, :workflow
+  attr_reader :storage
 
   def initialize(meta = {})
     @meta        = meta
     @storage     = Bike::Storage.instance self
-    @workflow    = Bike::Workflow.instance self
-    @meta        = @workflow.class.const_get(:DEFAULT_META).merge @meta
+    @meta        = workflow.default_meta.merge @meta
     @item_object = {}
 
+    self.extend workflow.sd_module
+
     my[:item] ||= {
       'default' => {:item => {}}
     }
     my[:item].each {|type, item_meta|
-      item_meta[:item] = @workflow.default_sub_items.merge item_meta[:item]
+      item_meta[:item] = workflow.default_sub_items.merge item_meta[:item]
     }
 
     my[:p_size] = meta[:max] if meta[:max]
@@ -50,8 +51,6 @@ class Bike::Set::Dynamic < Bike::Field
   end
 
   def commit(type = :temp)
-    @workflow.before_commit
-
     items = pending_items
     items.each {|id, item|
       item.commit(:temp) || next
@@ -66,7 +65,6 @@ class Bike::Set::Dynamic < Bike::Field
     if valid?
       @result = (@action == :update) ? items : @action
       @action = nil if type == :persistent
-      @workflow.after_commit
       self
     end
   end
@@ -77,10 +75,6 @@ class Bike::Set::Dynamic < Bike::Field
     @storage.val
   end
 
-  def _get(arg)
-    (@workflow._get(arg) || super) unless @workflow._hide? arg
-  end
-
   def _get_by_tmpl(arg, tmpl = '')
     if arg[:action] == :read || self != Bike.base
       super
@@ -95,10 +89,6 @@ _html
     end
   end
 
-  def _get_by_self_reference(arg)
-    super unless @workflow._hide?(arg)
-  end
-
   def permit_get?(arg)
     permit?(arg[:action]) || collect_item(arg[:conds] || {}).all? {|item|
       item[:id][Bike::REX::ID_NEW] ?

data/t/skin/_users/index.html

@@ -2,7 +2,7 @@
   <head><title>@(label)</title></head>
   <body>
     <h1>@(label)</h1>
-    <dl id="main" class="app-blog">
+    <dl id="main" class="app-register">
       <dt>id: $(_id = meta-id 32 1..32)</dt>
       <dd>
         password: $(password = password 12)

data/t/test_bike.rb

@@ -87,6 +87,21 @@ class TC_Bike < Test::Unit::TestCase
       'Bike#rebuild_params should rebuild both the special symbols and regular items'
     )
 
+    hash = bike.instance_eval {
+      rebuild_params(
+        '_token'      => 'foo',
+        'dest_action' => 'bar'
+      )
+    }
+    assert_equal(
+      {
+        :token       => 'foo',
+        :dest_action => 'bar',
+      },
+      hash,
+      'Bike#rebuild_params should use symbols for special keys'
+    )
+
     hash = bike.instance_eval {
       rebuild_params(
         'moo.conds-p'                   => '9',
@@ -648,115 +663,6 @@ class TC_Bike < Test::Unit::TestCase
     )
   end
 
-  def test_login
-    Bike.client = nil
-    res = Bike.new.send(
-      :login,
-      Bike::Set::Static::Folder.root.item('foo', 'main'),
-      {'id' => 'test', 'pw' => 'test', :conds => {:id => '20100222_0123'}, 'dest_action' => 'update'}
-    )
-    assert_equal(
-      'test',
-      Bike.client,
-      'Bike#login should set Bike.client given a valid pair of user/password'
-    )
-    assert_match(
-      %r{/foo/20100222/123/update.html},
-      res[1]['Location'],
-      'Bike#login should return a proper location header'
-    )
-  end
-
-  def test_login_default_action
-    Bike.client = nil
-    res = Bike.new.send(
-      :login,
-      Bike::Set::Static::Folder.root.item('foo', 'main'),
-      {'id' => 'test', 'pw' => 'test', :conds => {:id => '20100222_0123'}}
-    )
-    assert_match(
-      %r{/foo/20100222/123/index.html},
-      res[1]['Location'],
-      "Bike#login should set 'index' as the default action of a location"
-    )
-  end
-
-  def test_login_with_wrong_account
-    Bike.client = nil
-
-    assert_raise(
-      Bike::Error::Forbidden,
-      'Bike#login should raise Error::Forbidden given a non-existent user'
-    ) {
-      Bike.new.send(
-        :login,
-        Bike::Set::Static::Folder.root.item('foo', 'main'),
-        {'id' => 'non-existent', 'pw' => 'test'}
-      )
-    }
-    assert_equal(
-      'nobody',
-      Bike.client,
-      'Bike#login should not set Bike.client with a non-existent user'
-    )
-
-    assert_raise(
-      Bike::Error::Forbidden,
-      'Bike#login should raise Error::Forbidden given a empty password'
-    ) {
-      Bike.new.send(
-        :login,
-        Bike::Set::Static::Folder.root.item('foo', 'main'),
-        {'id' => 'test', 'pw' => nil}
-      )
-    }
-    assert_equal(
-      'nobody',
-      Bike.client,
-      'Bike#login should not set Bike.client with an empty password'
-    )
-
-    assert_raise(
-      Bike::Error::Forbidden,
-      'Bike#login should raise Error::Forbidden given a wrong password'
-    ) {
-      res = Bike.new.send(
-        :login,
-        Bike::Set::Static::Folder.root.item('foo', 'main'),
-        {
-          'id' => 'test',
-          'pw' => 'wrong',
-          :conds => {:id => '20100222_0123'},
-          'dest_action' => 'update'
-        }
-      )
-    }
-    assert_equal(
-      'nobody',
-      Bike.client,
-      'Bike#login should not set Bike.client with a wrong password'
-    )
-  end
-
-  def test_logout
-    Bike.client = 'frank'
-    res = Bike.new.send(
-      :logout,
-      Bike::Set::Static::Folder.root.item('foo', 'main'),
-      {'id' => 'test', 'pw' => 'test', :conds => {:id => '20100222_0123'}}
-    )
-    assert_equal(
-      'nobody',
-      Bike.client,
-      'Bike#logout should clear Bike.client'
-    )
-    assert_match(
-      %r{/foo/20100222/123/index.html},
-      res[1]['Location'],
-      'Bike#logout should return a proper location header'
-    )
-  end
-
   def test_libdir
     assert_match(
       %r{^.*/lib$},

data/t/test_call.rb

@@ -772,7 +772,7 @@ _html
     res = Rack::MockRequest.new(@bike).post(
       "http://#{base_uri}/t_store/main/update.html",
       {
-        :input => ".action-preview_update=submit&_1-name=fz&_1-comment=howdy.&.status-public=create"
+        :input => ".action-preview_update=submit&_1-name=fz&_1-comment=howdy.&.status-public=create&_token=#{Bike.token}"
       }
     )
     tid = res.headers['Location'][Bike::REX::TID]
@@ -861,7 +861,7 @@ _html
     res = Rack::MockRequest.new(@bike).post(
       'http://example.com/t_store/main/update.html',
       {
-        :input => ".action-preview_update=submit&_1-name=verrrrrrrrrrrrrrrrrrrrrrrrrrrrrrylong&_1-comment=howdy.&.status-public=create"
+        :input => ".action-preview_update=submit&_1-name=verrrrrrrrrrrrrrrrrrrrrrrrrrrrrrylong&_1-comment=howdy.&.status-public=create&_token=#{Bike.token}"
       }
     )
     assert_equal(
@@ -1054,6 +1054,16 @@ _html
       res.status,
       'Bike#call with :login action should return status 422 upon failure'
     )
+    assert_match(
+      /^<html/,
+      res.body,
+      'Bike#call with :login action should return login form upon failure'
+    )
+    assert_match(
+      /name="dest_action" value="update"/,
+      res.body,
+      'Bike#call with :login action should keep the dest_action upon failure'
+    )
   end
 
   def test_post_logout
@@ -1278,4 +1288,26 @@ _html
     )
   end
 
+  def test_workflow_register
+    Bike.client = nil
+    Bike::Set::Static::Folder.root.item('_users', 'main').storage.delete('00000000_don')
+
+    res = Rack::MockRequest.new(@bike).post(
+      'http://example.com/_users/main/update.html',
+      {
+        :input => "_1-_id=don&_1-password=secret&.status-public=create&_token=#{Bike.token}"
+      }
+    )
+    assert_match(
+      /done\.html$/,
+      res.headers['Location'],
+      'Workflow::Register should have special __p_next_action().'
+    )
+    assert_equal(
+      'don',
+      Bike::Set::Static::Folder.root.item('_users', 'main', 'don')[:owner],
+      'Workflow::Register should set special item[:owner]'
+    )
+  end
+
 end

data/t/test_workflow.rb

@@ -38,8 +38,8 @@ class TC_Workflow < Test::Unit::TestCase
 
     assert_equal(
       sd,
-      Bike::Workflow.instance(sd).sd,
-      'Bike::Workflow.instance should set @sd'
+      Bike::Workflow.instance(sd).f,
+      'Bike::Workflow.instance should set @f'
     )
   end
 
@@ -364,4 +364,107 @@ class TC_Workflow < Test::Unit::TestCase
     )
   end
 
+  def test_login
+    Bike.client = nil
+    res = Bike::Set::Static::Folder.root.item('foo', 'main').workflow.send(
+      :_p_login,
+      {'id' => 'test', 'pw' => 'test', :conds => {:id => '20100222_0123'}, :dest_action => 'update'}
+    )
+    assert_equal(
+      'test',
+      Bike.client,
+      'Bike#login should set Bike.client given a valid pair of user/password'
+    )
+    assert_match(
+      %r{/foo/20100222/123/update.html},
+      res[1]['Location'],
+      'Bike#login should return a proper location header'
+    )
+  end
+
+  def test_login_default_action
+    Bike.client = nil
+    res = Bike::Set::Static::Folder.root.item('foo', 'main').workflow.send(
+      :_p_login,
+      {'id' => 'test', 'pw' => 'test', :conds => {:id => '20100222_0123'}}
+    )
+    assert_match(
+      %r{/foo/20100222/123/index.html},
+      res[1]['Location'],
+      "Bike#login should set 'index' as the default action of a location"
+    )
+  end
+
+  def test_login_with_wrong_account
+    Bike.client = nil
+
+    assert_raise(
+      Bike::Error::Forbidden,
+      'Bike#login should raise Error::Forbidden given a non-existent user'
+    ) {
+      res = Bike::Set::Static::Folder.root.item('foo', 'main').workflow.send(
+        :_p_login,
+        {'id' => 'non-existent', 'pw' => 'test'}
+      )
+    }
+    assert_equal(
+      'nobody',
+      Bike.client,
+      'Bike#login should not set Bike.client with a non-existent user'
+    )
+
+    assert_raise(
+      Bike::Error::Forbidden,
+      'Bike#login should raise Error::Forbidden given a empty password'
+    ) {
+      res = Bike::Set::Static::Folder.root.item('foo', 'main').workflow.send(
+        :_p_login,
+        {'id' => 'test', 'pw' => nil}
+      )
+    }
+    assert_equal(
+      'nobody',
+      Bike.client,
+      'Bike#login should not set Bike.client with an empty password'
+    )
+
+    assert_raise(
+      Bike::Error::Forbidden,
+      'Bike#login should raise Error::Forbidden given a wrong password'
+    ) {
+      res = Bike::Set::Static::Folder.root.item('foo', 'main').workflow.send(
+        :_p_login,
+        {
+          'id' => 'test',
+          'pw' => 'wrong',
+          :conds => {:id => '20100222_0123'},
+          :dest_action => 'update'
+        }
+      )
+    }
+    assert_equal(
+      'nobody',
+      Bike.client,
+      'Bike#login should not set Bike.client with a wrong password'
+    )
+  end
+
+  def test_logout
+    Bike.client = 'frank'
+    res = Bike::Set::Static::Folder.root.item('foo', 'main').workflow.send(
+      :_p_logout,
+      {'id' => 'test', 'pw' => 'test', :conds => {:id => '20100222_0123'}, :token => Bike.token}
+    )
+    assert_equal(
+      'nobody',
+      Bike.client,
+      'Bike#logout should clear Bike.client'
+    )
+    assert_match(
+      %r{/foo/20100222/123/index.html},
+      res[1]['Location'],
+      'Bike#logout should return a proper location header'
+    )
+  end
+
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 1
-  version: 0.2.1
+  - 2
+  version: 0.2.2
 platform: ruby
 authors: 
 - Akira FUNAI
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-20 00:00:00 +09:00
+date: 2010-10-12 00:00:00 +09:00
 default_executable: bike
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -146,6 +146,7 @@ files:
 - lib/_i18n.rb
 - lib/_parser.rb
 - lib/_path.rb
+- lib/_response.rb
 - lib/_storage/_storage.rb
 - lib/_storage/file.rb
 - lib/_storage/sequel.rb