wagn 1.12.7

data/lib/wagn/migration_helper.rb

@@ -0,0 +1,32 @@
+# -*- encoding : utf-8 -*-
+
+module Wagn::MigrationHelper
+  def self.card_migration_paths
+    Wagn.paths.add 'db/migrate_cards'
+    Wagn.paths['db/migrate_cards'].to_a
+  end
+  
+  def self.schema_mode type
+    new_suffix = type.to_s =~ /card/ ? '_cards' : ''
+    original_suffix = ActiveRecord::Base.table_name_suffix
+    ActiveRecord::Base.table_name_suffix = new_suffix
+    yield
+    ActiveRecord::Base.table_name_suffix = original_suffix
+  end
+  
+  def contentedly &block
+    Wagn::Cache.reset_global
+    Wagn::MigrationHelper.schema_mode '' do
+      Account.as_bot do
+        ActiveRecord::Base.transaction do
+          begin
+            yield
+          ensure
+            Wagn::Cache.reset_global
+          end
+        end
+      end
+    end
+  end
+  
+end

data/lib/wagn/script_wagn_loader.rb

@@ -0,0 +1,29 @@
+require 'pathname'
+
+module Wagn
+  module ScriptWagnLoader
+    RUBY = File.join(*RbConfig::CONFIG.values_at("bindir", "ruby_install_name")) + RbConfig::CONFIG["EXEEXT"]
+    SCRIPT_WAGN = File.join('script', 'wagn')
+
+    def self.exec_script_wagn!
+      cwd = Dir.pwd
+      return unless in_wagn_application? || in_wagn_application_subdirectory?
+      exec RUBY, SCRIPT_WAGN, *ARGV if in_wagn_application?
+      Dir.chdir("..") do
+        # Recurse in a chdir block: if the search fails we want to be sure
+        # the application is generated in the original working directory.
+        exec_script_wagn! unless cwd == Dir.pwd
+      end
+    rescue SystemCallError
+      # could not chdir, no problem just return
+    end
+
+    def self.in_wagn_application?
+      File.exists?(SCRIPT_WAGN)
+    end
+
+    def self.in_wagn_application_subdirectory?(path = Pathname.new(Dir.pwd))
+      File.exists?(File.join(path, SCRIPT_WAGN)) || !path.root? && in_wagn_application_subdirectory?(path.parent)
+    end
+  end
+end

data/lib/wagn/spec_helper.rb

@@ -0,0 +1,99 @@
+# -*- encoding : utf-8 -*-
+require 'spork'
+ENV["RAILS_ENV"] = 'test'
+
+Spork.prefork do
+  require File.expand_path( '../../../config/environment', __FILE__ )
+  require 'rspec/rails'
+
+  # Requires supporting ruby files with custom matchers and macros, etc,
+  # in spec/support/ and its subdirectories.
+  Dir[ File.join(Wagn.gem_root, "spec/support/**/*.rb") ].each { |f| require f }
+
+  FIXTURES_PATH = File.dirname(__FILE__) + '/../fixtures'
+  JOE_USER_ID = Card['joe_user'].id
+
+  RSpec.configure do |config|
+
+    config.include RSpec::Rails::Matchers::RoutingMatchers, :example_group => {
+      :file_path => /\bspec\/controllers\// }
+
+    #config.include CustomMatchers
+    #config.include ControllerMacros, :type=>:controllers
+
+    # == Mock Framework
+    # If you prefer to mock with mocha, flexmock or RR, uncomment the appropriate symbol:
+    # :mocha, :flexmock, :rr
+
+    config.mock_with :rr
+
+    config.use_transactional_fixtures = true
+    config.use_instantiated_fixtures  = false
+
+
+    config.before(:each) do
+      Account.current_id = JOE_USER_ID
+      Wagn::Cache.restore
+      Wagn::Env.reset
+    end
+    config.after(:each) do
+      Timecop.return
+    end
+  end
+end
+
+
+Spork.each_run do
+  # This code will be run each time you run your specs.
+end
+
+module Wagn::SpecHelper
+
+  include ActionDispatch::Assertions::SelectorAssertions
+  #~~~~~~~~~  HELPER METHODS ~~~~~~~~~~~~~~~#
+  
+  def login_as user
+    Account.current_id = @request.session[:user] = (uc=Card[user.to_s] and uc.id)
+    #warn "(ath)login_as #{user.inspect}, #{Account.current_id}, #{@request.session[:user]}"
+  end
+  
+  def newcard name, content=""
+    #FIXME - misleading name; sounds like it doesn't save.
+    Card.create! :name=>name, :content=>content
+  end
+
+  def assert_view_select(view_html, *args, &block)
+    node = HTML::Document.new(view_html).root
+    if block_given?
+      assert_select node, *args, &block
+    else
+      assert_select node, *args
+    end
+  end
+
+  def render_editor(type)
+    card = Card.create(:name=>"my favority #{type} + #{rand(4)}", :type=>type)
+    Card::Format.new(card).render(:edit)
+  end
+
+  def render_content content, format_args={}
+    @card ||= Card.new :name=>"Tempo Rary 2"
+    @card.content = content
+    f = Card::Format.new @card, format_args
+    f._render :core
+  end
+
+  def render_card view, card_args={}, format_args={}
+    card = begin
+      if card_args[:name]
+        Card.fetch card_args[:name], :new=>card_args
+      else
+        Card.new card_args.merge( :name=> 'Tempo Rary' )
+      end
+    end
+    Card::Format.new(card, format_args)._render(view)
+  end
+end
+
+RSpec::Core::ExampleGroup.send :include, Wagn::SpecHelper
+

data/lib/wagn/version.rb

@@ -0,0 +1,27 @@
+# -*- encoding : utf-8 -*-
+require 'wagn'
+
+module Wagn
+  module Version
+    class << self
+      
+      def release
+        @@version ||= File.read( File.expand_path '../../../VERSION', __FILE__ ).strip
+      end
+    
+      def schema type=nil
+        File.read( schema_stamp_path type ).strip
+      end
+    
+      def schema_stamp_path type
+        suffix = type.to_s =~ /card/ ? '_cards' : ''
+        File.join schema_stamp_dir, "/version#{ suffix }.txt"  
+      end
+    
+      def schema_stamp_dir
+        File.join Wagn.gem_root, 'config'
+      end
+      
+    end
+  end
+end

data/mods/core/chunks/literal.rb

@@ -0,0 +1,24 @@
+# -*- encoding : utf-8 -*-
+
+# These are basic chunks that have a pattern and can be protected.
+# They are used by rendering process to prevent wiki rendering
+# occuring within literal areas such as <code> and <pre> blocks
+# and within HTML tags.
+module Card::Chunk
+  class EscapedLiteral < Abstract
+    FULL_RE = { '[' => /^\\\[\[[^\]]*\]\]/, '{' => /^\\\{\{[^\}]*\}\}/ }
+    Card::Chunk.register_class self, {
+      :prefix_re => '\\\\(?:\\[\\[|\\{\\{)',
+      :idx_char  => '\\'
+    }
+
+    def self.full_re prefix
+      re = FULL_RE[ prefix[1,1] ]
+    end
+
+    def interpret match, content
+      @process_chunk = match[0].sub(/^\\(.)/, "<span>\\1</span>")
+    end
+  end
+
+end

data/mods/core/chunks/reference.rb

@@ -0,0 +1,41 @@
+# -*- encoding : utf-8 -*-
+module Card::Chunk
+  class Reference < Abstract
+    attr_accessor :referee_name, :name
+
+    def referee_name
+      return if name.nil?
+        
+      @referee_name ||= ( render_obj name ).to_name
+      @referee_name = @referee_name.to_absolute(card.cardname).to_name
+    end
+
+    def referee_card
+      @referee_card ||= referee_name && Card.fetch( referee_name )
+    end
+
+    def referee_id
+      referee_card and referee_card.id
+    end
+
+    def replace_name_reference old_name, new_name
+      #warn "ref rnr #{inspect}, #{old_name}, #{new_name}"
+      @referee_card = @referee_name = nil
+      if Card::Content===name
+        name.find_chunks(Chunk::Reference).each { |chunk| chunk.replace_reference old_name, new_name }
+      else
+        @name = name.to_name.replace_part( old_name, new_name )
+      end
+    end
+    
+    def render_obj raw
+      if format && Card::Content===raw
+        format.card.references_expired = nil # don't love this; this is to keep from running update_references again
+        format.process_content raw
+      else
+        raw
+      end
+    end
+  end
+end
+

data/mods/core/chunks/uri.rb

@@ -0,0 +1,135 @@
+# -*- encoding : utf-8 -*-
+require 'uri'
+
+# This wiki chunk matches arbitrary URIs, using patterns from the Ruby URI modules.
+# It parses out a variety of fields that could be used by formats to format
+# the links in various ways (shortening domain names, hiding email addresses)
+# It matches email addresses and host.com.au domains without schemes (http://)
+# but adds these on as required.
+#
+# The heuristic used to match a URI is designed to err on the side of caution.
+# That is, it is more likely to not autolink a URI than it is to accidently
+# autolink something that is not a URI. The reason behind this is it is easier
+# to force a URI link by prefixing 'http://' to it than it is to escape and
+# incorrectly marked up non-URI.
+#
+# I'm using a part of the [ISO 3166-1 Standard][iso3166] for country name suffixes.
+# The generic names are from www.bnoack.com/data/countrycode2.html)
+#   [iso3166]: http://geotags.com/iso3166/
+module Card::Chunk
+  class URI < Abstract
+
+    SCHEMES = %w{irc http https ftp ssh git sftp file ldap ldaps mailto}
+
+    REJECTED_PREFIX_RE = %w{ ! ": " ' ]( }.map{|s|Regexp.escape s} * '|'
+
+    attr_reader :uri, :link_text
+    delegate :to, :scheme, :host, :port, :path, :query, :fragment, :to => :uri
+
+    Card::Chunk.register_class self, {
+      :prefix_re => "(?:(?!#{REJECTED_PREFIX_RE})(?:#{SCHEMES * '|'})\\:)",
+      :full_re    => /^#{::URI.regexp( SCHEMES )}/,
+      :idx_char  => ':'
+    }
+    
+    class << self
+      def full_match content, prefix
+        prepend_str = if prefix[-1,1] != ':' && config[:prepend_str]
+          config[:prepend_str]
+        else
+          ''
+        end
+        content = prepend_str + content
+        match = super content, prefix
+        [ match, prepend_str.length ]
+      end
+
+      def context_ok? content, chunk_start
+        preceding_string = content[chunk_start-2..chunk_start-1]
+        !( preceding_string =~ /(?:#{REJECTED_PREFIX_RE})$/ )
+      end
+    end
+    
+    def interpret match, content
+      chunk = match[0]
+      last_char = chunk[-1,1]
+      chunk.gsub!(/(?:&nbsp;)+/, '')
+
+      @trailing_punctuation = if %w{ , . ) ! ? : }.member?(last_char)
+        @text.chop!
+        chunk.chop!
+        last_char
+      end
+      chunk.sub!(/\.$/, '')
+
+      @link_text = chunk
+
+      #warn "uri parse[#{match.inspect}]"
+      @uri = ::URI.parse( chunk )
+      @process_chunk = "#{self.format.build_link(@link_text, @link_text)}#{@trailing_punctuation}"
+    rescue ::URI::Error=>e
+      #warn "rescue parse #{chunk_class}: '#{m}' #{e.inspect} #{e.backtrace*"\n"}"
+      Rails.logger.warn "rescue parse #{self.class}: #{e.inspect}"
+    end
+
+
+  end
+
+  # FIXME: DRY, merge these two into one class
+  class EmailURI < URI
+
+    PREPEND_STR = 'mailto:'
+    EMAIL = "[a-zA-Z\d](?:[-a-zA-Z\d]*[a-zA-Z\d])?\\@"
+        
+    Card::Chunk.register_class self, {
+      :prefix_re => "(?:(?!#{REJECTED_PREFIX_RE})#{EMAIL})\\b",
+      :full_re    => /^#{::URI.regexp( SCHEMES )}/,
+      :prepend_str => PREPEND_STR,
+      :idx_char  => '@'
+    }
+
+    def interpret match, content
+      super
+      @text = @text.sub(/^mailto:/,'')  # this removes the prepended string from the unchanged match text
+      @process_chunk = "#{self.format.build_link(@link_text, @text)}#{@trailing_punctuation}"
+    end
+  end
+
+  class HostURI < URI
+
+    GENERIC = 'aero|biz|com|coop|edu|gov|info|int|mil|museum|name|net|org'
+
+    COUNTRY = 'ad|ae|af|ag|ai|al|am|an|ao|aq|ar|as|at|au|aw|az|ba|bb|bd|be|' +
+      'bf|bg|bh|bi|bj|bm|bn|bo|br|bs|bt|bv|bw|by|bz|ca|cc|cf|cd|cg|ch|ci|ck|cl|' +
+      'cm|cn|co|cr|cs|cu|cv|cx|cy|cz|de|dj|dk|dm|do|dz|ec|ee|eg|eh|er|es|et|fi|' +
+      'fj|fk|fm|fo|fr|fx|ga|gb|gd|ge|gf|gh|gi|gl|gm|gn|gp|gq|gr|gs|gt|gu|gw|gy|' +
+      'hk|hm|hn|hr|ht|hu|id|ie|il|in|io|iq|ir|is|it|jm|jo|jp|ke|kg|kh|ki|km|kn|' +
+      'kp|kr|kw|ky|kz|la|lb|lc|li|lk|lr|ls|lt|lu|lv|ly|ma|mc|md|mg|mh|mk|ml|mm|' +
+      'mn|mo|mp|mq|mr|ms|mt|mu|mv|mw|mx|my|mz|na|nc|ne|nf|ng|ni|nl|no|np|nr|nt|' +
+      'nu|nz|om|pa|pe|pf|pg|ph|pk|pl|pm|pn|pr|pt|pw|py|qa|re|ro|ru|rw|sa|sb|sc|' +
+      'sd|se|sg|sh|si|sj|sk|sl|sm|sn|so|sr|st|su|sv|sy|sz|tc|td|tf|tg|th|tj|tk|' +
+      'tm|tn|to|tp|tr|tt|tv|tw|tz|ua|ug|uk|um|us|uy|uz|va|vc|ve|vg|vi|vn|vu|wf|' +
+      'ws|ye|yt|yu|za|zm|zr|zw|' +
+      'eu' # made this separate, since it's not technically a country -efm
+      # These are needed otherwise HOST will match almost anything
+
+    TLDS = "(?:#{GENERIC}|#{COUNTRY})"
+    #TLDS = "(?:#{GENERIC})"
+
+    PREPEND_STR = 'http://'
+    HOST = "(?:[a-zA-Z\d](?:[-a-zA-Z\d]*[a-zA-Z\d])?\\.)+#{TLDS}"
+    
+    Card::Chunk.register_class self, {
+      :prefix_re => "(?:(?!#{REJECTED_PREFIX_RE})#{HOST})\\b",
+      :full_re    => /^#{::URI.regexp( SCHEMES )}/,
+      :prepend_str => PREPEND_STR
+    }
+
+    def interpret match, content
+      super
+      @text = @text.sub(/^http:\/\//,'')  # this removes the prepended string from the unchanged match text
+      #warn "huri t:#{@text}, #{match}, #{params.inspect}"
+      @process_chunk = "#{self.format.build_link(@link_text, @text)}#{@trailing_punctuation}"
+    end
+  end
+end

data/mods/core/formats/data_format.rb

@@ -0,0 +1,2 @@
+class Card::DataFormat < Card::Format
+end

data/mods/core/formats/html_format.rb

@@ -0,0 +1,319 @@
+# -*- encoding : utf-8 -*-
+
+require_dependency 'card/diff'
+
+class Card::HtmlFormat < Card::Format
+  include Card::Diff
+  
+  attr_accessor  :options_need_save, :start_time, :skip_autosave
+
+  # builtin layouts allow for rescue / testing
+  LAYOUTS = Wagn::Loader.load_layouts.merge 'none' => '{{_main}}'
+
+  INCLUSION_DEFAULTS = {
+    :layout => { :view => :core },
+    :normal => { :view => :content }
+  }
+  
+  
+  def get_inclusion_defaults
+    INCLUSION_DEFAULTS[@mode] || {}
+  end
+  
+  def default_item_view
+    :closed
+  end
+
+  def view_for_unknown view, args
+    case
+    when focal? && ok?( :create )   ;  :new
+    when commentable?( view, args ) ;  view
+    else                               super
+    end
+  end
+
+  def commentable? view, args
+    self.class.tagged view, :comment and 
+    args[:show] =~ /comment_box/     and
+    ok? :comment
+  end
+
+  def get_layout_content(args)
+    Account.as_bot do
+      case
+        when (params[:layout] || args[:layout]) ;  layout_from_name args
+        when card                               ;  layout_from_card
+        else                                    ;  LAYOUTS['default']
+      end
+    end
+  end
+
+  def layout_from_name args
+    lname = (params[:layout] || args[:layout]).to_s
+    lcard = Card.fetch(lname, :skip_virtual=>true, :skip_modules=>true)
+    case
+      when lcard && lcard.ok?(:read)         ; lcard.content
+      when hardcoded_layout = LAYOUTS[lname] ; hardcoded_layout
+      else  ; "<h1>Unknown layout: #{lname}</h1>Built-in Layouts: #{LAYOUTS.keys.join(', ')}"
+    end
+  end
+
+  def layout_from_card
+    return unless rule_card = (card.rule_card(:layout) or Card.default_rule_card(:layout))
+    #return unless rule_card.is_a?(Card::Set::Type::Pointer) and  # type check throwing lots of warnings under cucumber: rule_card.type_id == Card::PointerID        and
+    return unless rule_card.type_id == Card::PointerID        and
+        layout_name=rule_card.item_names.first                and
+        !layout_name.nil?                                     and
+        lo_card = Card.fetch( layout_name, :skip_virtual => true, :skip_modules=>true ) and
+        lo_card.ok?(:read)
+    lo_card.content
+  end
+
+  def slot_options args
+    @@slot_option_keys ||= Card::Chunk::Include.options.reject { |k| k == :view }.unshift :home_view
+    options_hash = {}
+    
+    if @context_names.present?
+      options_hash['name_context'] = @context_names.map( &:key ) * ','
+    end
+    
+    @@slot_option_keys.inject(options_hash) do |hash, opt|
+      hash[opt] = args[opt] if args[opt].present?
+      hash
+    end
+    
+    JSON( options_hash )
+  end
+
+  def wrap view, args = {}
+    classes = [
+      ( 'card-slot' unless args[:no_slot] ),
+      "#{view}-view",
+      ( args[:slot_class] if args[:slot_class] ),
+      ( "STRUCTURE-#{args[:structure].to_name.key}" if args[:structure]),
+      card.safe_set_keys
+    ].compact
+    
+    div = %{<div id="#{card.cardname.url_key}" data-card-id="#{card.id}" data-card-name="#{h card.name}" style="#{h args[:style]}" class="#{classes*' '}" } +
+      %{data-slot='#{html_escape_except_quotes slot_options( args )}'>#{yield}</div>}
+
+    if args[:no_wrap_comment]
+      div
+    else
+      name = h card.name
+      space = '  ' * @depth
+      %{<!--\n\n#{ space }BEGIN SLOT: #{ name }\n\n-->#{ div }<!--\n\n#{space}END SLOT: #{ name }\n\n-->}
+    end
+  end
+  
+  def wrap_body args={}
+    css_classes = [ 'card-body' ]
+    css_classes << args[:body_class]                  if args[:body_class]
+    css_classes += [ 'card-content', card.safe_set_keys ] if args[:content]
+    content_tag :div, :class=>css_classes.compact*' ' do
+      yield args
+    end
+  end
+    
+  def wrap_frame view, args={}
+    wrap view, args.merge(:slot_class=>'card-frame') do
+      %{
+        #{ _render_header args }
+        #{ %{ <div class="card-subheader">#{ args[:subheader] }</div> } if args[:subheader] }
+        #{ _render_help args if args[:show_help] }
+        #{ wrap_body args do yield args end }
+      }
+    end
+  end
+
+  def wrap_main(content)
+    return content if params[:layout]=='none'
+    %{#{
+    if flash[:notice]
+      %{<div class="flash-notice">#{ flash[:notice] }</div>}
+    end
+    }<div id="main">#{content}</div>}
+  end
+
+  
+  def html_escape_except_quotes s
+    # to be used inside single quotes (makes for readable json attributes)
+    s.to_s.gsub(/&/, "&amp;").gsub(/\'/, "&apos;").gsub(/>/, "&gt;").gsub(/</, "&lt;")
+  end
+
+
+  def edit_slot args={}
+    if args[:structure] || card.structure
+      _render_raw(args).scan( /\{\{\s*\+[^\}]*\}\}/ ).map do |inc|
+        process_content( inc ).strip
+      end.join
+#        raw _render_core(args)
+    elsif label = args[:label]
+      label = '' if label == true
+      fieldset label, content_field( form, args ), :editor=>:content
+    else
+      editor_wrap( :content ) { content_field form, args }
+    end
+  end
+  
+
+  #### --------------------  additional helpers ---------------- ###
+
+  def rendering_error exception, view
+    %{
+      <span class="render-error">
+        error rendering
+        #{
+          if Account.always_ok?
+            %{
+              #{ link_to_page error_cardname, nil, :class=>'render-error-link' }
+              <div class="render-error-message errors-view" style="display:none">
+                <h3>Error message (visible to admin only)</h3>
+                <p><strong>#{ exception.message }</strong></p>
+                <div>
+                  #{exception.backtrace * "<br>\n"}
+                </div>
+              </div>
+            }
+          else
+            error_cardname
+          end
+        }
+        (#{view} view)
+      </span>
+    }
+  end
+  
+  def unknown_view view
+    "<strong>unknown view: <em>#{view}</em></strong>"
+  end
+  
+  def unsupported_view view
+    "<strong>view <em>#{view}</em> not supported for <em>#{error_cardname}</em></strong>"
+  end
+
+  def final_link href, opts={}
+    text = opts[:text] || href
+    %{<a class="#{opts[:class]}" href="#{href}">#{text}</a>}
+  end
+
+  def link_to_view text, view, opts={}
+    path_opts = view==:home ? {} : { :view=>view }
+    if p = opts.delete( :path_opts )
+      path_opts.merge! p
+    end
+    opts[:remote] = true
+    opts[:rel] = 'nofollow'
+    link_to text, path( path_opts ), opts
+  end
+
+  def name_field form=nil, options={}
+    form ||= self.form
+    form.text_field( :name, {
+      :value=>card.name, #needed because otherwise gets wrong value if there are updates
+      :autocomplete=>'off'
+    }.merge(options))
+  end
+
+  def type_field args={}
+    typelist = Account.createable_types
+    typelist << card.type_name if !card.new_card?
+    # current type should be an option on existing cards, regardless of create perms
+
+    options = options_from_collection_for_select(
+      typelist.uniq.sort.map { |name| [ name, name ] },
+      :first, :last, Card[ card ? card.type_id : Card.default_type_id ].name )
+    template.select_tag 'card[type]', options, args
+  end
+
+  def content_field form, options={}
+    @form = form
+    @nested = options[:nested]
+    revision_tracking = if card && !card.new_card? && !options[:skip_rev_id]
+      form.hidden_field :current_revision_id, :class=>'current_revision_id'
+    end
+    %{
+      #{ revision_tracking }
+      #{ _render_editor options }
+    }
+  end
+
+  def form_for_multi
+    block = Proc.new {}
+    builder = ActionView::Base.default_form_builder
+    card.name = card.name.gsub(/^#{Regexp.escape(root.card.name)}\+/, '+') if root.card.new_card?  ##FIXME -- need to match other relative inclusions.
+    
+    builder.new("card[cards][#{card.relative_name}]", card, template, {}, block)
+  end
+
+  def form
+    @form ||= form_for_multi
+  end
+
+  def card_form *opts
+    form_for( card, form_opts(*opts) ) { |form| yield form }
+  end
+
+  def form_opts url, classes='', other_html={}
+    url = path(:action=>url) if Symbol===url
+    opts = { :url=>url, :remote=>true, :html=>other_html }
+    opts[:html][:class] = classes + ' slotter'
+    opts[:html][:recaptcha] = 'on' if Wagn::Env[:recaptcha_on] && Card.toggle( card.rule(:captcha) )
+    opts
+  end
+
+  def editor_wrap type=nil
+    content_tag( :div, :class=>"editor#{ " #{type}-editor" if type }" ) { yield }
+  end
+
+  def fieldset title, content, opts={}
+    if attribs = opts[:attribs]
+      attrib_string = attribs.keys.map do |key| 
+        %{#{key}="#{attribs[key]}"}
+      end * ' '
+    end
+    help_text = case opts[:help]
+      when String ; _render_help :help_text=> opts[:help]
+      when true   ; _render_help
+      else        ; nil
+    end
+    %{
+      <fieldset #{ attrib_string }>
+        <legend>
+          <h2>#{ title }</h2>
+          #{ help_text }
+        </legend>
+        #{ editor_wrap( opts[:editor] ) { content } }
+      </fieldset>
+    }
+  end
+  
+  def hidden_tags hash, base=nil
+    # convert hash into a collection of hidden tags
+    result = ''
+    hash.each do |key, val|
+      result += if Hash === val
+        hidden_tags val, key
+      else
+        name = base ? "#{base}[#{key}]" : key
+        hidden_field_tag name, val
+      end
+    end
+    result
+  end
+
+  def main?
+    if ajax_call?
+      @depth == 0 && params[:is_main]
+    else
+      @depth == 1 && @mainline
+    end
+  end
+
+  private
+
+  def fancy_title title=nil
+    raw %{<span class="card-title">#{ showname(title).to_name.parts.join %{<span class="joint">+</span>} }</span>}
+  end
+
+end