runo 0.2.1 → 0.2.2

data/lib/scalar/text.rb

@@ -1,38 +0,0 @@
-# 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

@@ -1,35 +0,0 @@
-# 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

@@ -1,14 +0,0 @@
-# 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

@@ -1,173 +0,0 @@
-# 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.join}</#{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

@@ -1,196 +0,0 @@
-# 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(/@\((.+?)\)/) {
-      tag   = $&
-      steps = $1.split '-'
-      id    = steps.pop
-      item  = item steps
-      item ? item[id.intern] : tag
-    }.gsub(/_\((.+?)\)/) {
-      _ $1
-    }.gsub(/\$\((.*?)(?:\.([\w\-]+))?\)/) {
-      tag, 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?
-          tag
-        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)
-    }.join
-  end
-
-  def _g_errors(arg)
-    # errors are shown by scalars
-  end
-
-  def item_arg(arg, steps)
-    Array(steps).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.is_a?(::Hash) && 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