egalite 0.0.1

data/rack.rb

@@ -0,0 +1,81 @@
+# Copyright (C) 2007, 2008, 2009, 2010 Christian Neukirchen <purl.org/net/chneukirchen>
+#
+# Rack is freely distributable under the terms of an MIT-style license.
+# See COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+# The Rack main module, serving as a namespace for all core Rack
+# modules and classes.
+#
+# All modules meant for use in your application are <tt>autoload</tt>ed here,
+# so it should be enough just to <tt>require rack.rb</tt> in your code.
+
+module Rack
+  # The Rack protocol version number implemented.
+  VERSION = [1,1]
+
+  # Return the Rack protocol version as a dotted string.
+  def self.version
+    VERSION.join(".")
+  end
+
+  # Return the Rack release as a dotted string.
+  def self.release
+    "1.2"
+  end
+
+  autoload :Builder, "rack/builder"
+  autoload :Cascade, "rack/cascade"
+  autoload :Chunked, "rack/chunked"
+  autoload :CommonLogger, "rack/commonlogger"
+  autoload :ConditionalGet, "rack/conditionalget"
+  autoload :Config, "rack/config"
+  autoload :ContentLength, "rack/content_length"
+  autoload :ContentType, "rack/content_type"
+  autoload :ETag, "rack/etag"
+  autoload :File, "rack/file"
+  autoload :Deflater, "rack/deflater"
+  autoload :Directory, "rack/directory"
+  autoload :ForwardRequest, "rack/recursive"
+  autoload :Handler, "rack/handler"
+  autoload :Head, "rack/head"
+  autoload :Lint, "rack/lint"
+  autoload :Lock, "rack/lock"
+  autoload :Logger, "rack/logger"
+  autoload :MethodOverride, "rack/methodoverride"
+  autoload :Mime, "rack/mime"
+  autoload :NullLogger, "rack/nulllogger"
+  autoload :Recursive, "rack/recursive"
+  autoload :Reloader, "rack/reloader"
+  autoload :Runtime, "rack/runtime"
+  autoload :Sendfile, "rack/sendfile"
+  autoload :Server, "rack/server"
+  autoload :ShowExceptions, "rack/showexceptions"
+  autoload :ShowStatus, "rack/showstatus"
+  autoload :Static, "rack/static"
+  autoload :URLMap, "rack/urlmap"
+  autoload :Utils, "rack/utils"
+
+  autoload :MockRequest, "rack/mock"
+  autoload :MockResponse, "rack/mock"
+
+  autoload :Request, "rack/request"
+  autoload :Response, "rack/response"
+
+  module Auth
+    autoload :Basic, "rack/auth/basic"
+    autoload :AbstractRequest, "rack/auth/abstract/request"
+    autoload :AbstractHandler, "rack/auth/abstract/handler"
+    module Digest
+      autoload :MD5, "rack/auth/digest/md5"
+      autoload :Nonce, "rack/auth/digest/nonce"
+      autoload :Params, "rack/auth/digest/params"
+      autoload :Request, "rack/auth/digest/request"
+    end
+  end
+
+  module Session
+    autoload :Cookie, "rack/session/cookie"
+    autoload :Pool, "rack/session/pool"
+    autoload :Memcache, "rack/session/memcache"
+  end
+end

data/route.rb

@@ -0,0 +1,231 @@
+module Egalite
+class Route
+  def initialize(route_def)
+    @route = route_def
+    @controller = nil
+    @prefix = nil
+    @action = nil
+  end
+  def self.default_routes
+    routes = []
+    routes << Route.new([
+      [:controller],
+      [:controller],
+      [:action],
+      [:param_arg, :id],
+      [:params]
+    ])
+    routes << Route.new([
+      [:controller],
+      [:controller],
+      [:param_arg, :id],
+      [:params]
+    ])
+    routes << Route.new([
+      [:controller],
+      [:action],
+      [:param_arg, :id],
+      [:params]
+    ])
+    routes << Route.new([
+      [:controller],
+      [:param_arg, :id],
+      [:params]
+    ])
+    routes << Route.new([
+      [:action],
+      [:param_arg, :id],
+      [:params]
+    ])
+    routes << Route.new([
+      [:param_arg, :id],
+      [:params]
+    ])
+    routes
+  end
+
+
+  def match(path)
+    path = path.sub(/^\/+/,'')
+    pathary = path.to_s.split('/')
+    controller = nil
+    action = nil
+    path_params = []
+    params = {}
+    prefix = []
+    @route.each { |fragment|
+      command = fragment[0]
+      
+      case command
+        when :controller
+          if pathary.empty? and controller
+            controller += '/index'
+          elsif pathary.empty?
+            return nil
+          else
+            controller += '/' if controller
+            controller ||= ''
+            controller += pathary.shift
+          end
+        when :action
+          return nil if pathary.empty?
+          action = pathary.shift
+        when :param
+          next if pathary.empty?
+          val = pathary.shift
+          params[fragment[1]] = val
+          prefix << val unless controller
+        when :param_arg
+          next if pathary.empty?
+          val = pathary.shift
+          params[fragment[1]] = val if fragment[1]
+          path_params << val
+          prefix << val unless controller
+        when :param_fix
+          return nil if pathary[0] != fragment[2]
+          params[fragment[1]] = pathary.shift
+          prefix << val unless controller
+        when :controller_fix
+          return nil if pathary[0] != fragment[1]
+          controller += '/' if controller
+          controller ||= ''
+          controller += pathary.shift
+        when :params
+          path_params += pathary
+          pathary = []
+      end
+    }
+    return nil if pathary.size > 0
+    @controller = controller
+    @action = action
+    @path_params = path_params
+    @params = params
+    @prefix = prefix.join('/')
+    [controller, action, path_params, params]
+  end
+
+  def escape(s)
+    Rack::Utils.escape(s)
+  end
+
+  def get_path_and_params_from_params(params, current_host = nil, current_port = nil, current_scheme = nil)
+    route = @route || []
+    pathary = []
+    controller_exist = false
+    action_exist = false
+    contfrags = (@controller || "").to_s.split('/')
+    
+    scheme = nil
+    host = nil
+    port = nil
+    if params[:scheme]
+      scheme = params[:scheme].to_s
+      params.delete(:scheme)
+    end
+    if params[:host]
+      host = params[:host]
+      params.delete(:host)
+    end
+    if params[:port]
+      port = params[:port].to_i
+      params.delete(:port)
+    end
+    if (scheme or port or host)
+      raise "get_path_and_params_from_params: current_host is not supplied." unless host or current_host
+      scheme = scheme || current_scheme || 'http'
+      prefix = "#{scheme}://#{host || current_host}"
+      unless (current_scheme == 'http' and current_port == 80) or (current_scheme == 'https' and current_port == 443)
+        port ||= current_port
+      end
+      if port
+        unless (scheme == 'http' and port == 80) or (scheme == 'https' and port == 443)
+          prefix << ":#{port}"
+        end
+      end
+    end
+    
+    route.each { |fragment|
+      command = fragment[0]
+      
+      case command
+        when :controller
+          next if controller_exist
+          if params[:controller] == nil
+            pathary += contfrags
+          elsif params[:controller] =~ /^\//
+            pathary += params[:controller].to_s.split('/')
+          else
+            pathary += contfrags[0..-2]
+            pathary += params[:controller].to_s.split('/')
+          end
+          controller_exist = pathary.size
+          params.delete(:controller)
+        when :action
+          pathary << (params[:action] || (controller_exist ? nil : @action))
+          action_exist = true
+          params.delete(:action)
+        when :param
+          pathary << params[fragment[1]]
+          params.delete(fragment[1])
+        when :param_arg
+          pathary << params[fragment[1]]
+          params.delete(fragment[1])
+        when :param_fix
+          value = params[fragment[1]]
+          value = fragment[2] unless value
+          pathary << params[fragment[1]]
+          params.delete(fragment[1])
+        when :controller_fix
+          next
+        when :params
+          ary = (params[:params] || [])
+          if ary.respond_to?(:map)
+            pathary += ary.map { |s| s.to_s }
+          else
+            pathary += [ary.to_s]
+          end
+          params.delete(:params)
+      end
+    }
+    if not action_exist and params[:action]
+      if controller_exist
+        pathary.insert(controller_exist,params[:action])
+      else
+        pathary.unshift(params[:action])
+      end
+      params.delete(:action)
+    end
+    if not controller_exist and params[:controller]
+      pathary.unshift(params[:controller].to_s.split('/')).flatten!
+      params.delete(:controller)
+    end
+    pathary = pathary.compact.map { |frag| escape(frag) }
+    path = "/" + pathary.join('/').sub(/\/+$/,'').sub(/^\//,'')
+    
+    [path, params, pathary, prefix]
+  end
+
+  def url_for(params, host = nil, port = nil, scheme = nil)
+    (path, params, z, prefix) = get_path_and_params_from_params(params, host, port, scheme)
+    if params and params.size > 0
+      q = []
+      params.each { |k,v|
+        if v.is_a?(Hash)
+          v.each { |k2,v2|
+            next if v2 == nil
+            q << "#{escape(k)}[#{escape(k2)}]=#{escape(v2)}"
+          }
+        else
+          q << "#{escape(k)}=#{escape(v)}" if v
+        end
+      }
+      path += "?" + q.join('&') unless q.empty?
+    end
+    "#{prefix}#{path}"
+  end
+
+  def link_to(title, params, host = nil, port = nil, scheme = nil)
+    "<a href='#{url_for(params, host, port, scheme)}'>#{title}</a>"
+  end
+end
+end

data/sendmail.rb

@@ -0,0 +1,222 @@
+
+require 'template'
+require 'nkf'
+require 'time'
+
+# mailheaders
+# {
+#   :date => Time.new,
+#   :from => 'ARAI Shunichi <arai@example.com>', # encoded by Sendmail.address
+#   :reply_to => ,
+#   :to => 'tanaka@example.com', # encoded by Sendmail.address
+#   :cc => '', # encoded by Sendmail.address
+#   :bcc => '',
+#   :message_id => '',
+#   :in_reply_to => '',
+#   :references => '',
+#   :subject => '',
+# }
+
+module Sendmail
+  class QualifiedMailbox < String
+  end
+ class <<self
+  @@mock = false
+  def mock=(bool)
+    @@mock=bool
+  end
+  def folding(h, s) # folding white space. see RFC5322, section 2.3.3 and 3.2.2.
+    len = 78 - h.size - ": ".size
+    len2nd = 78 - " ".size
+    lines = []
+    line = ""
+    s.strip.split(/\s+/).each { |c| # each word (according to gmail's behavior)
+      if (line+c).size > len
+        len = len2nd
+        lines << line.strip
+        line = c + " "
+      else
+        line << c + " "
+      end
+    }
+    lines << line.strip if line.size > 0
+    lines.join("\n ")
+  end
+  def multibyte_folding(h, s, encoding = 'UTF-8') # RFC2047
+    bracketsize = "=?#{encoding}?B??=".size
+    len = 76 - h.size - ": ".size - bracketsize
+    len2nd = 76 - bracketsize
+    lines = []
+    line = ""
+    s = s.gsub(/\s+/, ' ').strip
+    s.split(//).each { |c| # each character (including multi-byte ones)
+      teststr = line+c
+      teststr = NKF.nkf('-Wj',teststr) if encoding =~ /iso-2022-jp/i
+      if [teststr].pack('m').chomp.size > len
+        len = len2nd
+        lines << line
+        line = c
+      else
+        line << c
+      end
+    }
+    lines << line if line.size > 0
+    lines = lines.map { |s| "=?#{encoding}?B?#{[s].pack('m').gsub(/\n/,'')}?=" }
+    lines.join("\n ")
+  end
+  def vchar(s)
+    s.gsub(/[\x00-\x1f\x7f]/,'')
+  end
+  def wsp(s)
+    s.gsub(/\s+/,' ')
+  end
+  def quote_string(s)
+    '"' + vchar(wsp(s)).gsub(/\\/,"\\\\\\").gsub(/\"/,'\\\"') + '"'
+  end
+  def multibyte?(s)
+    s.each_byte.any? { |c| c > 0x7f }
+  end
+  def encode_phrase(header, s)
+    if multibyte?(s)
+      multibyte_folding(header, s)
+    else
+      folding(header, quote_string(s))
+    end
+  end
+  def encode_unstructured(header, s)
+    if multibyte?(s)
+      multibyte_folding(header, s)
+    else
+      folding(header, vchar(wsp(s)))
+    end
+  end
+  def atext; '[0-9a-zA-Z!#$%&\'*+\-/=?\^_`{|}~]'; end
+  def atext_loose; '[0-9a-zA-Z!#$%&\'*+\-/=?\^_`{|}~.]'; end
+  
+  def check_domain(s)
+    s =~ /\A#{atext}+?(\.#{atext}+?)+\Z/
+  end
+  def check_local_loose(s)
+    s =~ /\A#{atext_loose}+\Z/
+  end
+  def parse_addrspec(addrspec)
+    # no support for CFWS, FWS, and domain-literal.
+    if addrspec[0,1] == '"' # quoted-string
+      addrspec =~ /\A(\".*?[^\\]\")\@(.+)\Z/
+      (local, domain) = [$1, $2]
+      return nil if local =~ /[\x00-\x1f\x7f]/
+      return nil unless check_domain(domain)
+      [local, domain]
+    else
+      (local, domain) = addrspec.split(/@/,2)
+      return nil unless check_local_loose(local)
+      return nil unless check_domain(domain)
+      [local, domain]
+    end
+  end
+  def address(addrspec, name = nil, header='Reply-to') 
+    # mailbox in RFC5322 section 3.4. not 'address' as in RFC.
+    raise 'invalid mail address.' unless parse_addrspec(addrspec)
+    if name and name.size > 0
+      QualifiedMailbox.new(folding(header, "#{encode_phrase(header, name)} <#{addrspec}>"))
+    else
+      addrspec
+    end
+  end
+  def mailboxlist(value, header = 'Reply-to')
+    case value
+      when QualifiedMailbox: value
+      when String: parse_addrspec(value) ? value : nil
+      when Hash: address(value[:address],value[:name],header)
+      when Array
+        folding(header, value.map { |v|
+          v.is_a?(Array) ? address(v[0],v[1]) : mailboxlist(v,header)
+        }.join(', '))
+      else
+        nil
+    end
+  end
+  def message(body, params)
+    headers = {}
+    
+    raise "From must be exist." unless params[:from]
+    raise "The number of sender must be zero or one." if params[:sender].is_a?(Array) and params[:sender].size > 1
+    raise "When the number of 'from' is more than one, sender must be exist" if params[:from].is_a?(Array) and params[:from].size > 1 and not params[:sender]
+    
+    %w[From To Sender Reply-To Cc].each { |s|
+      v = params[s.gsub(/-/,'_').downcase.to_sym]
+      headers[s] = mailboxlist(v,s) if v and v.size >= 1
+    }
+    
+    headers["Subject"] = encode_unstructured("Subject",params[:subject].to_s) if params[:subject]
+    headers["MIME-Version"] = "1.0"
+    date = params[:date] || Time.now
+    headers["Date"] = date.is_a?(Time) ? date.rfc822 : date
+    headers["Content-Type"] = "text/plain; charset=UTF-8"
+    
+    if multibyte?(body)
+      headers["Content-Transfer-Encoding"] = "base64"
+      body = [body].pack('m')
+    else
+      headers["Content-Transfer-Encoding"] = "7bit"
+    end
+    
+    text = [headers.map{|k,v| "#{k}: #{v}"}.join("\n"),body].join("\n\n")
+  end
+  private
+  def _extract_addrspec(value)
+    case value
+      when QualifiedMailbox
+        value =~ /<(#{atext_loose}+?@#{atext_loose}+?)>\Z/
+        $1
+      when String: parse_addrspec(value) ? value : nil
+      when Hash: parse_addrspec(value[:address]) ? value[:address] : nil
+      when Array
+        value.map { |v|
+          if v.is_a?(Array)
+            parse_addrspec(v[0]) ? v[0] : nil
+          else
+            _extract_addrspec(v)
+          end
+        }
+      else nil
+    end
+  end
+  public
+  def to_addresses(params)
+    addresses = [:to, :cc, :bcc].map { |s|
+      _extract_addrspec(params[s])
+    }
+    addresses.flatten.compact.uniq
+  end
+  def _send(text, envelope_from, to, host = 'localhost')
+    if @@mock
+      @@lastmail = [text, envelope_from, to, host]
+    else
+      Net::SMTP.start(host) { |smtp|
+        smtp.send_message(text, envelope_from, to)
+      }
+    end
+  end
+  def lastmail
+    @@lastmail if @@lastmail
+  end
+  def send(body, params, host = 'localhost')
+    _send(
+      message(body, params),
+      _extract_addrspec(params[:envelope_from] || params[:sender] || params[:from]),
+      to_addresses(params),
+      host
+    )
+  end
+  def send_with_template(filename, params, host = 'localhost')
+    File.open("mail/"+ filename ,"r") { |f|
+      text = f.read
+      tengine = Egalite::HTMLTemplate.new
+      tengine.default_escape = false
+      text = tengine.handleTemplate(text,params)
+      send(text, params, host)
+    }
+  end
+ end
+end

data/sequel_helper.rb

@@ -0,0 +1,20 @@
+
+class Sequel::Model
+  def update_with(hash, *selection)
+    data = {}
+    selection.flatten.each { |k| data[k] = hash[k] || hash[k.to_sym] }
+    update(data)
+  end
+  def update_without(hash, *selection)
+    hash = hash.clone
+    selection.flatten.each { |k| hash.delete(k.to_s) if hash.key?(k.to_s) }
+    selection.flatten.each { |k| hash.delete(k.to_sym) if hash.key?(k.to_sym) }
+    update(hash)
+  end
+  def to_hash
+    hash = {}
+    self.each { |k,v| hash[k] = v }
+    hash
+  end
+end
+

data/session.rb

@@ -0,0 +1,132 @@
+
+require 'openssl'
+
+module Egalite
+class Session
+  attr_accessor :expire_after, :hash, :cookie_name
+
+  def initialize(env, cookies, opts = {})
+    @env = env
+    @cookies = cookies
+    @cookie_name = opts[:cookie_name] || 'egalite_session'
+    @expire_after = opts[:expire_after] || (86400 * 30)
+    @secure = opts[:secure] || false
+    @path = opts[:path] || '/'
+    @hash = {}
+    @loaded = false
+  end
+  def create
+    raise NotImplementedError
+  end
+  def load
+    raise NotImplementedError
+  end
+  def save
+    raise NotImplementedError
+  end
+  def delete
+    raise NotImplementedError
+  end
+  def [](k)
+    @hash[k]
+  end
+  def []=(k,v)
+    @hash[k] = v
+  end
+end
+class SessionSequel < Session
+  def self.create_table(db, opts = {})
+    table = opts[:table_name] || :sessions
+    
+    db.create_table(table) {
+      primary_key :id, :integer, :auto_increment => true
+      column :mac, :varchar
+      column :updated_at, :timestamp
+    }
+  end
+
+  def initialize(env, cookies, opts = {}) 
+    @db = env.db
+    @table = opts[:tablename] || :sessions
+    
+    super(env, cookies, opts)
+  end
+  def cookie
+    {
+      :value => @sstr,
+      :expires => Time.now + @expire_after,
+      :path => @path,
+      :secure => @secure
+    }
+  end
+  def sstr
+    @sstr
+  end
+  def _load(_sstr)
+    return false unless _sstr and _sstr.size > 0
+    (sid,mac) = _sstr.split(/_/)
+
+    sid = sid.to_i
+    return false if sid <= 0
+    return false unless mac and mac.size > 0
+
+    rec = @db[@table][:id => sid]
+    return false unless rec and rec[:mac] == mac
+    
+    # timeout check
+    updated = rec[:updated_at]
+    return false if Time.now > (updated + @expire_after)
+    
+    @sstr = _sstr
+    @hash = rec
+    @sid = sid
+    @mac = mac
+    @loaded = true
+    @cookies[@cookie_name] = cookie
+    
+    @db[@table].filter(:id => sid).update(:updated_at => 'now')
+
+    true
+  end
+  def load_from_param(_sstr)
+    _load(_sstr)
+  end
+  def load
+    _sstr = @cookies[@cookie_name]
+    _sstr = _sstr[0] if _sstr.is_a?(Array)
+    _load(_sstr)
+  end
+  def create(hash = nil)
+    @sid = @db[@table].insert({})
+    @mac = OpenSSL::Random.random_bytes(8).unpack('h*')[0]
+    hash ||= {}
+    @db[@table].filter(:id => @sid).update(hash.merge(:mac => @mac,:updated_at => Time.now))
+    @hash = @db[@table][:id => @sid]
+
+    @sstr = "#@sid" + "_#@mac"
+    @cookies[@cookie_name] = cookie
+    @loaded = true
+
+    true
+  end
+  def delete
+    @cookies[@cookie_name] = {
+      :value => nil,
+      :expires => Time.now - 3600,
+      :path => @path,
+      :secure => @secure
+    }
+    @db[@table].filter(:id => @sid).delete
+    @loaded = false
+    true
+  end
+  def save
+    return false unless @loaded
+    [:updated_at, :mac, :id].each { |s| @hash.delete(s) }
+    @db[@table].filter(:id => @sid).update(
+      {:updated_at => Time.now}.merge(@hash)
+    )
+    true
+  end
+end
+end # module