card 1.98.0 → 1.99.1

data/mod/rules/set/rule/bridge_rules_editor.rb

@@ -14,20 +14,15 @@ format :html do
     edit_rule_title
   end
 
-  view :overlay_rule_help, unknown: true, perms: :none, cache: :never do
-    # wrap_with :div, class: "help-text rule-instruction d-flex justify-content-between"
-    # do
-
-    # output [wrap_with(:div, rule_based_help), setting_link]
-    # end
-    popover_link([rule_based_help, setting_link].join(" "))
+  view :help_text, unknown: true, cache: :never do
+    wrap_help_text [rule_based_help, setting_link].join(" ")
   end
 
   def setting_link
     wrap_with :div, class: "ml-auto" do
-      # FIXME: hardcoded count
-      link_to_card card.rule_setting_name, " (37 #{card.rule_setting_title} rules)",
-                   class: "text-muted", target: "wagn_setting"
+      link_to_card card.rule_setting_name,
+                  " (#{card.rule_setting.count} #{card.rule_setting_title} rules)",
+                   class: "text-muted"
     end
   end
 end

data/mod/rules/set/rule/editor.rb

@@ -1,19 +1,11 @@
 format :html do
   attr_accessor :rule_context
 
-  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}"
+  view :rule_edit, cache: :never, unknown: true,
+                   wrap: { modal: { size: :large,
+                                    title: :edit_rule_title,
+                                    footer: "" } } do
+    current_rule_form form_type: :modal
   end
 
   view :rule_help, unknown: true, perms: :none, cache: :never do
@@ -22,62 +14,6 @@ format :html do
     end
   end
 
-  view :show_rule, cache: :never, unknown: true do
-    return "No Current Rule" if card.new_card?
-
-    voo.items[:view] ||= :link
-    output [
-      show_rule_set(card.rule_set),
-      _render_core
-    ]
-  end
-
-  def show_rule_set set
-    wrap_with :div, class: "rule-set" do
-      %(<label>Applies to</label> #{link_to_card set.name, set.label}:)
-    end
-  end
-
-  view :quick_edit, unknown: true, template: :haml, wrap: :slot do
-    setting_title + short_help_text + quick_editor
-  end
-
-  def quick_form
-    card_form :update,
-              "data-slot-selector": ".set-info.card-slot",
-              success: { view: :quick_edit_success }  do
-      quick_editor
-    end
-  end
-
-  def set_info notify_change=nil
-    wrap true, class: "set-info" do
-      haml :set_info, notify_change: notify_change
-    end
-  end
-
-  def undo_button
-    link_to "undo", method: :post, rel: "nofollow", class: "btn btn-secondary ml-2 btn-sm btn-reduced-padding slotter",
-                    remote: true,
-                    "data-slot-selector": ".card-slot.quick_edit-view",
-                    path: { action: :update,
-                            revert_actions: [card.last_action_id],
-                            revert_to: :previous }
-  end
-
-  view :quick_edit_success do
-    set_info true
-  end
-
-  def quick_editor
-    if card.right.codename == :default
-      @edit_rule_success = {}
-      rules_type_formgroup
-    else
-      rule_content_formgroup
-    end
-  end
-
   view :rule_bridge_link, unknown: true do
     opts = bridge_link_opts(class: "edit-rule-link nav-link",
                             "data-toggle": "pill",
@@ -86,57 +22,37 @@ format :html do
     link_to_view(:overlay_rule, (setting_title + short_help_text), opts)
   end
 
-  def setting_title
-    card.name.tag.tr "*", ""
-  end
-
-  def short_help_text
-    "<div class=\"help-text\">#{card.short_help_text}</div>"
-  end
-
-  def rule_content_container
-    wrap_with :div, class: "rule-content-container" do
-      wrap_with(:span, class: "closed-content content") { yield }
-    end
+  def edit_link_view
+    :rule_edit
   end
 
-  def link_to_open_rule
-    setting_title = card.name.tag.tr "*", ""
-    link_to_view :open_rule, setting_title, class: "edit-rule-link"
-  end
-
-  def closed_rule_content rule_card
-    return "" unless rule_card
-
-    nest rule_card, { view: :closed_content }, set_context: card.name.trunk_name
+  def edit_rule_title
+    output [
+      wrap_with(:h5, setting_title, class: "title font-weight-bold")
+      # render_overlay_rule_help
+    ]
   end
 
-  def open_rule_setting_links
-    wrap_with :div, class: "rule-setting" do
-      [link_to_closed_rule, link_to_all_rules]
+  def current_rule
+    if params[:assign]
+      card
+    elsif (existing = find_existing_rule_card)
+      existing
+    else
+      card
     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"
+  def quick_editor
+    rule_content_formgroup
   end
 
-  def link_to_closed_rule
-    link_to_view :closed_rule, card.rule_setting_title,
-                 class: "close-rule-link"
+  def setting_title
+    card.name.tag.tr "*", ""
   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
+  def short_help_text
+    "<div class=\"help-text\">#{card.short_help_text}</div>"
   end
 
   def rule_set_description
@@ -149,7 +65,7 @@ format :html do
     success = @edit_rule_success
     wrap_type_formgroup do
       type_field(
-        href: path(mark: success[:id], view: success[:view], type_reload: true),
+        href: path(mark: success[:id], view: :rule_form, assign: true),
         class: "type-field rule-type-field live-type-field",
         "data-remote" => true
       )
@@ -157,15 +73,26 @@ format :html do
   end
 
   def rule_content_formgroup
-    formgroup "content", editor: "content", help: false do
-      content_field true
-    end
+    _render_content_formgroup hide: :conflict_tracker
   end
 
   def current_set_key
     card.new_card? ? Card.quick_fetch(:all).name.key : card.rule_set_key
   end
 
+  def left_type_for_nest_editor_set_selection
+    return super unless card.is_template?
+
+    case Card.fetch_id(card.rule_set_pattern_name) # set_pattern_id
+    when TypeID
+      card.rule_set.anchor_name
+    when SelfID
+      card.rule_set.anchor.type_name
+    else
+      super
+    end
+  end
+
   private
 
   def find_existing_rule_card

data/mod/rules/set/rule/html_views.rb

@@ -0,0 +1,13 @@
+format :html do
+  view :core do
+    # Rule cards that are searches are usual right structures and refer to the left
+    # in the search query. In that case the search doesn't work
+    # properly in the context of the rule card itself.  Hence we show the query syntax
+    # and not the search result.
+    if card.type_id == Card::SearchTypeID
+      render_raw
+    else
+      super()
+    end
+  end
+end

data/mod/rules/set/rule/quick_editor.rb

@@ -0,0 +1,39 @@
+format :html do
+  view :quick_edit, unknown: true, wrap: :slot do
+    quick_edit
+  end
+
+  view :quick_edit_success do
+    set_info true
+  end
+
+  def quick_edit
+    haml :quick_edit
+  end
+
+  def quick_form
+    card_form :update, quick_form_opts do
+      quick_editor
+    end
+  end
+
+  def quick_form_opts
+    { "data-slot-selector": ".set-info.card-slot",
+      success: { view: :quick_edit_success } }
+  end
+
+  def set_info notify_change=nil
+    wrap true, class: "set-info" do
+      haml :set_info, notify_change: notify_change
+    end
+  end
+
+  def undo_button
+    link_to "undo", method: :post, rel: "nofollow", class: "btn btn-secondary ml-2 btn-sm btn-reduced-padding slotter",
+                    remote: true,
+                    "data-slot-selector": ".card-slot.quick_edit-view",
+                    path: { action: :update,
+                            revert_actions: [card.last_action_id],
+                            revert_to: :previous }
+  end
+end

data/mod/rules/set/rule/{editor → quick_editor}/set_info.haml

@@ -1,6 +1,6 @@
 .form-group.form-control-feedback
   %label
-    set
+    Set
   %p.text-muted
     = find_existing_rule_card&.left&.label || "--"
   - if notify_change

data/mod/rules/set/rule/rule_form/buttons.rb

@@ -19,7 +19,9 @@ format :html do
 
     delete_opts = {
       confirm: delete_confirm(args[:fallback_set]),
-      success: @edit_rule_success,
+      # success: @edit_rule_success,
+      no_success: true,
+      "data-slotter-mode": "silent-success",
       class: "_close-#{form_type}-on-success"
     }
     delete_opts["data-slot-selector"] = slot_selector if args[:slot_selector]

data/mod/rules/set/rule/rule_form/form_elements.rb

@@ -10,7 +10,7 @@ format :html do
   def rule_set_formgroup
     tag = @rule_context.rule_user_setting_name
     narrower = []
-    option_list "set" do
+    option_list "Set" do
       rule_set_options.map do |set_name, state|
         rule_set_radio_button set_name, tag, state, narrower
       end
@@ -33,7 +33,7 @@ format :html do
   end
 
   def option_list title
-    formgroup title, editor: "set", class: "col-xs-6", help: false do
+    formgroup title, input: "set", class: "col-xs-6", help: false do
       wrap_with :ul do
         wrap_each_with(:li, class: "radio") { yield }
       end

data/mod/rules/set/rule/rule_form/rule_set_radio.rb

@@ -18,7 +18,7 @@ class RuleSetRadio
 
     rule_radio do
       radio_text = "#{@set_name}+#{@tag}"
-      radio_button :name, radio_text, checked: checked?, warning: warning
+      radio_button :name, radio_text, checked: false, warning: warning
     end
   end
 
@@ -51,14 +51,11 @@ class RuleSetRadio
     when :current
       "(current)"
     when :overwritten, :exists
-      link_to_card "#{@set_name}+#{@card.rule_user_setting_name}", "(#{@state})"
+      link_to_card "#{@set_name}+#{@card.rule_user_setting_name}", "(#{@state})",
+                   target: "_blank"
     end
   end
 
-  def checked?
-    [@set_name, true].include? @format.selected_rule_set
-  end
-
   def warning
     if @set_name == "*all"
       "This rule will affect all cards! Are you sure?"

data/mod/rules/set/rule/rule_form/set_selection.rb

@@ -9,16 +9,16 @@ format :html do
     tag = @rule_context.rule_user_setting_name
     narrower = []
 
-    bridge_option_list "set" do
+    bridge_option_list "Set" do
       rule_set_options.map do |set_name, state|
         RuleSetRadio.new(self, set_name, tag, state).html narrower
       end
     end
   end
 
-  def bridge_option_list _title
+  def bridge_option_list title
     index = -1
-    formgroup "", editor: "set", class: "col-xs-6", help: false do
+    formgroup title, input: "set", class: "col-xs-6", help: false do
       yield.inject("") do |res, radio|
         index += 1
         # TODO
@@ -36,11 +36,4 @@ format :html do
   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
 end

data/mod/rules/set/rule/rules.rb

@@ -1,4 +1,5 @@
-event :save_recently_edited_settings, :integrate, on: :save do
+event :save_recently_edited_settings, :integrate,
+      on: :save, changed: %i[type content] do
   if (recent = Card[:recent_settings])
     recent.insert_item 0, name.right
     attach_subcard recent
@@ -17,6 +18,10 @@ def rule_set_name
   end
 end
 
+def rule_set_pattern_name
+  rule_set_name.tag_name
+end
+
 def rule_set
   if is_preference?
     self[0..-3]
@@ -25,6 +30,10 @@ def rule_set
   end
 end
 
+def rule_setting
+  right
+end
+
 def rule_setting_name
   name.tag
 end

data/mod/rules/set/type/set.rb

@@ -1,33 +1,41 @@
 include_set Type::SearchType
 
+def anchor_name
+  name.left_name
+end
+
+def anchor
+  Card[anchor_name]
+end
+
+def pattern_name
+  name.tag_name
+end
+
+def pattern
+  tag
+end
+
 def inheritable?
-  return true if junction_only?
+  junction_only? || (anchor_name&.junction? && self_set?)
+end
 
-  name.trunk_name.junction? &&
-    name.tag_name.key == Card::Set::Self.pattern.key
+def self_set?
+  pattern_name == Card::Set::Self.pattern.key
 end
 
 def subclass_for_set
-  current_set_pattern_code = tag.codename
-  Card.set_patterns.find do |set|
-    current_set_pattern_code == set.pattern_code
-  end
+  current_set_pattern_code = pattern.codename
+  Card.set_patterns.find { |set| set.pattern_code == current_set_pattern_code }
 end
 
 def junction_only?
-  if @junction_only.nil?
-    @junction_only = subclass_for_set.junction_only
-  else
-    @junction_only
-  end
+  @junction_only.nil? ? (@junction_only = subclass_for_set.junction_only) : @junction_only
 end
 
 def label
-  if (klass = subclass_for_set)
-    klass.label name.left
-  else
-    ""
-  end
+  klass = subclass_for_set
+  klass ? klass.label(anchor_name) : ""
 end
 
 def uncapitalized_label
@@ -56,11 +64,12 @@ def visible_setting_codenames
   @visible_setting_codenames ||= visible_settings.map(&:codename)
 end
 
-def visible_settings group=nil
+def visible_settings group=nil, cardtype_id=nil
+  cardtype_id ||= prototype.type_id
   settings =
     (group && Card::Setting.groups[group]) || Card::Setting.groups.values.flatten.compact
   settings.reject do |setting|
-    !setting || !setting.applies_to_cardtype(prototype.type_id)
+    !setting || !setting.applies_to_cardtype(cardtype_id)
   end
 end
 
@@ -69,10 +78,18 @@ def broader_sets
 end
 
 def prototype
-  opts = subclass_for_set.prototype_args name.trunk_name
+  opts = subclass_for_set.prototype_args anchor_name
   Card.fetch opts[:name], new: opts
 end
 
+def prototype_default_type_id
+  prototype_default_card.type_id
+end
+
+def prototype_default_card
+  prototype.rule_card(:default)
+end
+
 def related_sets with_self=false
   if subclass_for_set.anchorless?
     prototype.related_sets with_self