card 1.19.6 → 1.20.0

data/mod/standard/set/all/links.rb

@@ -5,7 +5,7 @@ format :html do
     opts[:href] = path opts.delete(:path)
     text = raw(text || opts[:href])
     interpret_data_opts_to_link_to opts
-    content_tag :a, text, opts
+    wrap_with :a, text, opts
   end
 
   def interpret_data_opts_to_link_to opts

data/mod/standard/set/all/rich_html/content.rb

@@ -2,117 +2,110 @@ def show_comment_box_in_related?
   false
 end
 
+def help_rule_card
+  setting = new_card? ? [:add_help, { fallback: :help }] : :help
+  help_card = rule_card(*setting)
+  help_card if help_card && help_card.ok?(:read)
+end
+
 format :html do
   def show view, args
-    if show_layout?
-      args[:view] = view if view
-      @main_opts = args
-      render :layout
-    else
-      view ||= args[:home_view] || :open
-      @nest_opts = (args[:items] || {}).clone
-      render view, args
-    end
+    send "show_#{show_layout? ? :with : :without}_layout", view, args
   end
 
   def show_layout?
     !Env.ajax? || params[:layout]
   end
 
-  view :layout, perms: :none do |args|
-    output [
-      process_content(get_layout_content, content_opts:
-        { chunk_list: :references }),
-      _render_modal_slot(args)
-    ]
+  def show_with_layout view, args
+    args[:view] = view if view
+    @main = false
+    @main_opts = args
+    render :layout, title: params[:layout]
+    # FIXME: using title because it's a standard view option.  hack!
   end
 
-  view :content do |args|
-    wrap args.reverse_merge(slot_class: "card-content") do
-      [
-        _optional_render(:menu, args, :hide),
-        _render_core(args)
-      ]
-    end
+  def show_without_layout view, args
+    @main = true if params[:is_main] || args[:main]
+    view ||= args[:home_view] || :open
+    render view, args
+  end
+
+  view :layout, perms: :none do
+    layout = process_content get_layout_content(voo.title),
+                             content_opts: { chunk_list: :references }
+    output [layout, _render_modal_slot]
+  end
+
+  view :content do
+    class_up "card-slot", "card-content"
+    voo.hide :menu
+    wrap { [_optional_render_menu, _render_core] }
   end
 
-  view :content_panel do |args|
-    wrap args.reverse_merge(slot_class: "card-content panel panel-default") do
+  view :content_panel do
+    class_up "card-slot", "card-content panel panel-default"
+    voo.hide :menu
+    wrap do
       wrap_with :div, class: "panel-body" do
-        [
-          _optional_render(:menu, args, :hide),
-          _render_core(args)
-        ].join("\n")
+        [_optional_render_menu, _render_core]
       end
     end
   end
 
-  view :titled, tags: :comment do |args|
-    wrap args do
+  view :titled, tags: :comment do
+    @content_body = true
+    wrap do
       [
-        _optional_render(:menu, args),
-        _render_header(args),
-        wrap_body(content: true) { _render_core args },
-        optional_render(:comment_box, args)
+        _optional_render_menu,
+        _render_header,
+        wrap_body { _render_core },
+        optional_render_comment_box
       ]
     end
   end
 
-  view :labeled do |args|
-    wrap args do
+  view :labeled do
+    class_up "card-body", "closed-content"
+    @content_body = true
+    wrap do
       [
-        _optional_render(:menu, args),
-        "<label>#{_render_title args}</label>",
-        wrap_body(body_class: "closed-content", content: true) do
-          _render_closed_content args
+        _optional_render_menu,
+        wrap_with(:label, _render_title),
+        wrap_body do
+          _render_closed_content
         end
       ]
     end
   end
 
-  view :title do |args|
-    title = fancy_title args[:title], args[:title_class]
-    title =
-      _optional_render(:title_editable, args, :hide) ||
-      _optional_render(:title_link, args.merge(title_ready: title), :hide) ||
-      title
+  view :title do
+    title = fancy_title super()
+    if show_view? :title_link, :hide
+      title = _render_title_link title_ready: title
+    end
     add_name_context
     title
   end
 
   view :title_link do |args|
-    title_text = args[:title_ready] || showname(args[:title])
+    title_text = args[:title_ready] || showname(voo.title)
     link_to_card card.cardname, title_text
   end
 
   view :type_info do
-    link = link_to_card card.type_name, nil, class: "navbar-link"
-    %(<span class="type-info pull-right">#{link}</span>).html_safe
-  end
-
-  view :title_editable do |args|
-    links = card.cardname.parts.map { |name| link_to_card name }
-    res = links.shift
-    links.each_with_index do |link, index|
-      name = card.cardname.parts[0..index + 1].join "+"
-      res += link_to_card name, glyphicon("plus", "header-icon")
-      res += link
+    return unless show_view?(:toolbar, :hide) && card.type_code != :basic
+    wrap_with :span, class: "type-info pull-right" do
+      link_to_card card.type_name, nil, class: "navbar-link"
     end
-    res += " "
-    res.concat link_to_view(
-      :edit_name, glyphicon("edit", "header-icon"),
-      class: "slotter", "data-toggle" => "tooltip", title: "edit name"
-    )
-    res.concat _optional_render(:type_link, args, :show)
   end
 
-  view :open, tags: :comment do |args|
-    args[:optional_toggle] ||= main? ? :hide : :show
-    frame args.merge(content: true) do
-      [
-        _render_open_content(args),
-        optional_render(:comment_box, args)
-      ]
+  view :open, tags: :comment do
+    voo.show! :toolbar if toolbar_pinned?
+    voo.viz :toggle, (main? ? :hide : :show)
+    @content_body = true
+    frame do
+      [_render_open_content, optional_render_comment_box]
     end
   end
 
@@ -125,26 +118,22 @@ format :html do
     link_to_card card.type_card, nil, class: klasses
   end
 
-  view :closed do |args|
-    frame args.reverse_merge(
-      content: true,
-      body_class: "closed-content",
-      toggle_mode: :close,
-      optional_toggle: :show,
-      optional_toolbar: :hide
-    ) do
-      _optional_render :closed_content, args
-    end
+  view :closed do
+    voo.show :toggle
+    voo.hide! :toolbar
+    class_up "card-body", "closed-content"
+    @content_body = true
+    @toggle_mode = :close
+    frame { _optional_render :closed_content }
   end
 
-  view :change do |args|
-    args[:optional_title_link] = :show
-    wrap args do
-      [
-        _optional_render(:title, args),
-        _optional_render(:menu, args, :hide),
-        _optional_render(:last_action, args)
-      ]
+  view :change do
+    voo.show :title_link
+    voo.hide :menu
+    wrap do
+      [_optional_render_title,
+       _optional_render_menu,
+       _optional_render_last_action]
     end
   end
 
@@ -157,60 +146,51 @@ format :html do
     Card.fetch(set_name)
   end
 
+  # subheader = with_name_context(card.name) do
+  #   subformat(rcard)._render_title(args)
+  # end
+
   view :related do |args|
-    if args[:related_card]
-      frame args.merge(optional_toolbar: :show) do
-        nest(args[:related_card], args[:related_args])
-      end
+    related_card, options = related_card_and_options args
+    return unless related_card
+    voo.show :toolbar, :menu, :help
+    frame do
+      voo.hide :header, :toggle
+      nest related_card, options
     end
   end
 
-  def default_related_args args
-    rparams = args[:related] || params[:related]
-    return unless rparams
-    rcard = rparams[:card] || begin
-      rcardname = rparams[:name].to_name.to_absolute_name(card.cardname)
-      Card.fetch rcardname, new: {}
-    end
+  def related_card_and_options args
+    options = (args[:related] || params[:related]).symbolize_keys
+    return unless options
+    related_card = related_card_from_options options
+    options[:view] ||= :open
+    options[:show] ||= []
+    options[:show] << :comment_box if related_card.show_comment_box_in_related?
+    [related_card, options]
+  end
 
-    subheader = with_name_context(card.name) do
-      subformat(rcard)._render_title(args)
-    end
-    add_name_context card.name
-    nest_args = (rparams[:slot] || {}).deep_symbolize_keys.reverse_merge(
-      view:            (rparams[:view] || :open),
-      optional_header: :hide,
-      optional_menu:   :show,
-      subheader:       subheader,
-      optional_toggle: :hide,
-      optional_help:   :show,
-      parent:          card,
-      subframe:        true,
-      subslot:         true
-    )
-    if rcard.show_comment_box_in_related?
-      nest_args[:optional_comment_box] = :show
-    end
-    args[:related_args] = nest_args
-    args[:related_card] = rcard
-  end
-
-  view :help, tags: :unknown_ok do |args|
-    text = args[:help_text] || begin
-      setting = card.new_card? ? [:add_help, { fallback: :help }] : :help
-      help_card = card.rule_card(*setting)
-      if help_card && help_card.ok?(:read)
-        with_nest_mode :normal do
-          raw_help_content = _render_raw args.merge(structure: help_card.name)
-          process_content raw_help_content, content_opts:
-            { chunk_list: :references }
-          # render help card with current card's format
-          # so current card's context is used in help card nests
-        end
-      end
+  def related_card_from_options options
+    related_card = options.delete :card
+    return related_card if related_card
+    related_name = options.delete(:name).to_name.to_absolute_name card.cardname
+    Card.fetch related_name, new: {}
+  end
+
+  view :help, tags: :unknown_ok do
+    help_text = voo.help || rule_based_help
+    return "" unless help_text.present?
+    wrap_with :div, help_text, class: classy("help-text")
+  end
+
+  def rule_based_help
+    return "" unless (rule_card = card.help_rule_card)
+    with_nest_mode :normal do
+      process_content _render_raw(structure: rule_card.name),
+                      content_opts: { chunk_list: :references }
+      # render help card with current card's format
+      # so current card's context is used in help card nests
     end
-    klass = [args[:help_class], "help-text"].compact * " "
-    %(<div class="#{klass}">#{raw text}</div>) if text
   end
 
   view :last_action do
@@ -236,9 +216,13 @@ format :html do
 
   private
 
-  def fancy_title title=nil, title_class=nil
-    klasses = ["card-title", title_class].compact * " "
-    title = showname(title).to_name.parts.join %(<span class="joint">+</span>)
-    raw %(<span class="#{klasses}">#{title}</span>)
+  def fancy_title title=nil
+    wrap_with :span, class: classy("card-title") do
+      showname(title).to_name.parts.join fancy_joint
+    end
+  end
+
+  def fancy_joint
+    wrap_with :span, "+", classy("joint")
   end
 end

data/mod/standard/set/all/rich_html/editing.rb

@@ -1,240 +1,177 @@
 format :html do
   ###---( TOP_LEVEL (used by menu) NEW / EDIT VIEWS )
-
-  view :new, perms: :create, tags: :unknown_ok do |args|
-    frame_and_form :create, args, "main-success" => "REDIRECT" do
+  view :edit, perms: :update, tags: :unknown_ok, cache: :never do
+    voo.show :toolbar, :help
+    frame_and_form :update do
       [
-        _optional_render(:name_formgroup, args),
-        _optional_render(:type_formgroup, args),
-        _optional_render(:content_formgroup, args),
-        _optional_render(:button_formgroup, args)
+        edit_view_hidden,
+        _optional_render_content_formgroup,
+        _optional_render_edit_buttons
       ]
     end
   end
 
-  def default_new_args args
-    hidden = args[:hidden] ||= {}
-    hidden[:success] ||= card.rule(:thanks) || "_self"
-    hidden[:card] ||= {}
-
-    args[:optional_help] ||= :show
-
-    default_new_args_for_name_field_or_title args
-    default_new_args_for_type_field args
-    default_new_args_buttons args
+  def edit_view_hidden
+    # for override
   end
 
-  def default_new_args_for_name_field_or_title args
-    hidden = args[:hidden]
-    if !params[:name_prompt] && !card.cardname.blank?
-      # name is ready and will show up in title
-      hidden[:card][:name] ||= card.name
-    else
-      args[:title] ||= generic_new_card_title
-      # FIXME: - overrides nest args
-      unless card.rule_card :autoname
-        # prompt for name
-        hidden[:name_prompt] = true unless hidden.key? :name_prompt
-        args[:optional_name_formgroup] ||= :show
-      end
+  view :edit_buttons do
+    button_formgroup do
+      [standard_submit_button, standard_cancel_button]
     end
-    args[:optional_name_formgroup] ||= :hide
   end
 
-  def generic_new_card_title
-    if card.type_id == Card.default_type_id
-      "New"
-    else
-      "New #{card.type_name}"
-    end
+  def standard_submit_button
+    submit_button class: "submit-button"
   end
 
-  def default_new_args_for_type_field args
-    if show_type_formgroup?(args)
-      args[:optional_type_formgroup] = :show
-    else
-      args[:hidden][:card][:type_id] ||= card.type_id
-      args[:optional_type_formgroup] = :hide
-    end
+  def standard_cancel_button href=nil
+    href ||= path
+    cancel_button class: "cancel-button", href: href
   end
 
-  def show_type_formgroup? args
-    !params[:type] && !args[:type] &&
-      (main? || card.simple? || card.is_template?) &&
-      Card.new(type_id: card.type_id).ok?(:create)
+  view :edit_name, perms: :update do
+    voo.show :toolbar
+    frame_and_form({ action: :update, id: card.id },
+                   "main-success" => "REDIRECT") do
+      [hidden_edit_name_fields,
+       _optional_render_name_formgroup,
+       rename_confirmation_alert,
+       edit_name_buttons]
+    end
   end
 
-  def default_new_args_buttons args
-    cancel_path = !main? && path(view: :missing)
-    args[:buttons] ||= [
-      submit_button(class: "create-submit-button"),
-      cancel_button(class: "create-cancel-button", href: cancel_path)
-    ].join "\n"
+  def hidden_edit_name_fields
+    hidden_tags success:  "_self",
+                old_name: card.name,
+                card: { update_referers: false }
   end
 
-  view :edit, perms: :update, tags: :unknown_ok do |args|
-    frame_and_form :update, args.reverse_merge(optional_toolbar: :show) do
-      [
-        _optional_render(:content_formgroup, args),
-        _optional_render(:button_formgroup, args)
-      ]
+  def edit_name_buttons
+    button_formgroup do
+      [rename_and_update_button, rename_button, standard_cancel_button]
     end
   end
 
-  def default_edit_args args
-    args[:optional_help] ||= :show
-    args[:optional_toolbar] ||= :show
-
-    args[:buttons] ||= %(
-      #{submit_button class: 'submit-button'}
-      #{cancel_button href: (args[:cancel_path] || path),
-                      class: 'cancel-button',
-                      'data-slot-selector' => args[:cancel_slot_selector]}
-    )
+  def rename_and_update_button
+    submit_button text: "Rename and Update", disable_with: "Renaming",
+                  class: "renamer-updater"
   end
 
-  view :edit_name, perms: :update do |args|
-    frame_and_form(
-      { action: :update, id: card.id }, args, "main-success" => "REDIRECT"
-    ) do
-      [
-        _render_name_formgroup(args),
-        _optional_render(:confirm_rename, args),
-        _optional_render(:button_formgroup, args)
-      ]
-    end
+  def rename_button
+    button_tag "Rename", data: { disable_with: "Renaming" }, class: "renamer"
   end
 
-  view :confirm_rename do |args|
-    referers = args[:referers]
-    descendants = card.descendants
+  def rename_confirmation_alert
     msg = "<h5>Are you sure you want to rename <em>#{card.name}</em>?</h5>"
-    if referers.any? || descendants.any?
-      msg << rename_info(referers, descendants)
-    end
+    msg << rename_effects_and_options
     alert("warning") { msg }
   end
 
-  def rename_info referers, descendants
-    effects = []
-    options = ""
-    if descendants.any? # FIXME: count, don't instantiate
-      effects << "automatically alter #{descendants.size} related name(s)."
-    end
-    if referers.any? # FIXME: count, don't instantiate
-      count = referers.size
-      refs = count == 1 ? "reference" : "references"
-      effects << "affect at least #{count} #{refs} to \"#{card.name}\""
-      options = "You may choose to <em>update or ignore</em> the referers."
-    end
-    effects = effects.map { |effect| "<li>#{effect}</li>" }.join("")
-    "<h6>This change will...</h6><ul>#{effects}</ul><p>#{options}</p>"
-  end
-
-  def default_edit_name_args args
-    referers = args[:referers] = card.family_referers
-    args[:hidden] ||= {}
-    args[:hidden].reverse_merge!(
-      success:  "_self",
-      old_name: card.name,
-      referers: referers.size, # FIXME: count, don't instantiate
-      card:     { update_referers: false }
-    )
-    args[:optional_toolbar] ||= :show
-    args[:buttons] = default_rename_buttons
+  def rename_effects_and_options
+    descendant_effect = rename_descendant_effect
+    referer_effect, referer_option = rename_referer_effect_and_option
+    effects = [descendant_effect, referer_effect].compact
+    return "" if effects.empty?
+    format_rename_effects_and_options effects, referer_option
   end
 
-  def default_rename_buttons
-    [submit_button(text: "Rename and Update",
-                   disable_with: "Renaming",
-                   class: "renamer-updater"),
-     button_tag("Rename", data: { disable_with: "Renaming" }, class: "renamer"),
-     cancel_button(href: path)].join "\n"
+  def format_rename_effects_and_options effects, referer_option
+    effects = effects.map { |effect| "<li>#{effect}</li>" }.join
+    info = %(<h6>This change will...</h6>)
+    info += %(<ul>#{effects}</ul>)
+    info += %(<p>#{referer_option}</p>) if referer_option
+    info
   end
 
-  view :edit_type, perms: :update do |args|
-    frame_and_form :update, args do
-      # 'main-success'=>'REDIRECT: _self', # adding this back in would make
-      # main cards redirect on cardtype changes
+  def rename_descendant_effect
+    descendants = card.descendants
+    return unless descendants.any? # FIXME: count, don't instantiate
+    "automatically alter #{descendants.size} related name(s)."
+  end
+
+  def rename_referer_effect_and_option
+    referers = card.family_referers
+    return unless referers.any? # FIXME: count, don't instantiate
+    count = referers.size
+    refs = count == 1 ? "reference" : "references"
+    effect = "affect at least #{count} #{refs} to \"#{card.name}\""
+    effect += hidden_field_tag(:referers, count)
+    option = "You may choose to <em>update or ignore</em> the referers."
+    [effect, option]
+  end
+
+  view :edit_type, cache: :never, perms: :update do
+    voo.show :toolbar
+    frame_and_form :update do
       [
-        _render_type_formgroup(args),
-        optional_render(:button_formgroup, args)
+        hidden_edit_type_fields,
+        _render_type_formgroup,
+        edit_type_buttons
       ]
     end
   end
 
-  def default_edit_type_args args
-    args[:variety] = :edit # YUCK!
-    args[:optional_toolbar] ||= :show
-    args[:hidden] ||= { success: { view: :edit } }
-    args[:buttons] = [
-      submit_button, cancel_button(href: path(view: :edit))
-    ].join "\n"
-  end
-
-  view :edit_rules, tags: :unknown_ok do |args|
-    view = args[:rule_view] || :common_rules
-    slot_args =
-      {
-        rule_view: view,
-        optional_set_navbar: :show,
-        optional_set_label: :hide,
-        optional_rule_navbar: :hide
-      }
-    _render_related args.merge(
-      related: { card: current_set_card, view: :open, slot: slot_args }
-    )
+  def hidden_edit_type_fields
+    hidden_field_tag "success[view]", "edit"
   end
 
-  def default_edit_rules_args args
-    args[:optional_toolbar] ||= :show
+  def edit_type_buttons
+    cancel_path = path view: :edit
+    button_formgroup do
+      [standard_submit_button, standard_cancel_button(cancel_path)]
+    end
   end
 
-  # for backwards compatibility
-  view :options, view: :edit_rules, mod: All::RichHtml::Editing::HtmlFormat
+  view :edit_rules, cache: :never, tags: :unknown_ok do |args|
+    voo.show :set_navbar, :toolbar
+    voo.hide :set_label, :rule_navbar
 
-  view :edit_structure do |args|
-    slot_args =
-      {
-        cancel_slot_selector: ".card-slot.related-view",
-        cancel_path: card.format.path(view: :edit),
-        optional_edit_toolbar: :hide,
-        hidden: { success: { view: :open, "slot[subframe]" => true } }
+    _render_related args.merge(
+      related: {
+        card: current_set_card,
+        view: :open,
+        slot: { rule_view: (args[:rule_view] || :common_rules) }
       }
-    render_related args.merge(
-      related: { card: card.structure, view: :edit, slot: slot_args }
     )
   end
 
-  def default_edit_structure_args args
-    args[:optional_toolbar] ||= :show
+  view :edit_structure, cache: :never do |args|
+    voo.show :toolbar
+    render_related args.merge(
+      related: {
+        card: card.structure,
+        view: :edit
+      }
+      # FIXME: this stuff:
+      #  slot: {
+      #    cancel_slot_selector: ".card-slot.related-view",
+      #    cancel_path: card.format.path(view: :edit), hide: :edit_toolbar,
+      #    hidden: { success: { view: :open, "slot[subframe]" => true } }
+      #  }
+      # }
+    )
   end
 
-  view :edit_nests do |args|
-    frame args do
+  view :edit_nests, cache: :never do
+    voo.show :toolbar
+    frame do
       with_nest_mode :edit do
-        process_nested_fields optional_toolbar: :hide
+        process_nested_fields hide: :toolbar
       end
     end
   end
-  def default_edit_nests_args args
-    args[:optional_toolbar] ||= :show
-  end
 
-  view :edit_nest_rules do |args|
+  view :edit_nest_rules, cache: :never do |args|
+    voo.show :toolbar
     view = args[:rule_view] || :field_related_rules
-    frame args do
+    frame do
       # with_nest_mode :edit do
-      nested_fields(args).map do |chunk|
-        nest Card.fetch("#{chunk.referee_name}+*self"),
-             view: :titled, title: chunk.referee_name, rule_view: view,
-             optional_set_label: :hide,
-             optional_rule_navbar: :show
+      nested_fields.map do |name, _options|
+        nest Card.fetch(name.to_name.trait(:self)),
+             view: :titled, title: name, rule_view: view,
+             hide: :set_label, show: :rule_navbar
       end
     end
   end
-
-  def default_edit_nest_rules_args args
-    args[:optional_toolbar] ||= :show
-  end
 end