bike 0.2.1

data/lib/_widget/view_ym.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009-2010 Akira FUNAI
+
+class Bike::Set::Dynamic
+
+  private
+
+  def _g_view_ym(arg)
+    return unless permit? :read
+
+    uris = _uri_ym arg
+    return unless uris && uris.size > 1
+
+    year_tmpl = month_tmpl = nil
+    div = my[:tmpl][:view_ym] || <<'_tmpl'
+<div class="view_ym">
+  <span class="y">
+    $(.y) |
+    <span class="m">$()</span>
+    <br/>
+  </span>
+</div>
+_tmpl
+    div = Bike::Parser.gsub_block(div, 'y') {|open, inner, close|
+      inner = Bike::Parser.gsub_block(inner, 'm') {|*t|
+        month_tmpl = t.join
+        '$(.months)'
+      }
+      year_tmpl = open + inner + close
+      '$(.years)'
+    }
+    years = uris.inject({}) {|y, u|
+      year = u[/(\d{4})\d\d\/$/, 1]
+      y[year] ||= []
+      y[year] << u
+      y
+    }
+    p = (my[:order] =~ /^-/) ? 'p=last/' : ''
+    div.gsub('$(.years)') {
+      years.keys.sort.collect {|year|
+        year_tmpl.gsub('$(.y)', year).gsub('$(.months)') {
+          years[year].collect {|uri|
+            d = uri[/(\d{6})\//, 1]
+            y = d[/^\d{4}/]
+            m = d[/\d\d$/]
+            month_tmpl.gsub(/\$\((?:\.(ym|m))?\)/) {
+              label = ($1 == 'ym') ? _label_ym(y, m) : _label_m(m)
+              (arg[:conds][:d] == d) ?
+                "<span class=\"current\">#{label}</span>" :
+                "<a href=\"#{my[:path]}/#{uri}#{p}\">#{label}</a>"
+            }
+          }.join
+        }
+      }.join
+    }
+  end
+
+  def _uri_ym(arg)
+    @storage.__send__(:_sibs_d, :d => '000000').collect {|ym|
+      Bike::Path.path_of :d => ym
+    }
+  end
+
+  def _label_ym(y, m)
+    _('%{year}/%{month}') % {
+      :year  => y,
+      :month => _label_m(m)
+    }
+  end
+
+  def _label_m(m)
+    _ Date::ABBR_MONTHNAMES[m.to_i]
+  end
+
+end

data/lib/_workflow/_workflow.rb

@@ -0,0 +1,89 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+class Bike::Workflow
+
+  include Bike::I18n
+
+  DEFAULT_META = {
+    :item_label => Bike::I18n.n_('item', 'items', 1),
+  }
+  DEFAULT_SUB_ITEMS = {}
+
+  ROLE_ADMIN = 0b10000
+  ROLE_GROUP = 0b01000
+  ROLE_OWNER = 0b00100
+  ROLE_USER  = 0b00010
+  ROLE_NONE  = 0b00001
+
+  PERM = {
+    :create => 0b11111,
+    :read   => 0b11111,
+    :update => 0b11111,
+    :delete => 0b11111,
+  }
+
+  def self.instance(sd)
+    klass = sd[:workflow].to_s.capitalize
+    if klass != ''
+      self.const_get(klass).new sd
+    else
+      self.new sd
+    end
+  end
+
+  def self.roles(roles)
+    %w(admin group owner user none).select {|r|
+      roles & const_get("ROLE_#{r.upcase}") > 0
+    }.collect{|r| Bike::I18n._ r }
+  end
+
+  attr_reader :sd
+
+  def initialize(sd)
+    @sd = sd
+  end
+
+  def default_sub_items
+    self.class.const_get :DEFAULT_SUB_ITEMS
+  end
+
+  def permit?(roles, action)
+    case action
+      when :login, :done, :message
+        true
+      when :preview
+        # TODO: permit?(roles, action, sub_action = nil)
+        (roles & self.class.const_get(:PERM)[:read].to_i) > 0
+      else
+        (roles & self.class.const_get(:PERM)[action].to_i) > 0
+    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])
+      end
+    }
+  end
+
+  def _hide?(arg)
+    (arg[:p_action] && arg[:p_action] != :read) ||
+    (arg[:orig_action] == :read && arg[:action] == :submit)
+  end
+
+  def before_commit
+  end
+
+  def after_commit
+  end
+
+  def next_action(base)
+    (!base.result || base.result.values.all? {|item| item.permit? :read }) ? :read_detail : :done
+  end
+
+end

data/lib/_workflow/attachment.rb

@@ -0,0 +1,50 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+class Bike::Workflow::Attachment < Bike::Workflow
+
+  DEFAULT_META = {
+    :p_size     => 0,
+    :item_label => Bike::I18n.n_('attachment', 'attachments', 1),
+  }
+
+  PERM = {
+    :create => 0b00000,
+    :read   => 0b00000,
+    :update => 0b00000,
+    :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
+        new_item = item_instance '_001'
+
+        item_outs = _g_default(arg) {|item, item_arg|
+          action = item[:id][Bike::REX::ID_NEW] ? :create : :delete
+          button_tmpl = my[:tmpl][:"submit_#{action}"] || <<_html.chomp
+<input type="submit" name="@(short_name).action-#{action}" value="#{_ action.to_s}" />
+_html
+          button = item.send(:_get_by_tmpl, {}, button_tmpl)
+          item_arg[:action] = :create if action == :create
+          item_tmpl = item[:tmpl][:index].sub(/[\w\W]*\$\(.*?\)/, "\\&#{button}")
+          item.send(:_get_by_tmpl, item_arg, item_tmpl)
+        }
+        tmpl = my[:tmpl][:index].gsub('$()', item_outs)
+        _get_by_tmpl({:p_action => arg[:p_action], :action => :update}, tmpl)
+      end
+    }
+  end
+
+  def _hide?(arg)
+    arg[:action] == :submit
+  end
+
+end

data/lib/_workflow/blog.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+class Bike::Workflow::Blog < Bike::Workflow
+
+  DEFAULT_META = {
+    :p_size     => 10,
+    :conds      => {:d => '999999', :p => 'last'},
+    :order      => '-id',
+    :item_label => Bike::I18n.n_('entry', 'entries', 1),
+  }
+
+  DEFAULT_SUB_ITEMS = {
+    '_owner'     => {:klass => 'meta-owner'},
+    '_group'     => {:klass => 'meta-group'},
+    '_timestamp' => {:klass => 'meta-timestamp'},
+  }
+
+  PERM = {
+    :create => 0b11000,
+    :read   => 0b11111,
+    :update => 0b10100,
+    :delete => 0b10100,
+  }
+
+end

data/lib/_workflow/contact.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+class Bike::Workflow::Contact < Bike::Workflow
+
+  DEFAULT_META = {
+    :p_size     => 10,
+    :conds      => {:p => 'last'},
+    :item_label => Bike::I18n.n_('item', 'items', 1),
+  }
+
+  DEFAULT_SUB_ITEMS = {}
+
+  PERM = {
+    :create => 0b00011,
+    :read   => 0b11000,
+    :update => 0b00000,
+    :delete => 0b11000,
+  }
+
+end

data/lib/_workflow/forum.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009-2010 Akira FUNAI
+
+class Bike::Workflow::Forum < Bike::Workflow
+
+  DEFAULT_META = {
+    :conds      => {:p => 'last'},
+    :p_size     => 10,
+    :item_label => Bike::I18n.n_('post', 'posts', 1),
+  }
+
+  DEFAULT_SUB_ITEMS = {
+    '_owner'     => {:klass => 'meta-owner'},
+    '_timestamp' => {:klass => 'meta-timestamp'},
+  }
+
+  PERM = {
+    :create => 0b11110,
+    :read   => 0b11111,
+    :update => 0b11000,
+    :delete => 0b11000,
+  }
+
+end

data/lib/_workflow/register.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009-2010 Akira FUNAI
+
+class Bike::Workflow::Register < Bike::Workflow
+
+  DEFAULT_META = {
+    :p_size     => 0,
+    :conds      => {:p => '1'},
+    :order      => 'id',
+    :item_label => Bike::I18n.n_('item', 'items', 1),
+  }
+
+  DEFAULT_SUB_ITEMS = {
+    '_owner'     => {:klass => 'meta-owner'},
+    '_timestamp' => {:klass => 'meta-timestamp'},
+  }
+
+  PERM = {
+    :create => 0b11001,
+    :read   => 0b11100,
+    :update => 0b11100,
+    :delete => 0b11100,
+  }
+
+  def before_commit
+    @sd.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)
+    (Bike.client == 'nobody') ? :done : super
+  end
+
+end

data/lib/bike.rb

@@ -0,0 +1,396 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+class Bike
+
+  lib_dir = ::File.dirname __FILE__
+
+  require "#{lib_dir}/_i18n.rb"
+  I18n.bindtextdomain('index', ::File.expand_path('../locale', lib_dir))
+
+  Dir["#{lib_dir}/_*.rb"].sort.each {|file| require file }
+  Dir["#{lib_dir}/[a-z]*/*.rb"].sort.each {|file| require file }
+  Dir["#{lib_dir}/_*/*.rb"].sort.each {|file| require file }
+
+  module REX
+    ID_SHORT   = /[a-z][a-z0-9]*/
+    ID         = /^(\d{8})_(\d{4,}|#{ID_SHORT})/
+    ID_NEW     = /^_\d/
+    COND       = /^(.+?)=(.+)$/
+    COND_D     = /^(19\d\d|2\d\d\d|9999)\d{0,4}$/
+    PATH_ID    = /\/((?:19|2\d)\d{6})\/(\d+)/
+    TID        = /\d{10}\.\d+/
+    DIR_STATIC = /css|js|img|imgs|image|images/
+  end
+
+  def self.config(config)
+    @config = config
+  end
+
+  def self.[](name)
+    @config ||= {}
+    @config[name]
+  end
+
+  def self.current
+    Thread.current
+  end
+
+  def self.session
+    self.current[:session] || ($fake_session ||= {})
+  end
+
+  def self.transaction
+    self.session[:transaction] ||= {}
+  end
+
+  def self.client
+    self.session[:client] ||= 'nobody'
+  end
+
+  def self.client=(id)
+    self.session[:client] = id
+  end
+
+  def self.token
+    self.session[:token] ||= rand(36 ** 32).to_s(36)
+  end
+
+  def self.base
+    self.current[:base]
+  end
+
+  def self.uri
+    self.current[:uri]
+  end
+
+  def self.libdir
+    ::File.dirname __FILE__
+  end
+
+  def self.static(env)
+    @static ||= Rack::Directory.new Bike['skin_dir']
+    response = @static.call env
+
+    if response.first == 404
+      until ::File.readable? ::File.join(
+        Bike['skin_dir'],
+        env['PATH_INFO'].sub(%r{(/#{Bike::REX::DIR_STATIC}/).*}, '\\1')
+      )
+        env['PATH_INFO'].sub!(%r{/[^/]+(?=/#{Bike::REX::DIR_STATIC}/)}, '') || break
+      end
+      @static.call env
+    else
+      response
+    end
+  end
+
+  def call(env)
+    uri    = "#{env['rack.url_scheme']}://#{env['HTTP_HOST']}#{env['SCRIPT_NAME']}"
+    req    = Rack::Request.new env
+    method = req.request_method.downcase
+    params = params_from_request req
+    path   = req.path_info
+    tid    = Bike::Path.tid_of path
+
+    static_path = ::File.expand_path path
+    return Bike.static(env) if (
+      static_path =~ %r{/#{Bike::REX::DIR_STATIC}/} &&
+      static_path !~ %r{/#{Bike::REX::TID}/} &&
+      static_path !~ %r{/#{Bike::REX::ID.to_s.sub('^','')}/}
+    )
+
+    Bike::I18n.lang = env['HTTP_ACCEPT_LANGUAGE']
+
+    Bike.current[:env]     = env
+    Bike.current[:uri]     = uri
+    Bike.current[:req]     = req
+    Bike.current[:session] = env['rack.session']
+
+    if Bike.transaction[tid].is_a? Bike::Field
+      base = Bike.transaction[tid].item Bike::Path.steps_of(path.sub(/\A.*#{Bike::REX::TID}/, ''))
+    else
+      base = Bike::Path.base_of path
+    end
+    return 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
+  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),
+      :sub_action => Bike::Path.sub_action_of(req.path_info),
+    }
+    params.merge! rebuild_params(req.params)
+
+    params[:conds] ||= {}
+    params[:conds].merge! Bike::Path.conds_of(req.path_info)
+
+    params
+  end
+
+  def rebuild_params(src)
+    src.keys.sort.reverse.inject({}) {|params, key|
+      name, special = key.split('.', 2)
+      steps = name.split '-'
+
+      if special
+        special_id, special_val = special.split('-', 2)
+      else
+        item_id = steps.pop
+      end
+
+      hash = steps.inject(params) {|v, k| v[k] ||= {} }
+      val  = src[key]
+
+      if special_id == 'action'
+        action, sub_action = (special_val || val).split('_', 2)
+        hash[:action] = action.intern
+        hash[:sub_action] = sub_action.intern if sub_action
+      elsif special_id == 'status'
+        hash[:status] = (special_val || val).intern
+      elsif special_id == 'conds'
+        hash[:conds] ||= {}
+        hash[:conds][special_val.intern] = val
+      elsif hash[item_id].is_a? ::Hash
+        hash[item_id][:self] = val
+      elsif item_id == '_token'
+        hash[:token] = val
+      else
+        hash[item_id] = val
+      end
+
+      params
+    }
+  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