egalite 0.0.1 → 0.0.2

data/lib/egalite/m17n.rb

@@ -0,0 +1,193 @@
+
+module Egalite
+  module M17N
+    
+    
+    module Filters
+      def before_filter
+        # check hostname first to determine which language to serve.
+        first = req.host.split(/\./).first
+        @lang = Translation.lang(first)
+        if not @lang and req.accept_language and Translation.allow_content_negotiation
+          # fallback to Accept-Language HTTP header for language to serve.
+          langs = req.accept_language.split(/,/)
+          @lang = langs.map { |s| Translation.lang(s.split(/;/).first) }.compact.first
+        end
+        @lang ||= Translation.lang(Translation.user_default_lang)
+        @lang ||= Translation.lang('ja')
+        
+        super
+      end
+      def filter_on_html_load(html,path)
+        html = @lang.translate_html(path, html) if @lang
+        super(html,path)
+      end
+      def after_filter_return_value(response)
+        if @lang
+          response = @lang.translate_msg(req.controller_class, req.action_method, response)
+        end
+        super(response)
+      end
+      def _(str, values = [])
+        if @lang
+          str = @lang.translate_string(req.controller_class, req.action_method, str, values)
+        else
+          str = str.dup
+          values.each_with_index { |s2,i| str.gsub!(/\{#{i}\}/, s2) }
+        end
+        str
+      end
+    end
+    class Controller < Egalite::Controller
+      include Filters
+    end
+    
+    
+    class Translation
+      class <<self
+        attr_accessor :langs, :user_default_lang, :allow_content_negotiation
+      end
+      def self.load(path)
+        @@langs = {}
+        
+        s = open(path) { |f| f.read }
+        
+        langs = nil
+        system_default = nil
+        
+        [:languages, :system_default, :english_name, :native_name, :aliases].each { |optname|
+          s.gsub!(/\{\{#{optname}\s*(.+?)\s*\}\}\s*\n+/i) {
+            values = $1.split(/\s*,\s*/)
+            case optname
+              when :languages
+                langs = values
+                values.each { |lang|
+                  @@langs[lang] = Translation.new(lang)
+                  @@langs[lang].data = {}
+                }
+              when :system_default
+                lang = values.shift
+                @@langs[lang] = Translation.new(lang)
+                @@langs[lang].data = nil
+                system_default = lang
+              when :aliases
+                lang = values.shift
+                @@langs[lang].send("#{optname}=", values)
+              else
+                lang = values.shift
+                @@langs[lang].send("#{optname}=", values.first)
+            end
+            ''
+          }
+        }
+        
+        s.split(/###+\s*\n+/).each { |part|
+          next if part =~ /\A\s*\Z/
+          lines = part.split(/\n+/)
+          key = lines.shift
+          (type, path) = key.split(/\s+/,2)
+          raise "Egalite::M17N::Translation.load: type should be 'html', 'msg' or 'img' but it was '#{type}'" unless %w[msg html img].include?(type)
+          lines.each { |line|
+            if type == 'img'
+              langs.each { |lang|
+                next unless @@langs[lang].data
+                img = line.sub(/\.(jpg|jpeg|gif|png)/i,"_#{lang}.\\1")
+                @@langs[lang].data[:img] ||= {}
+                @@langs[lang].data[:img][path] ||= {}
+                @@langs[lang].data[:img][path][line] = img
+              }
+            else
+              a = line.split(/\s*\t+\s*/)
+              k = nil
+              a.each_with_index { |s,i|
+                unless @@langs[langs[i]].data
+                  k = s
+                else
+                  @@langs[langs[i]].data[type.to_sym] ||= {}
+                  @@langs[langs[i]].data[type.to_sym][path] ||= {}
+                  @@langs[langs[i]].data[type.to_sym][path][k] = s
+                end
+              }
+            end
+          }
+        }
+        @@langs
+      end
+      def self.lang(s)
+        return nil unless s
+        a =   @@langs.find { |k,v| v.fullmatch?(s) }
+        a ||= @@langs.find { |k,v| v.partialmatch?(s) }
+        a ? a.last : nil
+      end
+      private
+      def method_path(c,a)
+        c.class.name.to_s + '#' + a.to_s
+      end
+      def t_string(list, s)
+        list[s] ? list[s] : s
+      end
+      def t_hash(list, h)
+        if h.is_a?(EgaliteResponse)
+          h.param = t_hash(list, h.param)
+          return h
+        end
+        return h unless h.is_a?(Hash)
+        h2 = {}
+        h.each { |k,v|
+          h2[k] = case v
+            when String: t_string(list,v)
+            when Array: v.map { |x| t_hash(list,x) }
+            when Hash: t_hash(list, v)
+            else v
+          end
+        }
+        h2
+      end
+
+    public
+
+      attr_accessor :english_name, :native_name, :aliases, :data
+      attr_reader :langcode
+      
+      def initialize(langcode)
+        @langcode = langcode
+        @aliases = []
+      end
+      def fullmatch?(lang)
+        lang = lang.to_s.downcase
+        @langcode == lang or @aliases.include?(lang)
+      end
+      def partialmatch?(lang)
+        fullmatch?(lang.to_s.split(/-/).first)
+      end
+      def translate_html(path, html)
+        return html unless @data
+        list = @data[:html][path]
+        return html unless list
+        s = html.dup
+        list.sort { |a,b| b[0].length <=> a[0].length }.each { |k,v| s.gsub!(k, v)}
+        if @data[:img] and @data[:img][path]
+          @data[:img][path].each { |k,v| s.gsub!(k, v) }
+        end
+        s
+      end
+      def translate_msg(controller, action, msg)
+        return msg unless @data
+        list = @data[:msg][method_path(controller,action)]
+        return msg unless list
+        t_hash(list, msg)
+      end
+      def translate_string(controller, action, string, placeholders = [])
+        if @data
+          list = @data[:msg][method_path(controller,action)]
+          if list
+            string = t_string(list, string)
+          end
+        end
+        string = string.dup
+        placeholders.each_with_index { |s2,i| string.gsub!(/\{#{i}\}/, s2) }
+        string
+      end
+    end
+  end
+end

data/lib/egalite/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/lib/egalite/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/lib/egalite/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
+