runo 0.2.1 → 0.2.2

data/lib/_error.rb

@@ -1,14 +0,0 @@
-# encoding: UTF-8
-
-# Author::    Akira FUNAI
-# Copyright:: Copyright (c) 2009 Akira FUNAI
-
-module Runo::Error
-
-  class Forbidden < StandardError
-  end
-
-  class NotFound < StandardError
-  end
-
-end

data/lib/_field.rb

@@ -1,260 +0,0 @@
-# encoding: UTF-8
-
-# Author::    Akira FUNAI
-# Copyright:: Copyright (c) 2009-2010 Akira FUNAI
-
-require 'rubygems'
-require 'rack/utils'
-
-$KCODE = 'UTF8' if RUBY_VERSION < '1.9.0'
-
-class Runo::Field
-
-  include Runo::I18n
-
-  DEFAULT_META = {}
-
-  def self.instance(meta = {})
-    k = meta[:klass].to_s.split(/-/).inject(Runo) {|c, name|
-      name = name.capitalize
-      c.const_get(name)
-    }
-    k.new(meta) if k < self
-  end
-
-  def self.h(val)
-    Rack::Utils.escape_html val.to_s
-  end
-
-  attr_reader :action, :result
-
-  def initialize(meta = {})
-    @meta = self.class.const_get(:DEFAULT_META).merge meta
-    @val  = val_cast(nil)
-  end
-
-  def inspect
-    caller.grep(/`inspect'/).empty? ? super : "<#{self.class} name=\"#{my[:name]}\">"
-  end
-
-  def [](id, *arg)
-    respond_to?("meta_#{id}") ? __send__("meta_#{id}", *arg) : @meta[id]
-  end
-
-  def []=(id, v)
-    @meta[id] = v
-  end
-
-  def val
-    @val
-  end
-
-  def item(*item_steps)
-    item_steps = item_steps.first if item_steps.first.is_a? ::Array
-    item_steps.empty? ? self : nil # scalar has no item
-  end
-
-  def find_ancestor(&block)
-    f = self
-    block.call(f) ? (return f) : (f = f[:parent]) until f.nil?
-  end
-
-  def meta_name
-    my[:parent] && !my[:parent].is_a?(Runo::Set::Static::Folder) ?
-      "#{my[:parent][:name]}-#{my[:id]}" : my[:id]
-  end
-
-  def meta_full_name
-    my[:parent] ? "#{my[:parent][:full_name]}-#{my[:id]}" : my[:id]
-  end
-
-  def meta_short_name
-    return '' if Runo.base && my[:full_name] == Runo.base[:full_name]
-    my[:parent] && Runo.base && my[:parent][:full_name] != Runo.base[:full_name] ?
-      "#{my[:parent][:short_name]}-#{my[:id]}" : my[:id]
-  end
-
-  def meta_folder
-    find_ancestor {|f| f.is_a? Runo::Set::Static::Folder }
-  end
-
-  def meta_sd
-    find_ancestor {|f| f.is_a? Runo::Set::Dynamic }
-  end
-
-  def meta_client
-    Runo.client
-  end
-
-  def meta_owner
-    @meta[:owner] || (my[:parent] ? my[:parent][:owner] : 'root')
-  end
-
-  def meta_owners
-    (my[:parent] ? my[:parent][:owners] : ['root']) | Array(@meta[:owner])
-  end
-
-  def meta_admins
-    (my[:parent] ? my[:parent][:admins] : ['root']) | Array(@meta[:admin])
-  end
-
-  def meta_group
-    @meta[:group] || (my[:parent] ? my[:parent][:group] : [])
-  end
-
-  def meta_roles
-    roles  = 0
-    roles |= Runo::Workflow::ROLE_ADMIN if my[:admins].include? my[:client]
-    roles |= Runo::Workflow::ROLE_GROUP if my[:group].include? my[:client]
-    roles |= Runo::Workflow::ROLE_OWNER if my[:owner] == my[:client]
-    roles |= (Runo.client == 'nobody') ? Runo::Workflow::ROLE_NONE : Runo::Workflow::ROLE_USER
-    roles
-  end
-
-  def permit?(action)
-    return false if action == :create && @result == :load
-    return true unless my[:sd]
-    return true if my[:sd].workflow.permit?(my[:roles], action)
-    return true if find_ancestor {|f| f[:id] =~ Runo::REX::ID_NEW } # descendant of a new item
-  end
-
-  def default_action
-    return :read unless my[:sd]
-    actions = my[:sd].workflow.class.const_get(:PERM).keys - [:read, :create, :update]
-    ([:read, :create, :update] + actions).find {|action| permit? action }
-  end
-
-  def get(arg = {})
-    if permit_get? arg
-      _get(arg)
-    else
-      if arg[:action]
-        raise Runo::Error::Forbidden
-      else
-        arg[:action] = default_action
-      end
-      arg[:action] ? _get(arg) : 'xxx'
-    end
-  end
-
-  def load_default
-    post :load_default
-  end
-
-  def load(v = nil)
-    post :load, v
-  end
-
-  def create(v = nil)
-    post :create, v
-  end
-
-  def update(v = nil)
-    post :update, v
-  end
-
-  def delete
-    post :delete
-  end
-
-  def post(action, v = nil)
-    raise Runo::Error::Forbidden unless permit_post?(action, v)
-
-    if _post action, val_cast(v)
-      @result = (action == :load || action == :load_default) ? action : nil
-      @action = (action == :load || action == :load_default) ? nil : action
-    else
-      @result = nil
-    end
-    self
-  end
-
-  def commit(type = :temp)
-    if valid?
-      @result = @action
-      @action = nil if type == :persistent
-      self
-    end
-  end
-
-  def pending?
-    @action ? true : false
-  end
-
-  def valid?
-    errors.empty?
-  end
-
-  def empty?
-    val.respond_to?(:empty?) ? val.empty? : (val.to_s == '')
-  end
-
-  def errors
-    []
-  end
-
-  private
-
-  def my
-    self
-  end
-
-  def _get(arg)
-    _get_by_method arg
-  end
-
-  def _get_by_method(arg)
-    m = "_g_#{arg[:action]}"
-    respond_to?(m, true) ? __send__(m, arg) : _g_default(arg)
-  end
-  alias :_get_by_self_reference :_get_by_method
-
-  def _g_empty(arg)
-  end
-  alias :_g_login   :_g_empty
-  alias :_g_done    :_g_empty
-  alias :_g_message :_g_empty
-
-  def _g_default(arg)
-    Runo::Field.h val
-  end
-
-  def _g_errors(arg)
-    <<_html unless _g_valid? arg
-<span class="error_message">#{errors.join "<br/>\n"}</span>
-_html
-  end
-
-  def _g_class(arg)
-    c = self.class.to_s.sub('Runo::', '').gsub('::', '-').downcase
-    _g_valid?(arg) ? c : "#{c} error"
-  end
-
-  def _g_valid?(arg)
-    valid? || (arg[:action] == :create && !item.pending?)
-  end
-
-  def _post(action, v)
-    case action
-      when :load_default
-        @val = val_cast(my[:defaults] || my[:default])
-      when :load, :create, :update
-        @val = v if @val != v
-      when :delete
-        true
-    end
-  end
-
-  def permit_get?(arg)
-    permit? arg[:action]
-  end
-
-  def permit_post?(action, v)
-    action == :load || action == :load_default || permit?(action)
-  end
-
-  def val_cast(v)
-    v
-  end
-
-end

data/lib/_i18n.rb

@@ -1,144 +0,0 @@
-# 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
-        args = args.first if args.first.is_a? ::Array
-        ::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 ::File.open(po_file, ((RUBY_VERSION < '1.9') ? 'r' : 'r:utf-8')) {|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(Array(Runo::I18n.msg[msgid]).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

@@ -1,256 +0,0 @@
-# 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, '(?:app|runo)-\w+') {|open, inner, close| # "runo" is obsolete at 0.1.1
-      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?
-      out << skip_comment(s)
-      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).to_s
-      end
-    end
-    out
-  end
-
-  def gsub_scalar(html, &block)
-    out = ''
-    s = StringScanner.new html
-    until s.eos?
-      out << skip_comment(s)
-      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(/.+?(?=\$|<!|\z)/m).to_s
-      end
-    end
-    out
-  end
-
-  def skip_comment(s)
-    if s.scan /\s*<(!--|!\[CDATA\[)\n*/
-      s[0] + scan_inner_html(s, s[1]).join + (s.scan(/\n/) || '')
-    else
-      ''
-    end
-  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)(?:app|runo)-(\w+)/, 1] # "runo" is obsolete at 0.1.1
-
-    if inner_html =~ /<(?:\w+).+?class=(?:"|"[^"]*?\s)(model|body)(?:"|\s)/i # "body" is obsolete at 0.1.1
-      item_html = ''
-      sd_tmpl = gsub_block(inner_html, Regexp.last_match(1)) {|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)
-    open_tag  = "<#{name}"
-    close_tag = {'!--' => '-->', '<![CDATA[' => ']]>'}[name] || "</#{name}>"
-    contents = ''
-    rex = /(.*?)(#{Regexp.quote(open_tag)}|#{Regexp.quote(close_tag)}|\z)/m
-    gen = 1
-    until s.eos? || (gen < 1)
-      contents << s.scan(rex)
-      gen += 1 if s[2] == open_tag
-      gen -= 1 if s[2] == close_tag
-    end
-    contents.gsub!(/\A\n+/, '')
-    contents.gsub!(/[\t ]*#{Regexp.quote(close_tag)}\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