runo 0.1.0

data/lib/_i18n.rb

@@ -0,0 +1,141 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+module Runo::I18n
+
+  class Msgstr < String
+    def %(*args)
+      if args.first.is_a? ::Hash
+        self.gsub(/%\{(\w+)\}/) { args.first[$1.intern].to_s }
+      else
+        ::String.new(self.gsub(/%\{(\w+)\}/, '%s')) % args
+      end
+    end
+  end
+
+  module REX
+    COMMENT           = %r{^\s*\#}
+    COMMENT_FUZZY     = %r{^\s*\#\,\s*fuzzy}
+    MSGID             = %r{^\s*msgid\s*"(.*?[^\\])"}
+    MSGSTR            = %r{^\s*msgstr\s*"(.*?[^\\])"}
+    MSGSTR_PLURAL     = %r{^\s*msgstr\[(\d+)\]\s*"(.*?[^\\])"}
+    PLURAL_EXPRESSION = %r{
+      ^"Plural-Forms:.*plural=
+      ((?:
+        n(?=\s*(?:[\+\-\%]|==|!=|>|<|>=|<=))|
+        [\d\s\+\-\%\(\)\?\:]+|
+        ==|!=|>|<|>=|<=|&&|\|\|)+).*"
+    }xi
+  end
+
+  def self.lang
+    Thread.current[:lang] || []
+  end
+
+  def self.lang=(http_accept_language)
+    Thread.current[:msg] = nil
+    tokens = http_accept_language.to_s.split(/,/)
+    Thread.current[:lang] = tokens.sort_by {|t| # rfc3282
+      [
+        (t =~ /q=([\d\.]+)/) ? $1.to_f : 1.0,
+        -tokens.index(t)
+      ]
+    }.reverse.collect {|i|
+      if i =~ /([a-z]{1,8})(-[a-z]{1,8})?/i # rfc2616
+        $2 ? ($1.downcase + $2.upcase) : $1.downcase
+      end
+    }
+  end
+
+  def self.domain
+    @@domain ||= 'index'
+  end
+
+  def self.domain=(domain)
+    @@domain = domain
+  end
+
+  def self.po_dir
+    @@po_dir ||= ::File.expand_path('../locale', ::File.dirname(__FILE__))
+  end
+
+  def self.po_dir=(po_dir)
+    @@po_dir = po_dir
+  end
+
+  def self.bindtextdomain(domain, po_dir)
+    self.domain = domain
+    self.po_dir = po_dir
+  end
+
+  def self.msg
+    @@msg ||= {}
+    @@msg[self.lang] ||= self.find_msg
+    Thread.current[:msg] ||= @@msg[self.lang]
+  end
+
+  def self.find_msg(lang = self.lang)
+    lang.each {|range|
+      [
+        range,
+        range.sub(/-.*/, ''),
+      ].uniq.each {|r|
+        po_file = ::File.join(self.po_dir, r, "#{self.domain}.po")
+        return open(po_file) {|f| self.parse_msg f } if ::File.readable? po_file
+        return {} if r == 'en' # default
+      }
+    }
+    {}
+  end
+
+  def self.parse_msg(f)
+    msg   = {}
+    msgid = nil
+    f.each_line {|line|
+      case line
+        when REX::COMMENT_FUZZY
+          msgid = :skip_next
+        when REX::COMMENT
+          next
+        when REX::PLURAL_EXPRESSION
+          msg[:plural] = instance_eval "Proc.new {|n| #{$1} }"
+        when REX::MSGID
+          msgid = (msgid == :skip_next) ? :skip : $1
+        when REX::MSGSTR_PLURAL
+          if msgid.is_a? ::String
+            msg[msgid] = [] unless msg[msgid].is_a? ::Array
+            msg[msgid][$1.to_i] = $2
+          end
+        when REX::MSGSTR
+          msg[msgid] = $1 if msgid.is_a? ::String
+      end
+    }
+    msg
+  end
+
+  def self.merge_msg!(m)
+    m.delete :plural
+    Thread.current[:msg] = self.msg.merge m
+  end
+
+  module_function
+
+  def _(msgid)
+    Runo::I18n::Msgstr.new(Runo::I18n.msg[msgid].to_a.first || msgid)
+  end
+
+  def n_(msgid, msgid_plural, n)
+    msgstrs = Runo::I18n.msg[msgid].is_a?(::Array) ? Runo::I18n.msg[msgid] : [msgid, msgid_plural]
+    case v = Runo::I18n.msg[:plural] ? Runo::I18n.msg[:plural].call(n) : (n != 1)
+      when true
+        Runo::I18n::Msgstr.new msgstrs[1]
+      when false
+        Runo::I18n::Msgstr.new msgstrs[0]
+      else
+        Runo::I18n::Msgstr.new msgstrs[v.to_i]
+    end
+  end
+
+end

data/lib/_parser.rb

@@ -0,0 +1,243 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+module Runo::Parser
+
+  module_function
+
+  def parse_html(html, action = :index, xml = false)
+    item = {}
+
+    html = gsub_block(html, 'runo-\w+') {|open, inner, close|
+      id = open[/id="(.+?)"/i, 1] || 'main'
+      item[id] = parse_block(open, inner, close, action, xml)
+      "$(#{id})"
+    }
+    html = gsub_action_tmpl(html) {|id, act, open, inner, close|
+      id ||= 'main'
+      if item[id]
+        item[id][:tmpl] ||= {}
+        inner = gsub_action_tmpl(inner) {|i, a, *t|
+          item[id][:tmpl][a] = t.join
+          "$(.#{a})"
+        }
+        item[id][:tmpl][act] = open + inner + close
+        "$(#{id}.#{act})"
+      else
+        open + inner + close
+      end
+    }
+    item.each {|id, meta|
+      m = Proc.new {|a| html.include?("$(#{id}.#{a})") || meta[:tmpl][action].include?("$(.#{a})") }
+      supplement_sd(meta[:tmpl][action], meta[:workflow], m)
+      html.sub!("$(#{id})", "$(#{id}.message)\\&") unless (
+        meta[:workflow] == 'attachment' || m.call('message')
+      )
+    } unless xml
+
+    html = gsub_scalar(html) {|id, meta|
+      item[id] = meta
+      "$(#{id})"
+    }
+    html.gsub!(/\s*class=".*?"/,'') if xml
+
+    meta = scrape_meta html
+    meta.merge(
+      :label => meta[:label] || scrape_label(html),
+      :item  => item,
+      :tmpl  => {action => html}
+    )
+  end
+
+  def parse_xml(html, action = :index)
+    parse_html(html, action, xml = true)
+  end
+
+  def gsub_action_tmpl(html, &block)
+    rex_klass = /(?:\w+\-)?(?:action|view|navi|submit|done)\w*/
+    gsub_block(html, rex_klass) {|open, inner, close|
+      klass = open[/class=(?:"|"[^"]*?\s)(#{rex_klass})(?:"|\s)/, 1]
+      id, action = (klass =~ /-/) ? klass.split('-', 2) : [nil, klass]
+      block.call(id, action.intern, open, inner, close)
+    }
+  end
+
+  def gsub_block(html, class_name, &block)
+    rex_open_tag = /\s*<(\w+)[^>]+?class=(?:"|"[^"]*?\s)#{class_name}(?:"|\s).*?>\n?/i 
+    out = ''
+    s = StringScanner.new html
+    until s.eos?
+      if s.scan rex_open_tag
+        open_tag = s[0]
+        inner_html, close_tag = scan_inner_html(s, s[1])
+        close_tag << "\n" if s.scan /\n/
+        out << block.call(open_tag, inner_html, close_tag)
+      else
+        out << s.scan(/.+?(?=\t| |<|\z)/m)
+      end
+    end
+    out
+  end
+
+  def gsub_scalar(html, &block)
+    out = ''
+    s = StringScanner.new html
+    until s.eos?
+      if s.scan /\$\((\w+)(?:\s+|\s*=\s*)([\w\-]+)\s*/m
+        out << block.call(s[1], {:klass => s[2]}.merge(scan_tokens s))
+      else
+        out << s.scan(/.+?(?=\$|\w|<|\z)/m)
+      end
+    end
+    out
+  end
+
+  def scrape_meta(html)
+    meta = {}
+    html.gsub!(/(?:^\s+)?<meta[^>]*name="runo-([^"]+)[^>]*content="([^"]+).*?>\n?/i) {
+      meta[$1.intern] = $2.include?(',') ? $2.split(/\s*,\s*/) : $2
+      ''
+    }
+    meta
+  end
+
+  def scrape_label(html)
+    if html.sub!(/\A((?:[^<]*<!--)?[^<]*<[^>]*title=")([^"]+)/, '\\1')
+      label_plural = $2.to_s.split(/,/).collect {|s| s.strip }
+      label_plural *= 4 if label_plural.size == 1
+      label = label_plural.first
+      Runo::I18n.msg[label] ||= label_plural
+      label
+    end
+  end
+
+  def supplement_sd(tmpl, workflow, m)
+    tmpl << '$(.navi)' unless m.call 'navi'
+    unless workflow == 'attachment'
+      tmpl << '$(.submit)'        unless m.call 'submit'
+      tmpl << '$(.action_create)' unless m.call 'action_create'
+    end
+    tmpl
+  end
+
+  def supplement_ss(tmpl, action)
+    if action == :summary
+      tmpl.sub!(
+        /\$\(.*?\)/m,
+        '<a href="$(.uri_detail)">\&</a>'
+      ) unless tmpl.include? '$(.uri_detail)'
+    else
+      tmpl.sub!(
+        /\$\([^\.]*?\)/m,
+        '$(.a_update)\&</a>'
+      ) unless tmpl.include? '$(.action_update)'
+      tmpl.sub!(
+        /.*\$\(.*?\)/m,
+        '\&$(.hidden)'
+      ) unless tmpl.include? '$(.hidden)'
+    end
+    tmpl
+  end
+
+  def parse_block(open_tag, inner_html, close_tag, action = :index, xml = false)
+    open_tag.sub!(/id=".*?"/i, 'id="@(name)"')
+    workflow = open_tag[/class=(?:"|".*?\s)runo-(\w+)/, 1]
+
+    if inner_html =~ /<(\w+).+?class=(?:"|"[^"]*?\s)body(?:"|\s)/i
+      item_html = ''
+      sd_tmpl = gsub_block(inner_html, 'body') {|open, inner, close|
+        item_html = open + inner + close
+        '$()'
+      }
+    else
+      item_html = inner_html
+      sd_tmpl = '$()'
+    end
+
+    tmpl = {}
+    sd_tmpl = gsub_action_tmpl(sd_tmpl) {|id, act, open, inner, close|
+      inner = gsub_action_tmpl(inner) {|i, a, *t|
+        tmpl[a] = t.join
+        "$(.#{a})"
+      }
+      tmpl[act] = open + inner + close
+      "$(.#{act})"
+    }
+
+    tmpl[action] = "#{open_tag}#{sd_tmpl}#{close_tag}"
+    tmpl[action].gsub!(/\s*class=".*?"/,'') if xml
+
+    item_meta = Runo::Parser.parse_html(item_html, action, xml)
+    supplement_ss(item_meta[:tmpl][action], action) unless xml || workflow == 'attachment'
+
+    sd = {
+      :klass    => 'set-dynamic',
+      :workflow => workflow.downcase,
+      :tmpl     => tmpl,
+      :item     => {
+        'default' => item_meta,
+      },
+    }
+    (inner_html =~ /\A\s*<!--(.+?)-->/m) ? sd.merge(scan_tokens StringScanner.new($1)) : sd
+  end
+
+  def parse_token(prefix, token, meta = {})
+    case prefix
+      when ':'
+        meta[:default] = token
+      when ';'
+        meta[:defaults] ||= []
+        meta[:defaults] << token
+      when ','
+        meta[:options] ||= []
+        meta[:options] << token
+      else
+        case token
+          when /^(-?\d+)?\.\.(-?\d+)?$/
+            meta[:min] = $1.to_i if $1
+            meta[:max] = $2.to_i if $2
+          when /^(\d+)\*(\d+)$/
+            meta[:width]  = $1.to_i
+            meta[:height] = $2.to_i
+          else
+            meta[:tokens] ||= []
+            meta[:tokens] << token
+        end
+    end
+    meta
+  end
+
+  def scan_inner_html(s, name)
+    contents = ''
+    gen = 1
+    until s.eos? || (gen < 1)
+      contents << s.scan(/(.*?)(<#{name}|<\/#{name}>|\z)/m)
+      gen += 1 if s[2] == "<#{name}"
+      gen -= 1 if s[2] == "</#{name}>"
+    end
+    contents.gsub!(/\A\n+/, '')
+    contents.gsub!(/[\t ]*<\/#{name}>\z/, '')
+    [contents, $&]
+  end
+
+  def scan_tokens(s)
+    meta = {}
+    until s.eos? || s.scan(/\)/)
+      prefix = s[1] if s.scan /([:;,])?\s*/
+      if s.scan /(["'])(.*?)(\1|$)/
+        token = s[2]
+      elsif s.scan /[^\s\):;,]+/
+        token = s[0]
+      end
+      prefix ||= ',' if s.scan /(?=,)/ # 1st element of options
+      prefix ||= ';' if s.scan /(?=;)/ # 1st element of defaults
+
+      parse_token(prefix, token, meta)
+      s.scan /\s+/
+    end
+    meta
+  end
+
+end

data/lib/_path.rb

@@ -0,0 +1,86 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+module Runo::Path
+
+  module_function
+
+  def tid_of(path)
+    path[Runo::REX::TID]
+  end
+
+  def steps_of(path)
+    _dirname(path).gsub(Runo::REX::PATH_ID, '').split('/').select {|step_or_cond|
+      step_or_cond != '' &&
+      step_or_cond !~ Regexp.union(Runo::REX::COND, Runo::REX::COND_D, Runo::REX::TID)
+    }
+  end
+
+  def base_of(path)
+    base = Runo::Set::Static::Folder.root.item(steps_of path)
+    if base.is_a? Runo::Set::Static::Folder
+      base.item 'main'
+    else
+      base
+    end
+  end
+
+  def conds_of(path)
+    dir   = _dirname path.gsub(Runo::REX::PATH_ID, '')
+    conds = $& ? {:id => sprintf('%.8d_%.4d', $1, $2)} : {}
+
+    dir.split('/').inject(conds) {|conds, step_or_cond|
+      if step_or_cond =~ Runo::REX::COND
+        conds[$1.intern] = $2
+      elsif step_or_cond =~ Runo::REX::COND_D
+        conds[:d] = $&
+      end
+      conds
+    }
+  end
+
+  def action_of(path)
+    a = _basename(path).to_s[/^[a-z]+/]
+    a.intern if a && a != 'index'
+  end
+
+  def sub_action_of(path)
+    a = _basename(path).to_s[/_([a-z]+)/, 1]
+    a.intern if a
+  end
+
+  def path_of(conds)
+    conds = {} unless conds.is_a? ::Hash
+    (
+      (conds.keys - [:order, :p, :id]) |
+      ([:order, :p, :id] & conds.keys)
+    ).collect {|cid|
+      if cid == :id
+        ids = Array(conds[:id]).collect {|id|
+          (id =~ /_(#{Runo::REX::ID_SHORT})$/) ? $1 : (id if Runo::REX::ID)
+        }.compact
+        if (ids.size == 1) && (ids.first =~ Runo::REX::ID)
+          '%s/%d/' % [$1, $2.to_i]
+        elsif ids.size > 0
+          "id=#{ids.join ','}/"
+        end
+      elsif cid == :d
+        conds[:id] ? '' : "#{conds[:d]}/"
+      else
+        "#{cid}=#{Array(conds[cid]).join ','}/"
+      end
+    }.join.sub(%r{/p=1/$}, '/')
+  end
+
+  def _dirname(path) # returns '/foo/bar/' for '/foo/bar/'
+    path[%r{^.*/}] || ''
+  end
+
+  def _basename(path) # returns nil for '/foo/bar/'
+    path[%r{[^/]+$}]
+  end
+
+end
+