bike 0.2.1

data/lib/set/_set.rb

@@ -0,0 +1,196 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+module Bike::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
+    Bike.base ? Bike.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] =~ Bike::REX::ID_NEW &&
+      my[:parent].is_a?(Bike::Set::Dynamic) &&
+      my[:parent].workflow.is_a?(Bike::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 =~ Bike::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

data/lib/set/dynamic.rb

@@ -0,0 +1,177 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+class Bike::Set::Dynamic < Bike::Field
+
+  include Bike::Set
+
+  attr_reader :storage, :workflow
+
+  def initialize(meta = {})
+    @meta        = meta
+    @storage     = Bike::Storage.instance self
+    @workflow    = Bike::Workflow.instance self
+    @meta        = @workflow.class.const_get(:DEFAULT_META).merge @meta
+    @item_object = {}
+
+    my[:item] ||= {
+      'default' => {:item => {}}
+    }
+    my[:item].each {|type, item_meta|
+      item_meta[:item] = @workflow.default_sub_items.merge item_meta[:item]
+    }
+
+    my[:p_size] = meta[:max] if meta[:max]
+    my[:preview] = :optional if Array(meta[:tokens]).include?('may_preview')
+    my[:preview] = :mandatory if Array(meta[:tokens]).include?('should_preview')
+    my[:order] = 'id'  if Array(meta[:tokens]).include? 'asc'
+    my[:order] = '-id' if Array(meta[:tokens]).include? 'desc'
+  end
+
+  def meta_href
+    "#{Bike.uri}#{my[:path]}/"
+  end
+
+  def meta_tid
+    unless @meta[:tid]
+      t = Time.now
+      @meta[:tid] = t.strftime('%m%d%H%M%S.') + t.usec.to_s
+    end
+    @meta[:tid]
+  end
+
+  def get(arg = {})
+    if !arg[:conds].is_a?(::Hash) || arg[:conds].empty?
+      arg[:conds] = my[:conds].is_a?(::Hash) ? my[:conds].dup : {}
+    end
+    super
+  end
+
+  def commit(type = :temp)
+    @workflow.before_commit
+
+    items = pending_items
+    items.each {|id, item|
+      item.commit(:temp) || next
+      case type
+        when :temp
+          store(id, item) if @storage.is_a? Bike::Storage::Temp
+        when :persistent
+          store(id, item)
+          item.commit :persistent
+      end
+    }
+    if valid?
+      @result = (@action == :update) ? items : @action
+      @action = nil if type == :persistent
+      @workflow.after_commit
+      self
+    end
+  end
+
+  private
+
+  def _val
+    @storage.val
+  end
+
+  def _get(arg)
+    (@workflow._get(arg) || super) unless @workflow._hide? arg
+  end
+
+  def _get_by_tmpl(arg, tmpl = '')
+    if arg[:action] == :read || self != Bike.base
+      super
+    else
+      base_path = Bike.transaction[my[:tid]].is_a?(Bike::Field) ? nil : my[:base_path]
+      action = "#{base_path}/#{my[:tid]}/update.html"
+      <<_html
+<form id="form_#{my[:name]}" method="post" enctype="multipart/form-data" action="#{action}">
+<input name="_token" type="hidden" value="#{Bike.token}" />
+#{super}</form>
+_html
+    end
+  end
+
+  def _get_by_self_reference(arg)
+    super unless @workflow._hide?(arg)
+  end
+
+  def permit_get?(arg)
+    permit?(arg[:action]) || collect_item(arg[:conds] || {}).all? {|item|
+      item[:id][Bike::REX::ID_NEW] ?
+        item.permit?(:create) :
+        item.send(:permit_get?, :action => arg[:action])
+    }
+  end
+
+  def _post(action, v = nil)
+    if action == :create
+      @storage.build({})
+      @item_object.clear
+    end
+
+    case action
+      when :create, :update
+        v.keys.sort_by {|id| id.to_s }.each {|id|
+          next unless id.is_a? ::String
+
+          v[id][:action] ||= id[Bike::REX::ID_NEW] ? :create : :update
+          item_instance(id).post(v[id][:action], v[id])
+        }
+      when :load, :load_default
+        @storage.build v
+    end
+
+    !pending_items.empty? || action == :delete
+  end
+
+  def store(id, item)
+    case item.action
+      when :create
+        return if id[Bike::REX::ID] || item.empty?
+        new_id = @storage.store(:new_id, item.val)
+        item[:id] = new_id
+        @item_object.delete id
+        @item_object[item[:id]] = item
+      when :update, nil
+        new_id = @storage.store(item[:id], item.val)
+        if new_id != item[:id]
+          @item_object[new_id] = @item_object.delete item[:id]
+          item[:id] = new_id
+        end
+      when :delete
+        @storage.delete id
+        @item_object.delete id
+    end
+  end
+
+  def collect_item(conds = {}, &block)
+    @storage.select(conds).collect {|id|
+      item = item_instance id
+      block ? block.call(item) : item
+    }
+  end
+
+  def item_instance(id, type = 'default')
+    unless @item_object[id]
+      item_meta = my[:item][type] || my[:item]['default']
+      @item_object[id] = Bike::Field.instance(
+        item_meta.merge(
+          :id     => id,
+          :parent => self,
+          :klass  => 'set-static'
+        )
+      )
+      if id[Bike::REX::ID_NEW]
+        @item_object[id].load_default
+      else
+        @item_object[id].load @storage.val(id)
+      end
+    end
+    @item_object[id]
+  end
+
+end

data/lib/set/static.rb

@@ -0,0 +1,102 @@
+# encoding: UTF-8
+
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2009 Akira FUNAI
+
+require 'strscan'
+
+class Bike::Set::Static < Bike::Field
+
+  include Bike::Set
+
+  def initialize(meta = {})
+    @meta = meta
+    @meta.merge!(Bike::Parser.parse_html(meta[:html])) if meta[:html]
+    @meta[:item] ||= {}
+    @item_object = {}
+  end
+
+  def meta_href
+    my[:sd] ? "#{my[:sd][:href]}id=#{my[:id]}/" : "#{Bike.uri}#{my[:dir]}/"
+  end
+
+  def commit(type = :temp)
+    items = pending_items
+    items.each {|id, item| item.commit type }
+    if valid?
+      @result = (@action == :update) ? items : @action
+      @action = nil if type == :persistent
+      self
+    end
+  end
+
+  private
+
+  def _val
+    inject({}) {|v, item|
+      v[item[:id]] = item.val unless item.empty?
+      v
+    }
+  end
+
+  def _g_a_update(arg)
+    if arg[:orig_action] != :read
+      '<a>'
+    elsif permit_get?(:action => :update)
+      "<a href=\"#{_g_uri_update arg}\">"
+    elsif permit? :delete
+      "<a href=\"#{_g_uri_delete arg}\">"
+    else
+      '<a>'
+    end
+  end
+
+  def _g_uri_update(arg)
+    "#{my[:parent][:path]}/#{Bike::Path::path_of :id => my[:id]}update.html"
+  end
+
+  def _g_uri_delete(arg)
+    "#{my[:parent][:path]}/#{Bike::Path::path_of :id => my[:id]}preview_delete.html"
+  end
+
+  def _g_uri_detail(arg)
+    "#{my[:parent][:path]}/#{Bike::Path::path_of :id => my[:id]}read_detail.html"
+  end
+
+  def _g_hidden(arg)
+    if arg[:orig_action] == :preview
+      action = my[:id][Bike::REX::ID_NEW] ? :create : arg[:sub_action]
+      <<_html.chomp
+<input type="hidden" name="#{my[:short_name]}.action" value="#{action}" />
+_html
+    end
+  end
+
+  def _post(action, v = {})
+    each {|item|
+      id = item[:id]
+      item_action = (item.is_a?(Bike::Set) && action == :create) ? :update : action
+      item_action = v[id][:action] if v[id].is_a?(::Hash) && v[id][:action]
+      if [:load_default, :delete].include?(item_action) || v.key?(id) || item(id).is_a?(Bike::Meta)
+        item.post(item_action, v[id])
+      end
+    }
+    !pending_items.empty? || action == :delete
+  end
+
+  def collect_item(conds = {}, &block)
+    items = my[:item].keys
+    items &= Array(conds[:id]) if conds[:id] # select item(s) by id
+    items.sort.collect {|id|
+      item = @item_object[id] ||= Bike::Field.instance(
+        my[:item][id].merge(:id => id, :parent => self)
+      )
+      block ? block.call(item) : item
+    }
+  end
+
+  def val_cast(v)
+    v.is_a?(::Hash) ? v : {:self => v}
+  end
+
+end