runo 0.1.0

data/lib/scalar/text.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+class Runo::Text < Runo::Field
+
+  def initialize(meta = {})
+    meta[:size] = $&.to_i if meta[:tokens] && meta[:tokens].first =~ /^\d+$/
+    super
+  end
+
+  def errors
+    if (my[:max].to_i > 0) && (val.size > my[:max])
+      [_('too long: %{max} characters maximum') % {:max => my[:max]}]
+    elsif (my[:min].to_i == 1) && val.empty?
+      [_ 'mandatory']
+    elsif (my[:min].to_i > 0) && (val.size < my[:min])
+      [_('too short: %{min} characters minimum') % {:min => my[:min]}]
+    else
+      []
+    end
+  end
+
+  private
+
+  def _g_update(arg)
+    <<_html.chomp
+<span class="#{_g_class arg}"><input type="text" name="#{my[:short_name]}" value="#{Runo::Field.h val}" size="#{my[:size]}" />#{_g_errors arg}</span>
+_html
+  end
+  alias :_g_create :_g_update
+
+  def val_cast(v)
+    v.to_s
+  end
+
+end

data/lib/scalar/textarea.rb

@@ -0,0 +1,35 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+class Runo::Textarea < Runo::Field
+
+  def errors
+    if (my[:max].to_i > 0) && (val.size > my[:max])
+      [_('too long: %{max} characters maximum') % {:max => my[:max]}]
+    elsif (my[:min].to_i == 1) && val.empty?
+      [_ 'mandatory']
+    elsif (my[:min].to_i > 0) && (val.size < my[:min])
+      [_('too short: %{min} characters minimum') % {:min => my[:min]}]
+    else
+      []
+    end
+  end
+
+  private
+
+  def _g_update(arg)
+    <<_html
+<span class="#{_g_class arg}">
+  <textarea name="#{my[:short_name]}" cols="#{my[:width]}" rows="#{my[:height]}">#{Runo::Field.h val}</textarea>
+#{_g_errors arg}</span>
+_html
+  end
+  alias :_g_create :_g_update
+
+  def val_cast(v)
+    v.to_s.gsub(/\r\n?/, "\n")
+  end
+
+end

data/lib/scalar/textarea_pre.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009-2010 Akira FUNAI
+
+require 'rack/utils'
+
+class Runo::Textarea::Pre < Runo::Textarea
+
+  def _g_default(arg)
+    '<pre>' + Runo::Field.h(val) + '</pre>'
+  end
+
+end

data/lib/scalar/textarea_wiki.rb

@@ -0,0 +1,173 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+require 'csv'
+
+class Runo::Textarea::Wiki < Runo::Textarea
+
+  private
+
+  def _g_default(arg)
+    wiki @val.to_s
+  end
+
+  def wiki(str)
+    str.chomp!
+
+    html = ''
+    body = ''
+    type = :p
+
+    Runo::Field.h(str).each_line {|line|
+      if line =~ /^---$/
+        new_type = :hr
+      else
+        line =~ /^(.?)/
+        case $1
+          when '!'
+            new_type = :heading
+          when ','
+            new_type = :table
+          when '*'
+            new_type = :ul
+          when '+'
+            new_type = :ol
+          when ' ', "\t"
+            new_type = :pre
+          when ''
+            new_type = :blank
+          else
+            new_type = :p
+        end
+      end
+      if new_type != type
+        html += __send__("element_#{type}", body.to_s)
+        body = ''
+      end
+      body += line
+      type = new_type
+    }
+    html += __send__("element_#{type}", body) if body != ''
+
+    html
+  end
+
+  def element_hr(body)
+    body.gsub!(/\n*\Z/, '')
+    body.gsub!(/^---$/, "<hr />\n")
+  
+    <<_html
+#{body}
+_html
+  end
+
+  def element_heading(body)
+    <<_html
+<h3>#{body}</h3>
+_html
+  end
+
+  def element_table(body)
+    table = CSV.parse(body.gsub!(/^,/, ''))
+
+    table.each_with_index {|row, y|
+      row.each_index {|x|
+        if (row[x] == :same_as_above)
+          row[x] = nil
+          next
+        end
+
+        span = 1
+        ((y + 1) .. (table.size - 1)).each {|y_below|
+          if (table[y_below][x] == row[x])
+            table[y_below][x] = :same_as_above
+            span += 1
+          else
+            break
+          end
+        }
+        rowspan = (span > 1) ? " rowspan=\"#{span}\"" : ''
+
+        row[x] = "<td valign=\"top\"#{rowspan}>#{inline(row[x])}</td>"
+      }
+    }
+
+    rows = table.collect {|row|
+      "  <tr>" + row.join('') + '</tr>'
+    }.join("\n")
+
+    <<_html
+<table class="wiki">
+#{rows}
+</table>
+_html
+  end
+
+  def element_list(body, ul_ol)
+    items = []
+    lines = []
+    type  = nil
+    (body + "\n\n").each_line {|line|
+      line.sub!(/^(\*|\+)/, '')
+
+      unless line =~ /^(\*|\+)/ || lines.empty?
+        item = inline(lines.shift.to_s.chomp)
+        unless lines.empty?
+          lines = lines.join
+          item += (lines =~ /\A\*/) ? element_ul(lines) : element_ol(lines)
+        end
+        items << "<li>#{item}</li>\n" if item != ''
+        lines = []
+      end
+
+      lines << line
+    }
+
+    <<_html
+<#{ul_ol} class="wiki">
+#{items}</#{ul_ol}>
+_html
+  end
+
+  def element_ul(body)
+    element_list(body, 'ul')
+  end
+
+  def element_ol(body)
+    element_list(body, 'ol')
+  end
+
+  def element_pre(body)
+    body.gsub!(/\n*\Z/, '')
+
+    <<_html
+<pre class="wiki">#{body}
+</pre>
+_html
+  end
+
+  def element_p(body)
+    body.gsub!(/\n*\Z/, '')
+    body.gsub!(/\n/, "<br />\n")
+    body.gsub!(/^/, '  ')
+
+    <<_html
+<p class="wiki">
+#{inline(body)}
+</p>
+_html
+  end
+
+  def element_blank(body)
+    body.gsub!(/\n/, "<br />\n")
+  end
+
+  def inline(body)
+    body.gsub!(/\*(.+?)\*/, '<strong class="wiki">\1</strong>')
+    body.gsub!(/\=\=(.+?)\=\=/, '<s class="wiki">\1</s>')
+    body
+  end
+
+end

data/lib/set/_set.rb

@@ -0,0 +1,195 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+module Runo::Set
+
+  include Enumerable
+
+  def meta_dir
+    my[:folder][:dir] if my[:folder]
+  end
+
+  def meta_path
+    ['main', nil].include?(my[:name]) ?
+      my[:dir] :
+      "#{my[:dir]}/#{my[:name].sub(/^main-?/, '').gsub('-', '/')}"
+  end
+
+  def meta_base_path
+    Runo.base ? Runo.base[:path] : my[:path]
+  end
+
+  def val(*steps)
+    if steps.empty?
+      _val
+    elsif i = item(steps)
+      i.val
+    end
+  end
+
+  def item(*item_steps)
+    item_steps = item_steps.first if item_steps.first.is_a? ::Array
+    return self if item_steps.empty?
+
+    id, *item_steps = item_steps
+
+    if id.is_a?(::String) && child = collect_item(:id => id).first
+      item = item_steps.empty? ? child : child.item(*item_steps)
+      block_given? ? yield(item) : item
+    end
+  end
+
+  def pending?
+    !pending_items.empty? || action
+  end
+
+  def errors
+    return {} if
+      my[:id] =~ Runo::REX::ID_NEW &&
+      my[:parent].is_a?(Runo::Set::Dynamic) &&
+      my[:parent].workflow.is_a?(Runo::Workflow::Attachment)
+
+    errors = {}
+    @item_object.each_pair {|id, item|
+      errors[id] = item.errors unless item.valid? || item.action == :delete
+    }
+    errors
+  end
+
+  def collect(&block)
+    collect_item({}, &block)
+  end
+
+  def each(&block)
+    collect_item.each &block
+  end
+
+  def inspect_items(indent = 0)
+    my_action = action.inspect
+    my_result = result.is_a?(::Hash) ?
+      result.keys.sort.inspect.sub(/\A\[([\w\W]*)\]\z/, '{\1}') :
+      result.inspect
+
+    '  ' * indent +
+    "<\"#{my[:id]}\" @action=#{my_action} @result=#{my_result}>\n" +
+    @item_object.keys.sort.collect {|id|
+      item = @item_object[id]
+      if item.respond_to? :inspect_items
+        item.inspect_items(indent + 1)
+      else
+        action = item.action.inspect
+        result = item.result.inspect
+        val    = item.val.inspect
+        '  ' * (indent + 1) + "<\"#{id}\" @action=#{action} @result=#{result} @val=#{val}>\n"
+      end
+    }.join
+  end
+
+  private
+
+  def _get(arg)
+    if respond_to?("_g_#{arg[:action]}", true)
+      _get_by_method arg
+    elsif summary?(arg) && action_tmpl = my[:tmpl][:summary]
+      _get_by_tmpl(arg, action_tmpl)
+    elsif action_tmpl = my[:tmpl][arg[:sub_action]] || my[:tmpl][arg[:action]]
+      _get_by_tmpl(arg, action_tmpl)
+    else
+      _get_by_tmpl(arg, my[:tmpl][:index])
+    end
+  end
+
+  def _get_by_tmpl(arg, tmpl = '')
+    tmpl.gsub(/@\((.+?)\)/) {
+      steps = $1.split '-'
+      id    = steps.pop
+      item  = item steps
+      item ? item[id.intern] : '???'
+    }.gsub(/_\((.+?)\)/) {
+      _ $1
+    }.gsub(/\$\((.*?)(?:\.([\w\-]+))?\)/) {
+      name, action = $1, $2
+      if name == ''
+        self_arg = action ?
+          arg.merge(:orig_action => arg[:action], :action => action.intern) : arg
+        _get_by_self_reference self_arg
+      else
+        steps = name.split '-'
+        item_arg = item_arg(arg, steps)
+        item = item steps
+        if item.nil?
+          '???'
+        elsif action
+          item_arg = item_arg.merge(
+            :orig_action => item_arg[:action],
+            :action      => action.intern
+          )
+          item.send(:_get_by_self_reference, item_arg) # skip the authorization
+        else
+          item.get(item_arg)
+        end
+      end
+    }.gsub(/^\s+\n/, '')
+  end
+
+  def _get_by_self_reference(arg)
+    return if arg[:action].to_s =~ /^action_/ && ![:read, nil].include?(arg[:orig_action])
+    _get_by_method(arg)
+  end
+
+  def _get_by_action_tmpl(arg)
+    return nil unless !arg[:recur] && action_tmpl = my[:tmpl][arg[:action]]
+    _get_by_tmpl(arg.merge(:action => nil, :sub_action => nil, :recur => true), action_tmpl)
+  end
+
+  def _g_default(arg, &block)
+    collect_item(arg[:conds] || {}) {|item|
+      item_arg = item_arg(arg, item[:id])
+      next if item.empty? && ![:create, :update].include?(item_arg[:action])
+      block ? block.call(item, item_arg) : item.get(item_arg)
+    }
+  end
+
+  def _g_errors(arg)
+    # errors are shown by scalars
+  end
+
+  def item_arg(arg, steps)
+    steps.to_a.inject(arg) {|a, s|
+      i = a[s] || {}
+      i[:p_action] = a[:action]
+      unless i[:action]
+        i[:action]     = a[:action]
+        i[:sub_action] = a[:sub_action] if a[:sub_action]
+      end
+      i
+    }
+  end
+
+  def summary?(arg)
+    [:read, nil].include?(arg[:action]) && !arg[:sub_action]
+  end
+
+  def permit_post?(action, val)
+    super || val.all? {|id, v|
+      if id.is_a? ::Symbol
+        true # not a item value
+      elsif id =~ Runo::REX::ID_NEW
+        permit? :create
+      else
+        item_action = v[:action] || :update
+        item(id) && item(id).permit?(item_action)
+      end
+    }
+  end
+
+  def pending_items
+    @item_object.keys.sort.inject({}) {|h, id|
+      h[id] = @item_object[id] if @item_object[id].pending?
+      h
+    }
+  end
+
+end