format :html do
def current_rule force_reload=true
@current_rule = nil if force_reload
@current_rule ||= begin
rule = determine_current_rule
reload_rule rule
end
end
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
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
end
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 open_rule_body rule_view
wrap_with :div, class: "card-body" do
nest current_rule, view: rule_view, rule_context: card
end
end
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
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 show_rule_set set
wrap_with :div, class: "rule-set" do
%( #{link_to_card set.cardname, set.label}:)
end
end
view :closed_rule, cache: :never, tags: :unknown_ok do
return "not a rule" unless card.is_rule?
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 closed_rule_setting_cell _rule_card
wrap_rule_cell "rule-setting" do
link_to_open_rule
end
end
def closed_rule_content_cell rule_card
wrap_rule_cell "rule-content" do
rule_content_container { closed_rule_content rule_card }
end
end
def closed_rule_set_cell rule_card
wrap_rule_cell "rule-set" do
rule_card ? rule_card.trunk.label : ""
end
end
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
def wrap_rule_cell css_class
wrap_with(:td, class: "rule-cell #{css_class}") { yield }
end
def rule_content_container
wrap_with :div, class: "rule-content-container" do
wrap_with(:span, class: "closed-content content") { yield }
end
end
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
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 link_to_closed_rule
link_to_view :closed_rule, card.rule_setting_title,
class: "close-rule-link slotter"
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 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
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
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 edit_rule_delete_button args={}
return if card.new_card?
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
end
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
[rules_type_formgroup,
rule_content_formgroup,
rule_set_selection].compact
end
end
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 rule_content_formgroup
formgroup "rule", editor: "content" do
content_field true
end
end
def rule_set_selection
wrap_with :div, class: "row" do
[rule_set_formgroup,
related_set_formgroup]
end
end
# 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
rule_set_options.map do |set_name, state|
rule_set_radio_button set_name, tag, state, narrower
end
end
end
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
end
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.quick_fetch(:all).cardname.key : card.rule_set_key
end
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_rule_radios related_sets, tag
end
end
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
end
end
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 rule_radio_label set_name, state
label = Card.fetch(set_name).label
extra_info = extra_rule_radio_info state, set_name
label += " #{extra_info}".html_safe if extra_info
label
end
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
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, tags: :unknown_ok, cache: :never do
frame() { render_edit_rule }
end
private
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
# and returns that member's ACTUAL rule for the POTENTIAL rule's setting
if card.new_card?
if (setting = card.right)
card.set_prototype.rule_card setting.codename, user: card.rule_user
end
else
card
end
end
end