card-mod-rules 0.14.2 → 0.15.1

data/set/rule/rule_form/rule_set_radio.rb

@@ -2,7 +2,7 @@
 class RuleSetRadio
   attr_reader :format
 
-  delegate :link_to_card, :radio_button, :wrap_with, :icon_tag,
+  delegate :link_to_card, :radio_button, :wrap_with, :icon_tag, :unique_id,
            to: :format
 
   # @param state [:current, :overwritten]
@@ -12,14 +12,14 @@ class RuleSetRadio
     @set_name = set_name
     @tag = tag
     @state = state
+    @id = "#{unique_id}-#{Time.now.to_i}"
   end
 
   def html narrower
     @narrower_rules = narrower
 
-    rule_radio do
-      radio_text = "#{@set_name}+#{@tag}"
-      radio_button :name, radio_text, checked: false, warning: warning
+    wrap_with :div, class: "form-check" do
+      [radio, label]
     end
   end
 
@@ -33,18 +33,21 @@ class RuleSetRadio
     @state == :overwritten
   end
 
-  def rule_radio
-    label_classes = ["set-label", ("current-set-label" if current?)]
-    icon = icon_tag "open_in_new", "link-muted"
-    wrap_with :label, class: label_classes.compact.join(" ") do
-      [yield, label, link_to_card(@set_name, icon, target: "decko_set")]
-    end
+  def radio
+    radio_text = "#{@set_name}+#{@tag}"
+    radio_button :name, radio_text,
+                 checked: false, warning: warning, class: "form-check-input", id: @id
   end
 
   def label
-    label = Card.fetch(@set_name).label
-    label += " <em>#{extra_info}</em>".html_safe if extra_info
-    label
+    label_classes = ["set-label", ("current-set-label" if current?)].compact.join(" ")
+    icon = icon_tag "open_in_new", "text-muted"
+    text = Card.fetch(@set_name).label
+    text += " <em>#{extra_info}</em>".html_safe if extra_info
+
+    wrap_with :label, class: "form-check-label #{label_classes}", for: @id do
+      [text, link_to_card(@set_name, icon, target: "decko_set")]
+    end
   end
 
   def extra_info

data/set/rule/rule_form/set_selection.rb

@@ -1,6 +1,6 @@
 format :html do
   def bridge_rule_set_selection
-    wrap_with :div, class: "set-list" do
+    wrap_with :div, class: "set-list _set-editor" do
       bridge_rule_set_formgroup
     end
   end
@@ -9,30 +9,13 @@ format :html do
     tag = @rule_context.rule_user_setting_name
     narrower = []
 
-    bridge_option_list "Set" do
-      rule_set_options.map do |set_name, state|
+    wrap_with :div, class: "col-xs-6 mt-3 mb-5" do
+      rule_set_options.reverse.map do |set_name, state|
         RuleSetRadio.new(self, set_name, tag, state).html narrower
       end
     end
   end
 
-  def bridge_option_list title
-    index = -1
-    formgroup title, input: "set", class: "col-xs-6", help: false do
-      yield.inject("") do |res, radio|
-        index += 1
-        # TODO
-        if false # index.in? [2,3]
-          wrap_with(:li, radio, class: "radio") + res
-        else
-          wrap_with :ul do
-            wrap_with(:li, (radio + res), class: "radio")
-          end
-        end
-      end
-    end
-  end
-
   def rule_set_options
     @rule_set_options ||= @rule_context.set_options
   end

data/set/rule/rule_form.rb

@@ -1,8 +1,6 @@
 format :html do
   view :rule_form, cache: :never, unknown: true do
-    @success_view ||= :open
-    @rule_context ||= card
-    @form_type ||= :overlay
+    prepare_rule_form_options
 
     wrap do
       edit_rule_form @success_view do
@@ -14,6 +12,24 @@ format :html do
     end
   end
 
+  def prepare_rule_form_options
+    @success_view ||= :open
+    @rule_context ||= card
+    @form_type ||= :overlay
+    @edit_rule_success = edit_rule_success @success_view
+  end
+
+  view :rule_form_card_editor, cache: :never, unknown: true do
+    prepare_rule_form_options
+
+    wrap true, class: "card-editor slotter" do
+      [
+        rules_type_formgroup,
+        rule_content_formgroup
+      ]
+    end
+  end
+
   def form_type
     @form_type || :overlay
   end

data/set/self/cardtype.rb

@@ -1,5 +1,3 @@
-
-
 format :html do
   view :grouped_list do
     All::CardtypeGroups::GROUP.keys.map do |group|

data/set/self/recent_settings.rb

@@ -1,3 +1,5 @@
+include_set Abstract::List
+
 def history?
   false
 end

data/set/type/cardtype.rb

@@ -1,5 +1,5 @@
 def related_sets with_self=false
   sets = []
-  sets << ["#{name}+*type", Card::Set::Type.label(name)] if known?
+  sets << Card.fetch(name, :type) if known?
   sets + super
 end

data/set/type/set/html_views/filtered_rule_lists.rb

@@ -0,0 +1,23 @@
+format :html do
+  view :nest_rules,
+       cache: :never, unknown: true, wrap: :slot do
+    render :quick_edit_setting_list
+  end
+
+  view :modal_nest_rules,
+       cache: :never, unknown: true,
+       wrap: { modal: { title: "Rules for nest" } } do
+    filtered_rule_list :quick_edit_setting_list, :field_related
+  end
+
+  view :bridge_rules_tab,
+       cache: :never,
+       wrap: { slot: { class: "d-flex flex-column gap-3 mx-3 mt-2" } }  do
+    class_up "accordion-item", "_setting-list"
+    filtered_rule_list :accordion_rule_list, :common, mark: ""
+  end
+
+  view :filtered_accordion_rule_list do
+    filtered_rule_list :accordion_rule_list
+  end
+end

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

@@ -1,42 +1,102 @@
 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)
+  setting_list_view_options = { cache: :never,
+                                wrap: { slot: { class: "_setting-list" } } }
+
+  # rule can be edited in-place
+  view :quick_edit_setting_list, setting_list_view_options do
+    quick_edit_setting_list
+  end
+
+  # show the settings in bars
+  view :bar_setting_list, setting_list_view_options do
+    group = voo.filter&.to_sym || :all
+    category_setting_list_items(group, :bar, hide: :full_name).join("\n").html_safe
+  end
+
+  # a click on a setting opens the rule editor in an overlay
+  view :pill_setting_list, setting_list_view_options do
+    pill_setting_list
+  end
+
+  # a click on a setting opens the rule editor in a modal
+  view :modal_pill_setting_list, setting_list_view_options do
+    pill_setting_list true
+  end
+
+  view :accordion_rule_list, setting_list_view_options do
+    class_up "accordion", "bar-accordion"
+    category_accordion(:rule_bridge_link) do |list|
+      bridge_pills list
+    end
+  end
+
+  view :accordion_bar_list do
+    class_up "accordion", "bar-accordion"
+    category_accordion(:bar) do |list|
+      list_tag(class: "nav flex-column", items: { class: "nav-item" }) { list }
+    end
   end
 
-  view :bar_rule_list, cache: :never, wrap: { slot: { class: "rule-list" } } do
-    bar_rule_list setting_list_from_params
+  def category_accordion view, &block
+    class_up "accordion-item", "_setting-group"
+    wrap_with :div, class: "_setting-list" do
+      accordion do
+        category_accordion_item(view, &block)
+      end
+    end
+  end
+
+  def category_accordion_item view
+    Card::Setting.groups.keys.map do |group_key|
+      list =
+        card.group_settings(group_key).map do |setting|
+          setting_list_item setting, view
+        end
+      body = yield list
+      accordion_item "#{group_key} #{count_badge(list.size)}",
+                     body: body, context: group_key
+    end
   end
 
-  view :pill_rule_list, cache: :never, wrap: { slot: { class: "rule-list" } } do
-    pill_rule_list setting_list_from_params
+  def count_badge count
+    "<span class=\"_count badge bg-secondary ms-3\">#{count}</span>"
   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 }
+  view :overlay_rule_list_link, cache: :never do
+    opts = bridge_link_opts(class: "edit-rule-link btn btn-primary")
+    # opts[:path].delete(:layout)
+
+    wrap_with :div do
+      link_to_view(:core, "Show existing rules", opts)
     end
   end
 
-  def pill_rule_list settings
-    list_items =
-      settings.map { |setting| rule_list_item setting, :rule_bridge_link }
-    bridge_pills list_items
+  def quick_edit_setting_list
+    classes = "nav nav-pills flex-column bridge-pills _setting-list _setting-group"
+    list_tag class: classes do
+      category_setting_list_items :field, :quick_edit
+    end
   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
+  def pill_setting_list open_rule_in_modal=false
+    item_view = open_rule_in_modal ? :rule_nest_editor_link : :rule_bridge_link
+    bridge_pills category_setting_list_items(:all, item_view)
   end
 
-  def rule_list_item setting, view, opts={}
+  view :pill_setting_list, cache: :never, wrap: { slot: { class: "_setting-list" } } do
+    pill_setting_list
+  end
+
+  def category_setting_list_items category, item_view, options={}
+    card.category_settings(category).map do |setting|
+      setting_list_item setting, item_view, options
+    end
+  end
+
+  def setting_list_item setting, view, opts={}
     return "" unless show_view? setting
 
     rule_card = card.fetch 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/set/type/set/html_views/setting_filter.rb

@@ -0,0 +1,38 @@
+format :html do
+  def filtered_rule_list view, *filter_args
+    [
+      setting_filter(view, *filter_args),
+      render(view)
+    ]
+  end
+
+  def setting_filter view, selected_category=:common, path_opts={}
+    form_tag path(path_opts.merge(view: view)),
+             remote: true, method: "get", role: "filter",
+             "data-slot-selector": ".card-slot._setting-list",
+             class: classy("nodblclick slotter") do
+      output [
+        filter_buttons(selected_category)
+      ].flatten
+    end
+  end
+
+  def filter_buttons selected=:all
+    wrap_with :div, class: "my-4 mx-2 _setting-filter" do
+      [
+        content_tag(:label, "Settings"),
+        filter_radio(:all, "All", selected == :all),
+        filter_radio(:common, "Common", selected == :common),
+        filter_radio(:field, "Field", selected == :field_related),
+        filter_radio(:recent, "Recent", selected == :recent)
+      ]
+    end
+  end
+
+  def filter_radio name, label, checked=false
+    <<-HTML.strip_heredoc
+        <input type="radio" class="btn-check _setting-category" name="options" id="#{name}" autocomplete="off" #{'checked' if checked}>
+        <label class="btn btn-outline-primary" for="#{name}">#{label}</label>
+    HTML
+  end
+end

data/set/type/set/html_views.rb

@@ -4,43 +4,16 @@ format :html do
   end
 
   view :core, cache: :never do
-    filtered_rule_list :bar_rule_list
-  end
-
-  view :nest_rules, cache: :never, unknown: true, wrap: :slot do
-    filtered_rule_list :quick_edit_rule_list, :field_related_rules, :related, mark: ""
-  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 filtered_rule_list view, *filter_args
-    [rules_filter(view, *filter_args),
-     render(view)]
+    [
+      content_tag(:h4, t("rules_header"), class: "mt-3"),
+      filtered_rule_list(:accordion_bar_list)
+    ]
   end
 
   view :set_label do
     wrap_with :strong, card.label, class: "set-label"
   end
 
-  Card::Setting.groups.each_key do |group_key|
-    view group_key.to_sym do
-      next unless card.visible_settings(group_key).present?
-
-      haml :group_panel, group_key: group_key
-    end
-  end
-
-  def setting_group default=:common
-    voo&.filter&.to_sym || params[:group]&.to_sym || default
-  end
-
   view :input do
     "Cannot currently edit Sets" # LOCALIZE
   end

data/set/type/set/setting_categories.rb

@@ -0,0 +1,67 @@
+SETTING_OPTIONS = [["Common", :common_rules],
+                   ["All", :all_rules],
+                   ["Field", :field_related_rules],
+                   ["Recent", :recent_rules]].freeze
+
+COMMON_SETTINGS = %i[create read update delete structure default guide].freeze
+FIELD_SETTINGS = %i[default help].freeze
+
+def categories setting
+  result = [:all]
+  result += %i[field recent common].select do |cat|
+    category_settings(cat)&.include? setting
+  end
+  result
+end
+
+def selected_setting_category default=:common
+  voo&.filter&.to_sym || params[:group]&.to_sym || default
+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_settings(val) || group_settings(val) || [val]
+end
+
+def category_settings cat
+  case cat
+  when :all, :all_rules
+    all_settings
+  when :recent, :recent_rules
+    recent_settings
+  when :common, :common_rules
+    visible_setting_codenames & COMMON_SETTINGS
+  when :field, :field_related, :field_related_rules
+    field_related_settings
+  when :nest_editor_field_related
+    nest_editor_field_related_settings
+  else
+    group_settings cat
+  end
+end
+
+def group_settings group
+  visible_settings(group).map(&:codename) if Card::Setting.groups[group]
+end
+
+def all_settings
+  visible_setting_codenames.sort
+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 # card.visible_setting_codenames &
+end
+
+def recent_settings
+  recent_settings = Card[:recent_settings].item_cards.map(&:codename).compact
+  recent_settings & visible_setting_codenames
+end

data/set/type/set.rb

@@ -1,5 +1,7 @@
 include_set Type::SearchType
 
+basket[:non_createable_types] << :set
+
 def anchor_name
   name.left_name
 end
@@ -17,7 +19,7 @@ def pattern
 end
 
 def inheritable?
-  junction_only? || (anchor_name&.compound? && self_set?)
+  compound_only? || (anchor_name&.compound? && self_set?)
 end
 
 def self_set?
@@ -29,8 +31,8 @@ def subclass_for_set
   Pattern.concrete.find { |set| set.pattern_code == current_set_pattern_code }
 end
 
-def junction_only?
-  @junction_only.nil? ? (@junction_only = subclass_for_set.junction_only) : @junction_only
+def compound_only?
+  @compound_only.nil? ? (@compound_only = subclass_for_set.compound_only) : @compound_only
 end
 
 def label
@@ -82,7 +84,7 @@ def visible_settings group=nil, cardtype_id=nil
 end
 
 def broader_sets
-  prototype.set_names[1..-1]
+  prototype.set_names[1..-1].map(&Card.method(:fetch))
 end
 
 def prototype
@@ -105,3 +107,7 @@ def related_sets with_self=false
     left(new: {}).related_sets with_self
   end
 end
+
+def label_and_url_key
+  [label, name.to_name.url_key]
+end

data/set/type/setting/core.haml

@@ -0,0 +1,11 @@
+= _render_rule_help
+%h3 All #{card.name.tr "*", ""} rules that apply to
+- card.set_classes_with_rules.each do |klass, rules|
+  %p
+    %h5
+      = klass.generic_label.downcase
+    - if klass.anchorless?
+      = nest rules.first, view: :bar, show: :full_name
+    - else
+      - rules.each do |rule|
+        = nest rule, view: :bar

data/set/type/setting.rb

@@ -1,3 +1,5 @@
+basket[:non_createable_types] << :setting
+
 format :data do
   view :core do
     cql = { left: { type: SetID },
@@ -19,7 +21,7 @@ def set_classes_with_rules
 end
 
 def rules_for_set_class set_class
-  cql = { left: { type: SetID }, right: id, sort: %w[content name], limit: 0 }
+  cql = { left: { type: SetID }, right: id, sort_by: %w[content name], limit: 0 }
   cql[:left][(set_class.anchorless? ? :id : :right_id)] = set_class.pattern_id
   Card.search cql
 end

data/set/type_plus_right/set/setting.rb

@@ -0,0 +1,12 @@
+assign_type :list
+
+format :html do
+end
+
+def item_cards args={}
+  left.setting_list(args[:setting_list] || :all).map(&method(:rule_item_card))
+end
+
+def rule_item_card setting
+  left.fetch setting, new: {}
+end

data/set/type_plus_right/set/structure.rb

@@ -0,0 +1,10 @@
+format :html do
+  def nest_snippet
+    @nest_snippet ||=
+      begin
+        super
+        @nest_snippet.field! if @nest_snippet.empty?
+        @nest_snippet
+      end
+  end
+end