card 1.98.3 → 1.99.0

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

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

@@ -4,29 +4,25 @@ format :html do
   end
 
   view :core, cache: :never do
-    table_rules_filter + _render_rules_table
+    filtered_rule_list :bar_rule_list
   end
 
-  view :rules_table, cache: :never do
-    rules_table setting_list(setting_group)
+  view :nest_rules, cache: :never, unknown: true, wrap: :slot do
+    filtered_rule_list :quick_edit_rule_list, :field_related_rules, :related, mark: ""
   end
 
-  def table_rules_filter
-    form_tag path(view: :rules_table, slot: { show: :content }),
-             remote: true, method: "get", role: "filter",
-             "data-slot-selector": ".card-slot.rules-table",
-             class: classy("nodblclick slotter form-inline slim-select2 m-2") do
-      output [
-        label_tag(:view, icon_tag("filter_list"), class: "mr-2"),
-        setting_select,
-        content_tag(:span, "rules that apply to #{_render_set_label}".html_safe,
-                    class: "mx-2 small")
-      ]
-    end
+  view :modal_nest_rules, cache: :never, unknown: true,
+                          wrap: { modal: { title: "Rules for nest" } } do
+    filtered_rule_list :quick_edit_rule_list, :field_related_rules, :self
+  end
+
+  view :bridge_rules_tab, cache: :never do
+    filtered_rule_list :pill_rule_list, :common, :related, mark: ""
   end
 
-  def setting_group
-    voo&.filter&.to_sym || params[:group]&.to_sym || :common
+  def filtered_rule_list view, *filter_args
+    [rules_filter(view, *filter_args),
+     render(view)]
   end
 
   view :set_label do
@@ -41,29 +37,15 @@ format :html do
     end
   end
 
-  def rules_table settings
-    class_up "card-slot", "rules-table"
-    wrap do
-      haml :rules_table, settings: settings,
-                         item_view: voo.show?(:content) ? :closed_rule : :rule_link
-    end
-  end
-
-  def rule_table_row setting
-    return "" unless show_view? setting
-
-    rule_card = card.fetch trait: setting, new: {}
-    row_view, optional_content =
-      voo.hide?(:content) ? %i[rule_link hide] : %i[rule_row show]
-
-    nest(rule_card, view: row_view, optional_content => :content).html_safe
+  def setting_group default=:common
+    voo&.filter&.to_sym || params[:group]&.to_sym || default
   end
 
-  view :editor do
+  view :input do
     "Cannot currently edit Sets" # LOCALIZE
   end
 
-  view :closed_content do
+  view :one_line_content, wrap: {} do
     ""
   end
 end

data/mod/rules/set/type/set/html_views/group_panel.haml

@@ -11,4 +11,4 @@
                           role: "tabpanel",
                           "aria-labelledby": heading_id }
   .card-body
-    = rules_table card.visible_settings(group_key).map(&:codename)
+    = bar_rule_list card.visible_settings(group_key).map(&:codename)

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

@@ -0,0 +1,42 @@
+format :html do
+  view :quick_edit_rule_list, cache: :never, wrap: { slot: { class: "rule-list" } } do
+    quick_edit_rule_list setting_list_from_params(:field_related)
+  end
+
+  view :bar_rule_list, cache: :never, wrap: { slot: { class: "rule-list" } } do
+    bar_rule_list setting_list_from_params
+  end
+
+  view :pill_rule_list, cache: :never, wrap: { slot: { class: "rule-list" } } do
+    pill_rule_list setting_list_from_params
+  end
+
+  def quick_edit_rule_list settings
+    list_tag class: "nav nav-pills flex-column bridge-pills" do
+      settings.map { |setting| rule_list_item setting, :quick_edit }
+    end
+  end
+
+  def pill_rule_list settings
+    list_items =
+      settings.map { |setting| rule_list_item setting, :rule_bridge_link }
+    bridge_pills list_items
+  end
+
+  def bar_rule_list settings
+    list_items =
+      settings.map { |setting| rule_list_item setting, :bar, hide: :full_name }
+    list_items.join("\n").html_safe
+  end
+
+  def rule_list_item setting, view, opts={}
+    return "" unless show_view? setting
+
+    rule_card = card.fetch trait: setting, new: {}
+    nest(rule_card, opts.merge(view: view)).html_safe
+  end
+
+  def setting_list_from_params default=:common
+    setting_list setting_group(default)
+  end
+end

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

@@ -7,37 +7,6 @@ format :html do
   end
 
   def link_to_template_editor
-    link_to_view :template_editor, voo.title, path: { slot: { title: voo.title } }
-  end
-
-  # TODO: hamlize
-  view :template_editor do
-    wrap { haml :template_editor }
-  end
-
-  def frame_header
-    voo.show?(:template_closer) ? template_frame_header : super
-  end
-
-  def template_frame_header
-    [render_template_closer, _render_header]
-  end
-
-  # no slot, because frame is inside template_editor's slot
-  def standard_frame slot=true
-    voo.show?(:template_closer) ? super(false) : super
-  end
-
-  view :template_editor_frame do
-    voo.title = card.label
-    frame do
-      _render_core
-    end
-  end
-
-  view :template_closer do
-    wrap_with "div", class: "card-menu template-closer" do
-      link_to_view :template_link, icon_tag("remove")
-    end
+    link_to_view :modal_nest_rules, voo.title
   end
 end

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

@@ -1,27 +1,41 @@
 format :html do
-  def rules_filter selected_setting=:common, set_options=:related
-    form_tag path(mark: "", view: :rules_list, slot: { hide: :content }),
+  def rules_filter view, selected_setting=nil, set_options=nil, path_opts={}
+    form_tag path(path_opts.merge(view: view)),
              remote: true, method: "get", role: "filter",
-             "data-slot-selector": ".card-slot.rules_list-view",
+             "data-slot-selector": ".card-slot.rule-list",
              class: classy("nodblclick slotter form-inline slim-select2 m-2") do
       output [
         label_tag(:view, icon_tag("filter_list"), class: "mr-2"),
         setting_select(selected_setting),
-        content_tag(:span, "rules that apply to set ...", class: "mx-2 small"),
         set_select(set_options)
-      ]
+      ].flatten
     end
   end
 
+  def set_select set_options
+    return filter_text.html_safe unless set_options
+
+    [content_tag(:span, "rules that apply to set ...", class: "mx-2 small"),
+     set_select_tag(set_options)]
+  end
+
   def setting_select selected=nil
     select_tag(:group, grouped_options_for_select(setting_options, selected),
-               class: "_submit-on-select form-control")
+               class: "_submit-on-select form-control",
+               "data-select2-id": "#{unique_id}-#{Time.now.to_i}")
   end
 
-  def set_select set_options=:related
+  def filter_text
+    wrap_with :span, class: "mx-2 small" do
+      "rules that apply to #{_render_set_label.downcase}" # LOCALIZE
+    end
+  end
+
+  def set_select_tag set_options=:related
     select_tag(:mark, set_select_options(set_options),
-               class: "_submit-on-select form-control",
-               "data-minimum-results-for-search": "Infinity")
+               class: "_submit-on-select form-control _close-rule-overlay-on-select",
+               "data-minimum-results-for-search": "Infinity",
+               "data-select2-id": "#{unique_id}-#{Time.now.to_i}")
   end
 
   def selected_set
@@ -30,7 +44,7 @@ format :html do
 
   def set_select_options set_options
     options =
-      if set_options == :related || card.type_id != Card::SetID
+      if set_options == :related
         related_set_options
       else
         [[card.label, card.name.url_key]]

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

@@ -13,6 +13,10 @@ format :html do
      ["Single rules", card.visible_setting_codenames]]
   end
 
+  def field_settings
+    %i[default help input_type content_options content_option_view]
+  end
+
   # @param val setting category, setting group or single setting
   def setting_list val
     category_setting_list(val) || group_setting_list(val) || [val]
@@ -32,17 +36,18 @@ format :html do
       card.visible_setting_codenames & COMMON_SETTINGS
     when :field_related, :field_related_rules
       field_related_settings
+    when :nest_editor_field_related
+      nest_editor_field_related_settings
     end
   end
 
+  def nest_editor_field_related_settings
+    field_settings
+    #  & card.visible_settings(nil, card.prototype_default_type_id).map(&:codename)
+  end
+
   def field_related_settings
-    field_settings = %i[default help]
-    if card.collection?
-      # FIXME: isn't card always of type set???
-      # FIXME: should be done with override in pointer set module
-      field_settings += %i[input options options_label]
-    end
-    card.visible_setting_codenames & field_settings
+    field_settings # card.visible_setting_codenames &
   end
 
   def recent_settings
@@ -51,33 +56,21 @@ format :html do
   end
 
   view :all_rules_list do
-    rules_list :all, card.visible_setting_codenames.sort
-  end
-
-  view :grouped_rules_list do
-    with_label_and_navbars :grouped_rules do
-      wrap_with :div, class: "panel-group", id: "accordion",
-                      role: "tablist", "aria-multiselectable": "true" do
-        Card::Setting.groups.keys.map do |group_key|
-          _render group_key
-        end
-      end
-    end
+    pill_rule_list card.visible_setting_codenames.sort
   end
 
   view :recent_rules_list do
     recent_settings = Card[:recent_settings].item_cards.map(&:codename)
     settings = recent_settings.map(&:to_sym) & card.visible_setting_codenames
-    rules_list :all, settings
+    pill_rule_list settings
   end
 
   view :common_rules_list do
-    settings = card.visible_setting_codenames & COMMON_SETTINGS
-    # "&" = set intersection
-    rules_list :common, settings
+    settings = card.visible_setting_codenames & COMMON_SETTINGS # "&" = set intersection
+    pill_rule_list settings
   end
 
   view :field_related_rules_list do
-    rules_list :field_related, field_related_settings
+    pill_rule_list field_related_settings
   end
 end