card 1.19.6 → 1.20.0

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

@@ -1,184 +1,157 @@
 format :html do
-  def slot_options args
-    @@slot_option_keys ||=
-      Card::Content::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
-
-    options_hash[:subslot] = "true" if args[:subslot]
-
-    @@slot_option_keys.each_with_object(options_hash) do |opt, hash|
-      hash[opt] = args[opt] if args[opt].present?
-    end
-
-    JSON(options_hash)
-  end
 
   # Does two main things:
   # (1) gives CSS classes for styling and
   # (2) adds card data for javascript - including the "card-slot" class,
   #     which in principle is not supposed to be in styles
-  def wrap args={}
+  def wrap slot=true
     @slot_view = @current_view
-    classes = wrap_classes args
-    data = wrap_data args
-
-    div = content_tag :div, output(yield).html_safe,
-                      id: card.cardname.url_key,
-                      class: classes,
-                      data: data,
-                      style: h(args[:style])
-    add_debug_comments div
-  end
-
-  def add_debug_comments content
-    return content if params[:debug] != "slot" ||
-                      tagged(@current_view, :no_wrap_comments)
-    name = h card.name
-    space = "  " * @depth
-    "<!--\n\n#{space}BEGIN SLOT: #{name}\n\n-->" \
-    "#{div}" \
-    "<!--\n\n#{space}END SLOT: #{name}\n\n-->"
-  end
-
-  def wrap_classes args
-    [
-      ("card-slot" unless args[:no_slot]),
-      "#{@current_view}-view",
-      (args[:slot_class] if args[:slot_class]),
-      ("STRUCTURE-#{args[:structure].to_name.key}" if args[:structure]),
-      card.safe_set_keys
-    ].compact.join " "
-  end
-
-  def wrap_data args
-    {
-      "card-id" => card.id,
-      "card-name" => h(card.name),
-      "slot"      => html_escape_except_quotes(slot_options(args))
-    }
-  end
-
-  def wrap_body args={}
+    debug_slot do
+      wrap_with :div, yield, id: card.cardname.url_key,
+                             class: wrap_classes(slot),
+                             data:  wrap_data
+    end
+  end
+
+  def wrap_data
+    { "card-id"           => card.id,
+      "card-name"         => h(card.name),
+      "slot"              => slot_options }
+  end
+
+  def slot_options_json
+    html_escape_except_quotes JSON(slot_options)
+  end
+
+  def slot_options
+    options = voo.slot_options
+    name_context_slot_option options
+    options
+  end
+
+  def name_context_slot_option opts
+    return unless initial_context_names.present?
+    opts[:name_context] = initial_context_names.map(&:key) * ","
+  end
+
+  def debug_slot
+    debug_slot? ? debug_slot_wrap { yield } : yield
+  end
+
+  def debug_slot?
+    params[:debug] == "slot" && !tagged(@current_view, :no_wrap_comments)
+  end
+
+  def debug_slot_wrap
+    pre = "<!--\n\n#{'  ' * @depth}"
+    post = " SLOT: #{h card.name}\n\n-->"
+    [pre, "BEGIN", post, yield, pre, "END", post].join
+  end
+
+  def wrap_classes slot
+    list = ["card-slot", "#{@current_view}-view", card.safe_set_keys]
+    list.push "STRUCTURE-#{voo.structure.to_name.key}" if voo.structure
+    list.shift unless slot
+    classy list
+  end
+
+  def wrap_body
     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
+    css_classes += ["card-content", card.safe_set_keys] if @content_body
+    wrap_with :div, class: classy(*css_classes) do
+      yield
     end
   end
 
-  def panel args={}
-    wrap_with :div, class: "card-frame #{args[:panel_class]}" do
-      output(yield)
+  def panel
+    wrap_with :div, class: classy("card-frame") do
+      yield
     end
   end
 
-  def frame args={}, &block
-    if args[:subframe]
-      args.delete(:panel_class)
-      subframe args, &block
-    else
-      show_subheader =
-        show_view?(:toolbar, args.merge(default_visibility: :hide)) &&
-        @current_view != :related && @current_view != :open
-
-      wrap args do
-        [
-          _optional_render(:menu, args),
-          panel(args) do
-            [
-              _optional_render(:header, args, :show),
-              _optional_render(:subheader, args,
-                               (show_subheader ? :show : :hide)),
-              _optional_render(:help,
-                               args.merge(help_class: "alert alert-info"),
-                               :hide),
-              wrap_body(args) { output(yield(args)) }
-            ]
-          end
-        ]
-      end
+  def related_frame
+    voo.show :menu
+    wrap do
+      [
+        _render_menu,
+        _optional_render_subheader,
+        frame_help,
+        panel { wrap_body { yield } }
+      ]
     end
   end
 
-  def subframe args={}
-    wrap args do
+  def frame &block
+    method = show_related_frame? ? :related_frame : :standard_frame
+    send method, &block
+  end
+
+  def show_related_frame?
+    parent && parent.voo.ok_view == :related
+  end
+
+  def standard_frame
+    voo.hide :horizontal_menu, :help
+    wrap do
       [
-        _optional_render(:menu, args.merge(optional_horizontal_menu: :hide)),
-        _optional_render(:subheader, args, :show),
-        _optional_render(:help, args.merge(help_class: "alert alert-info"),
-                         :hide),
-        panel(args) do
+        _optional_render_menu,
+        panel do
           [
-            _optional_render(:header, args, :hide),
-            wrap_body(args) { output(yield args) }
+            _optional_render_header,
+            frame_help,
+            wrap_body { yield }
           ]
         end
       ]
     end
   end
 
-  def frame_and_form action, args={}, form_opts={}
-    form_opts.merge! args.delete(:form_opts) if args[:form_opts]
-    form_opts[:hidden] = args.delete(:hidden) if args[:hidden]
-    frame args do
+  def frame_help
+    # TODO: address these args
+    _optional_render :help, help_class: "alert alert-info"
+  end
+
+  def frame_and_form action, form_opts={}
+    frame do
       card_form action, form_opts do
-        output(yield args)
+        output yield
       end
     end
   end
 
   # alert_types: 'success', 'info', 'warning', 'danger'
-  def alert alert_type, args={}
-    css_class = "alert alert-#{alert_type} "
-    css_class += "alert-dismissible " if args[:dismissible]
-    css_class += args[:alert_class] if args[:alert_class]
-    close_button =
-      if args[:dismissible]
-        <<-HTML
-          <button type="button" class="close" data-dismiss="alert"
-                  aria-label="Close">
-            <span aria-hidden="true">&times;</span>
-          </button>
-        HTML
-      else
-        ""
-      end
-    content_tag :div, class: css_class, role: "alert" do
-      close_button + output(yield args)
+  def alert alert_type, dismissable=false
+    classes = ["alert", "alert-#{alert_type}"]
+    classes << "alert-dismissible " if dismissable
+
+    wrap_with :div, class: classy(classes), role: "alert" do
+      [(alert_close_button if dismissable), output(yield)]
+    end
+  end
+
+  def alert_close_button
+    wrap_with :button, type: "button", "data-dismiss" => "alert",
+                       class: "close", "aria-label" => "Close" do
+      wrap_with :span, "&times;", "aria-hidden" => true
     end
   end
 
-  def wrap_main content
-    return content if Env.ajax? || params[:layout] == "none"
-    %(<div id="main">#{content}</div>)
+  def wrap_main
+    return yield if Env.ajax? || params[:layout] == "none"
+    wrap_with :div, yield, id: "main"
   end
 
   def wrap_with tag, content_or_args={}, html_args={}
-    if block_given?
-      content_tag(tag, content_or_args) do
-        output(yield).html_safe
-      end
-    else
-      content_tag(tag, html_args) do
-        output(content_or_args).html_safe
-      end
-    end
+    content = block_given? ? yield : content_or_args
+    tag_args = block_given? ? content_or_args : html_args
+    content_tag(tag, tag_args) { output(content).to_s.html_safe }
   end
 
   def wrap_each_with tag, content_or_args={}, args={}
     content = block_given? ? yield(args) : content_or_args
     args    = block_given? ? content_or_args : args
     content.compact.map do |item|
-      wrap_with tag, args do
-        item
-      end
+      wrap_with(tag, args) { item }
     end.join "\n"
   end
 end

data/mod/standard/set/rstar/rules.rb

@@ -30,6 +30,10 @@ def rule_setting_name
   cardname.tag
 end
 
+def rule_setting_title
+  rule_setting_name.tr "*", ""
+end
+
 def rule_user_setting_name
   if is_preference?
     "#{rule_user_name}+#{rule_setting_name}"
@@ -46,49 +50,34 @@ def rule_user
   is_preference? ? self[-2] : nil
 end
 
-# ~~~~~~~~~~ determine the set options to which the user can apply the rule.
+# ~~~~~~~~~~ determine the set options to which a user can apply the rule.
 def set_options
-  first = if new_card?
-            0
-          else
-            set_prototype.set_names.index { |s| s.to_name.key == rule_set_key }
-          end
-  rule_cnt = 0
-  res = []
-  fallback_set = nil
-  set_prototype.set_names[first..-1].each do |set_name|
+  candidates = set_prototype.set_names
+  first = first_set_option_index candidates
+  tally = { existing: 0, options: [] }
+  candidates[first..-1].each do |set_name|
+    tally_set_option set_name, tally
+  end
+  tally[:options]
+end
+
+def tally_set_option set_name, tally
+  state =
     if Card.exists?("#{set_name}+#{rule_user_setting_name}")
-      rule_cnt += 1
-      res << if rule_cnt == 1
-               [set_name, :current]
-             else
-               fallback_set ||= set_name
-               [set_name, :overwritten]
-             end
+      tally[:existing] += 1
+      tally[:existing] == 1 ? :current : :overwritten
     else
-      res << (rule_cnt < 1 ? [set_name, :enabled] : [set_name, :disabled])
+      tally[:existing] < 1 ? :enabled : :disabled
     end
-  end
-
-  # fallback_set = if first > 0
-  #                 res[0..(first-1)].find do |set_name|
-  #                   Card.exists?("#{set_name}+#{rule_user_setting_name}")
-  #                 end
-  #               end
-  # last = res.index{|s| s.to_name.key == cardname.trunk_name.key} || -1
-  # # note, the -1 can happen with virtual cards because the self set doesn't
-  # show up in the set_names.  FIXME!!
-  # [res[first..last], fallback_set]
-  #
-  # The broadest set should always be the currently applied rule
-  # (for anything more general, they must explicitly choose to 'DELETE' the
-  # current one)
-  # the narrowest rule should be the one attached to the set being viewed.
-  # So, eg, if you're looking at the '*all plus' set, you shouldn't
-  # have the option to create rules based on arbitrary narrower sets, though
-  # narrower sets will always apply to whatever prototype we create
+  tally[:options] << [set_name, state]
+end
 
-  [res, fallback_set]
+# the narrowest rule should be the one attached to the set being viewed.
+# So, eg, if you're looking at the '*all plus' set, you shouldn't
+# have the option to create rules based on arbitrary narrower sets, though
+# narrower sets will always apply to whatever prototype we create
+def first_set_option_index candidates
+  new_card? ? 0 : candidates.index { |c| c.to_name.key == rule_set_key }
 end
 
 def set_prototype

data/mod/standard/set/rstar/rules_editor.rb

@@ -1,371 +1,392 @@
 format :html do
-  view :closed_rule, tags: :unknown_ok do
-    # these are helpful for handling non-rule rstar cards until we have real
-    # rule sets
-    return "not a rule" unless card.is_rule?
+  def current_rule force_reload=true
+    @current_rule = nil if force_reload
+    @current_rule ||= begin
+      rule = determine_current_rule
+      reload_rule rule
+    end
+  end
 
-    rule_card = find_current_rule_card
-    rule_content = closed_rule_content rule_card
-    known_or_missing = known_or_missing_rule rule_card
+  def determine_current_rule
+    existing = find_existing_rule_card
+    return existing if existing
+    Card.new name: "#{Card[:all].name}+#{card.rule_user_setting_name}"
+  end
 
-    cells = [
-      ["rule-setting", link_to_open_rule],
-      ["rule-content", rule_content_container(rule_content)],
-      ["rule-set", (rule_card ? rule_card.trunk.label : "")]
-    ].map do |css_class, cell_content|
-      wrap_rule_cell css_class, cell_content, known_or_missing
+  def open_rule_wrap rule_view
+    rule_view_class = rule_view.to_s.tr '_', '-'
+    wrap_with :tr, class: "card-slot open-rule #{rule_view_class}" do
+      wrap_with(:td, class: "rule-cell", colspan: 3) { yield }
     end
-    %(<tr class="card-slot closed-rule">#{cells.join "\n"}</tr>)
   end
 
-  def wrap_rule_cell css_class, cell_content, known_or_missing
-    %(
-      <td class="rule-cell #{css_class} #{known_or_missing}">
-        #{cell_content}
-      </td>
-    )
+  view :open_rule, cache: :never, tags: :unknown_ok do
+    return "not a rule" unless card.is_rule?
+    rule_view = open_rule_body_view
+    open_rule_wrap(rule_view) do
+      [open_rule_instruction,
+       open_rule_setting_links,
+       open_rule_body(rule_view)]
+    end
   end
 
-  def known_or_missing_rule rule_card
-    rule_card && !rule_card.new_card? ? "known-rule" : "missing-rule"
+  def open_rule_body rule_view
+    wrap_with :div, class: "card-body" do
+      nest current_rule, view: rule_view, rule_context: card
+    end
   end
 
-  def rule_content_container rule_content
-    %(
-      <div class="rule-content-container">
-        <span class="closed-content content">#{rule_content}</span>
-      </div>
-    )
+  def open_rule_body_view
+    return :show_rule if params[:success] && !params[:type_reload]
+    card_action = card.new_card? ? :create : :update
+    card.ok?(card_action) ? :edit_rule : :show_rule
   end
 
-  def link_to_open_rule
-    setting_title = card.cardname.tag.tr "*", ""
-    link_to_view :open_rule, setting_title, class: "edit-rule-link slotter"
+  view :show_rule, cache: :never, tags: :unknown_ok do
+    return "not a rule" unless card.is_rule?
+    return "No Current Rule" if card.new_card?
+
+    voo.items[:view] ||= :link
+    show_rule_set(card.rule_set) + _render_core
   end
 
-  def closed_rule_content rule_card
-    if rule_card
-      subformat(rule_card)._render_closed_content(
-        set_context: card.cardname.trunk_name
-      )
-    else
-      ""
+  def show_rule_set set
+    wrap_with :div, class: "rule-set" do
+      %(<label>Applies to</label> #{link_to_card set.cardname, set.label}:)
     end
   end
 
-  view :open_rule, tags: :unknown_ok do |args|
+  view :closed_rule, cache: :never, tags: :unknown_ok do
     return "not a rule" unless card.is_rule?
-    setting_name = args[:setting_name]
-    current_rule = args[:current_rule]
-
-    rule_view = open_rule_body_view
-    rule_view_args = { rule_context: card, set_context: card.rule_set_name }
-    body = subformat(current_rule)._render rule_view, rule_view_args
-
-    <<-HTML
-      <tr class="card-slot open-rule #{rule_view.to_s.sub '_', '-'}">
-        <td class="rule-cell" colspan="3">
-          <div class="rule-setting">
-            #{open_rule_setting_links setting_name}
-          </div>
-          <div class="alert alert-info rule-instruction">
-            #{open_rule_instruction setting_name}
-          </div>
-          <div class="card-body">
-            #{body}
-          </div>
-        </td>
-      </tr>
-    HTML
-  end
-
-  def open_rule_setting_links setting_name
-    setting_title = setting_name.tr "*", ""
-    closed_rule_link = link_to_view :closed_rule, setting_title,
-                                    class: "close-rule-link slotter"
-    all_rules_link = link_to_card setting_name, "all #{setting_title} rules",
-                                  class: "setting-link", target: "wagn_setting"
-    closed_rule_link + all_rules_link
-  end
-
-  def open_rule_instruction setting_name
-    process_content "{{#{setting_name}+*right+*help|content}}"
+    rule_card = find_existing_rule_card
+    wrap_closed_rule rule_card do
+      [:setting, :content, :set].map do |cell|
+        send "closed_rule_#{cell}_cell", rule_card
+      end
+    end
   end
 
-  def open_rule_body_view
-    return :show_rule if params[:success] && !params[:reload]
-    card_action = card.new_card? ? :create : :update
-    return :show_rule unless card.ok? card_action
-    :edit_rule
+  def closed_rule_setting_cell _rule_card
+    wrap_rule_cell "rule-setting" do
+      link_to_open_rule
+    end
   end
 
-  def reload_current_rule current_rule
-    return current_rule unless (card_args = params[:card])
-    if card_args[:name] && card_args[:name].to_name.key != current_rule.key
-      Card.new card_args
-    else
-      current_rule = current_rule.refresh
-      current_rule.assign_attributes card_args
-      current_rule.include_set_modules
+  def closed_rule_content_cell rule_card
+    wrap_rule_cell "rule-content" do
+      rule_content_container { closed_rule_content rule_card }
     end
   end
 
-  def default_open_rule_args args
-    current_rule = find_current_rule_card || begin
-      Card.new name: "#{Card[:all].name}+#{card.rule_user_setting_name}"
+  def closed_rule_set_cell rule_card
+    wrap_rule_cell "rule-set" do
+      rule_card ? rule_card.trunk.label : ""
     end
-    current_rule = reload_current_rule current_rule
-    args.reverse_merge! current_rule: current_rule,
-                        setting_name: card.rule_setting_name
   end
 
-  view :show_rule, tags: :unknown_ok do |args|
-    return "not a rule" unless card.is_rule?
+  def wrap_closed_rule rule_card
+    klass = rule_card && rule_card.real? ? "known-rule" : "missing-rule"
+    wrap_with(:tr, class: "card-slot closed-rule #{klass}") { yield }
+  end
 
-    if !card.new_card?
-      set = card.rule_set
-      args[:item] ||= :link
-      %(
-        <div class="rule-set">
-        <label>Applies to</label> #{link_to_card set.cardname, set.label}:
-        </div>
-        #{_render_core args}
-      )
-    else
-      "No Current Rule"
-    end
+  def wrap_rule_cell css_class
+    wrap_with(:td, class: "rule-cell #{css_class}") { yield }
   end
 
-  view :edit_rule, tags: :unknown_ok do |args|
-    return "not a rule" unless card.is_rule?
-    form_args = {
-      url: path(action: :update, no_mark: true),
-      html: { class: "card-form card-rule-form" }
-    }
-    if args[:remote]
-      form_args[:remote] = true
-      form_args[:html][:class] += " slotter"
+  def rule_content_container
+    wrap_with :div, class: "rule-content-container" do
+      wrap_with(:span, class: "closed-content content") { yield }
     end
+  end
 
-    form_for card, form_args do |form|
-      @form = form
-      %(
-        #{hidden_success_formgroup args[:success]}
-        #{editor args}
-        #{edit_buttons args}
-      )
+  def link_to_open_rule
+    setting_title = card.cardname.tag.tr "*", ""
+    link_to_view :open_rule, setting_title, class: "edit-rule-link slotter"
+  end
+
+  def closed_rule_content rule_card
+    return "" unless rule_card
+    nest rule_card, view: :closed_content,
+                    set_context: card.cardname.trunk_name
+  end
+
+  def open_rule_setting_links
+    wrap_with :div, class: "rule-setting" do
+      [link_to_closed_rule, link_to_all_rules]
     end
   end
 
-  view :edit_single_rule do |args|
-    %(<div class="edit-single-rule panel-body">#{render_edit_rule args}</div>)
+  def link_to_all_rules
+    link_to_card card.rule_setting_name, "all #{card.rule_setting_title} rules",
+                 class: "setting-link", target: "wagn_setting"
   end
 
-  def default_edit_rule_args args
-    args[:remote] ||= true
-    args[:rule_context] ||= card
-    args[:set_context] ||= card.rule_set_name
-    args[:set_selected] = params[:type_reload] ? card.rule_set_name : false
-    args[:set_options], args[:fallback_set] = args[:rule_context].set_options
+  def link_to_closed_rule
+    link_to_view :closed_rule, card.rule_setting_title,
+                 class: "close-rule-link slotter"
+  end
 
-    args[:success] ||= {}
-    args[:success].reverse_merge!(
-      card: args[:rule_context],
-      id:   args[:rule_context].cardname.url_key,
-      view: "open_rule",
-      item: "view_rule"
-    )
-    edit_rule_button_args args
-  end
-
-  def edit_rule_button_args args
-    args[:delete_button] ||= delete_button args
-    args[:cancel_button] ||=
-      begin
-        cancel_view = card.new_card? ? :closed_rule : :open_rule
-        cancel_button class: "rule-cancel-button",
-                      href: path(view: cancel_view, success: false)
-      end
+  def open_rule_instruction
+    wrap_with :div, class: "alert alert-info rule-instruction" do
+      process_content "{{#{card.rule_setting_name}+*right+*help|content}}"
+    end
   end
 
-  def default_edit_single_rule_args args
-    args[:remote] ||= false
-    args[:success] ||= {
-      card: args[:parent] || card,
-      id: (args[:parent] && args[:parent].cardname.url_key) ||
-          card.cardname.url_key,
-      view: :open,
-      item: nil
-    }
-    default_edit_rule_args args
-    edit_single_rule_button_args args
+  def reload_rule rule
+    return rule unless (card_args = params[:card])
+    if card_args[:name] && card_args[:name].to_name.key != rule.key
+      Card.new card_args
+    else
+      rule = rule.refresh
+      rule.assign_attributes card_args
+      rule.include_set_modules
+    end
   end
 
-  def edit_single_rule_button_args args
-    args[:delete_button] = delete_button args, ".card-slot.related-view"
+  view :edit_rule, cache: :never, tags: :unknown_ok do |args|
+    return "not a rule" unless card.is_rule?
+    @rule_context = args[:rule_context] || card
+    @edit_rule_success = edit_rule_success
+    action_args = { action: :update, no_mark: true }
+
+    card_form action_args, class: "card-rule-form" do |_form|
+      [hidden_tags(success: @edit_rule_success),
+       editor,
+       edit_rule_buttons].join
+    end
+  end
 
-    args[:cancel_button] =
-      link_to_card args[:success][:id], "Cancel",
-                   class: "rule-cancel-button btn btn-default",
-                   path: { view: args[:success][:view] }
+  def edit_rule_success
+    { id:   @rule_context.cardname.url_key,
+      view: "open_rule",
+      item: "view_rule" }
+  end
+
+  def edit_rule_buttons
+    wrap_with(:div, class: "button-area") do
+      [
+        edit_rule_delete_button,
+        edit_rule_submit_button,
+        edit_rule_cancel_button
+      ]
+    end
   end
 
-  def delete_button args, slot_selector=nil
+  def edit_rule_delete_button args={}
     return if card.new_card?
-    b_args = {
-      remote: true, class: "rule-delete-button slotter", type: "button"
-    }
-    b_args["data-slot-selector"] = slot_selector if slot_selector
-    b_args[:href] = path action: :delete, success: args[:success]
-    if (fset = args[:fallback_set]) && (fcard = Card.fetch(fset))
-      b_args["data-confirm"] =
-        "Deleting will revert to #{card.rule_setting_name} rule for " \
-        "#{fcard.label}"
+    options = { remote: true,
+                type: "button",
+                class: "rule-delete-button slotter",
+                href: path(action: :delete, success: @edit_rule_success) }
+    options["data-slot-selector"] = slot_selector if args[:slot_selector]
+    delete_button_confirmation_option options, args[:fallback_set]
+    wrap_with :span, class: "rule-delete-section" do
+      button_tag "Delete", options
     end
-    %(<span class="rule-delete-section">#{button_tag 'Delete', b_args}</span>)
   end
 
-  # used keys for args:
-  # :success,  :set_selected, :set_options, :rule_context
-  def editor args
-    content = content_field(form, args.merge(skip_rev_id: true))
+  def delete_button_confirmation_option options, fallback_set
+    return unless fallback_set && (fallback_set_card = Card.fetch fallback_set)
+    setting = card.rule_setting_name
+    options["data-confirm"] = "Deleting will revert to #{setting} rule "\
+                              "for #{fallback_set_card.label}"
+  end
+
+  def edit_rule_submit_button
+    submit_button class: "rule-submit-button"
+  end
+
+  def edit_rule_cancel_button
+    cancel_view = card.new_card? ? :closed_rule : :open_rule
+    cancel_button class: "rule-cancel-button",
+                  href: path(view: cancel_view, success: false)
+  end
+
+  def editor
     wrap_with(:div, class: "card-editor") do
-      [
-        (type_formgroup(args) if card.right.rule_type_editable),
-        formgroup("rule", content, editor: "content"),
-        set_selection(args)
-      ]
+      [rules_type_formgroup,
+       rule_content_formgroup,
+       rule_set_selection].compact
     end
   end
 
-  def type_formgroup args
-    content = type_field(
-      href: path(name: args[:success][:card].name,
-                 view: args[:success][:view],
-                 type_reload: true),
-      class: "type-field rule-type-field live-type-field",
-      "data-remote" => true
-    )
-    formgroup "type", content, editor: "type"
+  def rules_type_formgroup
+    return unless card.right.rule_type_editable
+    success = @edit_rule_success
+    wrap_type_formgroup do
+      type_field(
+        href: path(mark: success[:id], view: success[:view], type_reload: true),
+        class: "type-field rule-type-field live-type-field",
+        "data-remote" => true
+      )
+    end
   end
 
-  def hidden_success_formgroup args
-    %(
-      #{hidden_field_tag 'success[id]', args[:id] || args[:card].name}
-      #{hidden_field_tag 'success[view]', args[:view]}
-      #{hidden_field_tag 'success[item]', args[:item]}
-    )
+  def rule_content_formgroup
+    formgroup "rule", editor: "content" do
+      content_field true
+    end
   end
 
-  def set_selection args
-    wrap_with(:div, class: "row") do
-      [
-        set_formgroup(args),
-        related_set_formgroup(args)
-      ]
+  def rule_set_selection
+    wrap_with :div, class: "row" do
+      [rule_set_formgroup,
+       related_set_formgroup]
     end
   end
 
-  def set_formgroup args
-    tag = args[:rule_context].rule_user_setting_name
-    narrower_rules = []
+  # def default_edit_rule_args args
+  #   args[:set_context] ||= card.rule_set_name
+  # end
+
+  def rule_set_formgroup
+    tag = @rule_context.rule_user_setting_name
+    narrower = []
     option_list "set" do
-      args[:set_options].map do |set_name, state|
-        set_radio_button set_name, tag, state, narrower_rules,
-                         checked: checked_set_button?(set_name, args)
+      rule_set_options.map do |set_name, state|
+        rule_set_radio_button set_name, tag, state, narrower
       end
     end
   end
 
-  def set_radio_button set_name, tag, state, narrower_rules, opts
-    button = radio_button :name, "#{set_name}+#{tag}",
-                          checked: opts[:checked],
-                          warning: narrower_rule_warning(narrower_rules)
-    label = Card.fetch(set_name).label
-    if state.in? [:current, :overwritten]
-      narrower_rules << label
-      narrower_rules.last[0] = narrower_rules.last[0].downcase
+  def rule_set_options
+    @rule_set_options ||= @rule_context.set_options
+  end
+
+  def selected_rule_set
+    if @rule_set_options.length == 1 then true
+    elsif params[:type_reload]       then card.rule_set_name
+    else                                  false
+    end
+  end
+
+  def rule_set_radio_button set_name, tag, state, narrower
+    warning = narrower_rule_warning narrower, state, set_name
+    checked = checked_set_button? set_name, selected_rule_set
+    rule_radio set_name, state do
+      radio_text = "#{set_name}+#{tag}"
+      radio_button :name, radio_text, checked: checked, warning: warning
     end
-    button + set_label(card, set_name, label, state)
   end
 
-  def checked_set_button? set_name, args
-    (args[:set_selected] == set_name) ||
-      (current_set_key && args[:set_options].length == 1)
+  def narrower_rule_warning narrower_rules, state, set_name
+    return unless state.in? [:current, :overwritten]
+    narrower_rules << Card.fetch(set_name).uncapitalized_label
+    return unless state == :overwritten
+    narrower_rule_warning_message narrower_rules
+  end
+
+  def narrower_rule_warning_message narrower_rules
+    plural = narrower_rules.size > 1 ? "s" : ""
+    "This rule will not have any effect on this card unless you delete " \
+    "the narrower rule#{plural} for #{narrower_rules.to_sentence}."
+  end
+
+  def checked_set_button? set_name, selected
+    [set_name, true].include? selected
   end
 
   def current_set_key
-    card.new_card? ? Card[:all].cardname.key : card.rule_set_key
+    card.new_card? ? Card.quick_fetch(:all).cardname.key : card.rule_set_key
   end
 
-  def related_set_formgroup args
-    related_sets = args[:set_context] &&
-                   Card.fetch(args[:set_context]).prototype.related_sets
-    return "" unless related_sets && related_sets.size > 0
-    tag = args[:rule_context].rule_user_setting_name
+  def related_set_formgroup
+    related_sets = related_sets_in_context
+    return "" unless related_sets && !related_sets.empty?
+    tag = @rule_context.rule_user_setting_name
     option_list "related set" do
-      related_sets.map do |set_name, label|
-        rule_name = "#{set_name}+#{tag}"
-        rule_card = Card.fetch rule_name, skip_modules: true
-        state = (rule_card && :exists)
-        radio_button(:name, rule_name) +
-          set_label(card, set_name, label, state)
-      end
+      related_rule_radios related_sets, tag
     end
   end
 
-  def set_label card, set_name, label, state
-    label_class = "set-label"
-    label_body = link_to_card set_name, label, target: "wagn_set"
-    info =
-      case state
-      when :current
-        label_class += " current-set_label"
-        "(current)"
-      when :overwritten, :exists
-        link_to_card "#{set_name}+#{card.rule_user_setting_name}", "(#{state})"
+  def related_sets_in_context
+    set_context = @rule_context.rule_set_name
+    set_context && Card.fetch(set_context).prototype.related_sets
+  end
+
+  def related_rule_radios related_sets, tag
+    related_sets.map do |set_name, _label|
+      rule_name = "#{set_name}+#{tag}"
+      state = Card.exists?(rule_name) ? :exists : nil
+      rule_radio set_name, state do
+        radio_button :name, rule_name
       end
-    label_body += " <em>#{info}</em>".html_safe if info
-    %(<label class="#{label_class}">#{label_body}</label>).html_safe
+    end
   end
 
-  def narrower_rule_warning narrower_rules
-    return unless narrower_rules.present?
-    plural = narrower_rules.size > 1 ? "s" : ""
-    "This rule will not have any effect on this card unless you delete " \
-    "the narrower rule#{plural} for #{narrower_rules.to_sentence}."
+  def rule_radio set_name, state
+    label_classes = ["set-label", ("current-set-label" if state == :current)]
+    icon = glyphicon "question-sign", "link-muted"
+    wrap_with :label, class: label_classes.compact.join(" ") do
+      [yield,
+       rule_radio_label(set_name, state),
+       link_to_card(set_name, icon, target: "wagn_set")]
+    end
   end
 
-  def option_list title
-    list = wrap_each_with(:li, class: "radio") { yield }
-    formgroup title, "<ul>#{list}</ul>", editor: "set", class: "col-xs-6"
+  def rule_radio_label set_name, state
+    label = Card.fetch(set_name).label
+    extra_info = extra_rule_radio_info state, set_name
+    label += " <em>#{extra_info}</em>".html_safe if extra_info
+    label
   end
 
-  def edit_buttons  args
-    wrap_with(:div, class: "button-area") do
-      [
-        args[:delete_button],
-        button_tag("Submit", class: "rule-submit-button", situation: "primary"),
-        args[:cancel_button]
-      ]
+  def extra_rule_radio_info state, set_name
+    case state
+    when :current
+      "(current)"
+    when :overwritten, :exists
+      link_to_card "#{set_name}+#{card.rule_user_setting_name}", "(#{state})"
     end
   end
 
-  # view :edit_rule2 do |args|
-  #
-  #   card_form :update do
-  #     [
-  #       _optional_render(:type_formgroup,    args),
-  #       _optional_render(:content_formgroup, args),
-  #       _optional_render(:set_formgroup,     args),
-  #       _optional_render(:button_formgroup,  args)
-  #     ]
-  #   end
-  # end
+  def option_list title
+    formgroup title, editor: "set", class: "col-xs-6" do
+      wrap_with :ul do
+        wrap_each_with(:li, class: "radio") { yield }
+      end
+    end
+  end
+
+
+
+
+
+
+
+
+
+
+
+  view :edit_single_rule, cache: :never do |args|
+    %(<div class="edit-single-rule panel-body">#{render_edit_rule args}</div>)
+  end
+
+  def default_edit_single_rule_args args
+    args[:remote] ||= false
+    args[:success] ||= {
+      card: args[:parent] || card,
+      id: (args[:parent] && args[:parent].cardname.url_key) ||
+          card.cardname.url_key,
+      view: :open,
+      item: nil
+    }
+    default_edit_rule_args args
+    edit_single_rule_button_args args
+  end
+
+  def edit_single_rule_button_args args
+    args[:delete_button] = delete_button args, ".card-slot.related-view"
+
+    args[:cancel_button] =
+      link_to_card args[:success][:id], "Cancel",
+                   class: "rule-cancel-button btn btn-default",
+                   path: { view: args[:success][:view] }
+  end
 
   private
 
-  def find_current_rule_card
+  def find_existing_rule_card
     # self.card is a POTENTIAL rule; it quacks like a rule but may or may not
     # exist.
     # This generates a prototypical member of the POTENTIAL rule's set