card 1.96.8 → 1.97.0

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

@@ -0,0 +1,72 @@
+format :html do
+  COMMON_RULE_SETTINGS =
+    %i[create read update delete structure default].freeze
+
+  before :open do
+    voo.hide :template_closer
+  end
+
+  view :core, cache: :never do
+    table_rules_filter + _render_rules_table
+  end
+
+  view :rules_table, cache: :never do
+    rules_table setting_list(setting_group)
+  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
+  end
+
+  def setting_group
+    params[:group]&.to_sym || :common
+  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 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
+  end
+
+  view :editor do
+    "Cannot currently edit Sets" # LOCALIZE
+  end
+
+  view :closed_content do
+    ""
+  end
+end

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

@@ -0,0 +1,129 @@
+format :html do
+  view :bridge_rules_tab, cache: :never do
+    output [rules_filter, render_rules_list]
+  end
+
+  SETTING_OPTIONS = [["Common", :common_rules], ["All", :all_rules],
+                     ["Field", :field_related_rules],
+                     ["Recent", :recent_rules]].freeze
+
+  FIELD_SETTINGS = %i[default help structure].freeze
+
+  def setting_select
+    select_tag(:group, grouped_options_for_select(setting_options),
+               class: "_submit-on-select form-control")
+  end
+
+  def setting_options
+    [["Categories", SETTING_OPTIONS], ["Groups", Card::Setting.group_names.keys],
+     ["Single rules", card.visible_setting_codenames]]
+  end
+
+  def set_select
+    options = card.related_sets(true).map do |name, label|
+      [label, name.to_name.url_key]
+    end
+    select_tag(:mark,
+               options_for_select(options),
+               class: "_submit-on-select form-control",
+               "data-minimum-results-for-search": "Infinity")
+  end
+
+  def rules_filter
+    form_tag path(mark: "", view: :rules_list, slot: { hide: :content }),
+             remote: true, method: "get", role: "filter",
+             "data-slot-selector": ".card-slot.rules_list-view",
+             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 set ...", class: "mx-2 small"),
+        set_select
+      ]
+    end
+  end
+
+  def rules_list _key, items
+    bridge_pills(items.map { |i| rules_list_item i })
+  end
+
+  def rules_list_item setting
+    return "" unless show_view? setting
+
+    rule_card = card.fetch trait: setting, new: {}
+    nest(rule_card, view: :rule_bridge_link).html_safe
+  end
+
+  view :rules_list, wrap: :slot do
+    group = params[:group]&.to_sym || :common
+    rules_list group, setting_list(group)
+  end
+
+  # @param val setting category, setting group or single setting
+  def setting_list val
+    category_setting_list(val) || group_setting_list(val) || [val]
+  end
+
+  def group_setting_list group
+    card.visible_settings(group).map(&:codename) if Card::Setting.groups[group]
+  end
+
+  def category_setting_list cat
+    case cat
+    when :all, :all_rules
+      card.visible_setting_codenames.sort
+    when :recent, :recent_rules
+      recent_settings
+    when :common, :common_rules
+      card.visible_setting_codenames & COMMON_RULE_SETTINGS
+    when :field_related, :field_related_rules
+      field_related_settings
+    end
+  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
+  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
+  end
+
+  view :common_rules_list do
+    settings = card.visible_setting_codenames & COMMON_RULE_SETTINGS
+    # "&" = set intersection
+    rules_list :common, settings
+  end
+
+  def field_related_settings
+    field_settings = %i[default help structure]
+    if card.type_id == PointerID
+      # 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
+  end
+
+  def recent_settings
+    recent_settings = Card[:recent_settings].item_cards.map(&:codename)
+    recent_settings.map(&:to_sym) & card.visible_setting_codenames
+  end
+
+  view :field_related_rules_list do
+    rules_list :field_related, field_related_settings
+  end
+end

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

@@ -0,0 +1,11 @@
+%table.table.table-sm
+  %thead.thead-dark
+    %tr.rule-group
+      %th.rule-heading Trait
+      - if voo.show? :content
+        %th.rule-heading Content
+      %th.rule-heading.d-none.d-sm-table-cell Set
+  %tbody
+    - settings.each do |setting|
+      = rule_table_row setting
+

data/mod/{standard → rules}/set/type/set/html_views/template.rb

@@ -7,8 +7,7 @@ format :html do
   end
 
   def link_to_template_editor
-    link_to_view :template_editor, voo.title, class: "slotter",
-                                              path: { slot: { title: voo.title } }
+    link_to_view :template_editor, voo.title, path: { slot: { title: voo.title } }
   end
 
   # TODO: hamlize
@@ -31,17 +30,14 @@ format :html do
 
   view :template_editor_frame do
     voo.title = card.label
-    voo.hide :set_label
     frame do
       _render_core
     end
   end
 
   view :template_closer do
-    wrap_menu do
-      wrap_with "div", class: "card-menu template-closer" do
-        link_to_view :template_link, icon_tag("remove"), class: "slotter"
-      end
+    wrap_with "div", class: "card-menu template-closer" do
+      link_to_view :template_link, icon_tag("remove")
     end
   end
 end

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

@@ -0,0 +1,9 @@
+# -*- encoding : utf-8 -*-
+
+RSpec.describe Card::Set::Rule::Editor do
+  def card_subject
+    Card.fetch("*read+*right+*input", new: {})
+  end
+
+  check_html_views_for_errors
+end

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

@@ -0,0 +1,9 @@
+# -*- encoding : utf-8 -*-
+
+RSpec.describe Card::Set::Rule::TableRow do
+  def card_subject
+    Card.fetch("*read+*right+*input", new: {})
+  end
+
+  check_html_views_for_errors
+end

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

@@ -0,0 +1,15 @@
+# -*- encoding : utf-8 -*-
+
+RSpec.describe Card::Set::Rule::Table do
+  def card_subject
+    Card.fetch("*read+*right+*input", new: {})
+  end
+
+  check_html_views_for_errors
+
+  it "renders setting view for a *input rule", as_bot: true do
+    expect_view("open_rule").to have_tag "div.modal" do
+      with_tag "div.rule-section", count: 2
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# -*- encoding : utf-8 -*-
+
+RSpec.describe Card::Set::Type::Set::HtmlViews do
+  def card_subject
+    Card.fetch("User+*type")
+  end
+
+  check_html_views_for_errors
+
+  it "renders setting table for a right set" do
+    expect_view("open", card: "*read+*right")
+      .to have_tag "div", with: { id: "Xread-Xright-open-view" } do
+      with_tag "form", with: { role: "filter" }
+      with_tag "table" do
+        with_tag "tr", with: { id: "Xread-Xright-Xcreate-rule_row-view" } do
+          with_tag "td", "create"
+          with_tag "td", "Administrator"
+        end
+      end
+    end
+  end
+end

data/mod/{standard → rules}/spec/set/type/set_spec.rb

@@ -1,26 +1,26 @@
 # -*- encoding : utf-8 -*-
 
-describe Card::Set::Type::Set do
-  describe :junction_only? do
-    it "identifies sets that only apply to plus cards" do
-      expect(Card.fetch("*all").junction_only?).to be_falsey
-      expect(Card.fetch("*all plus").junction_only?).to be_truthy
-      expect(Card.fetch("Book+*type").junction_only?).to be_falsey
-      expect(Card.fetch("*to+*right").junction_only?).to be_truthy
-      expect(Card.fetch("Book+*to+*type plus right").junction_only?)
-        .to be_truthy
+RSpec.describe Card::Set::Type::Set do
+  describe "#junction_only?" do
+    it "identifies sets that only apply to plus cards", aggregate_failures: true do
+      expect(Card.fetch("*all")).not_to be_junction_only
+      expect(Card.fetch("*all plus")).to be_junction_only
+      expect(Card.fetch("Book+*type")).not_to be_junction_only
+      expect(Card.fetch("*to+*right")).to be_junction_only
+      expect(Card.fetch("Book+*to+*type plus right"))
+        .to be_junction_only
     end
   end
 
-  describe :inheritable? do
-    it "identifies sets that can inherit rules" do
-      expect(Card.fetch("A+*self").inheritable?).to be_falsey
-      expect(Card.fetch("A+B+*self").inheritable?).to be_truthy
-      expect(Card.fetch("Book+*to+*type plus right").inheritable?).to be_truthy
-      expect(Card.fetch("Book+*type").inheritable?).to be_falsey
-      expect(Card.fetch("*to+*right").inheritable?).to be_truthy
-      expect(Card.fetch("*all plus").inheritable?).to be_truthy
-      expect(Card.fetch("*all").inheritable?).to be_falsey
+  describe "#inheritable?" do
+    it "identifies sets that can inherit rules", aggregate_failures: true do
+      expect(Card.fetch("A+*self")).not_to be_inheritable
+      expect(Card.fetch("A+B+*self")).to be_inheritable
+      expect(Card.fetch("Book+*to+*type plus right")).to be_inheritable
+      expect(Card.fetch("Book+*type")).not_to be_inheritable
+      expect(Card.fetch("*to+*right")).to be_inheritable
+      expect(Card.fetch("*all plus")).to be_inheritable
+      expect(Card.fetch("*all")).not_to be_inheritable
     end
   end
 

data/mod/search/set/abstract/00_filter_helper.rb

@@ -1,12 +1,16 @@
+# TODO: move sort/filter handling out of card and into base format
+# sorting and filtering is about viewing the data, not altering the data itself.
 
 def sort_hash
-  { sort: sort_param }
+  sort_param.present? ? { sort: sort_param } : {}
 end
 
 def filter_param field
   filter_hash[field.to_sym]
 end
 
+# FIXME: it is inconsistent that #sort_hash has :sort as the key, but
+# #filter_hash is the _value_ of the hash with :filter as the key.
 def filter_hash
   @filter_hash ||= begin
     filter = Env.params[:filter]
@@ -16,13 +20,19 @@ def filter_hash
 end
 
 def sort_param
-  Env.params[:sort] if Env.params[:sort].present?
+  safe_sql_param :sort
+end
+
+def safe_sql_param key
+  param = Env.params[key]
+  param.blank? ? nil : Card::Query.safe_sql(param)
 end
 
 def filter_keys_with_values
   (filter_keys + advanced_filter_keys).map do |key|
     values = filter_param(key)
     next unless values.present?
+
     [key, values]
   end.compact
 end
@@ -38,14 +48,12 @@ end
 format do
   delegate :filter_hash, :sort_hash, :filter_param, :sort_param,
            :all_filter_keys, to: :card
-end
 
-format :html do
   def extra_paging_path_args
-    super.merge(filter: filter_hash).merge sort_hash
+    super.merge filter_and_sort_hash
   end
 
-  def filter_active?
-    filter_hash.present?
+  def filter_and_sort_hash
+    sort_hash.merge filter: filter_hash
   end
 end

data/mod/search/set/abstract/01_filter_form_helper.rb

@@ -83,6 +83,7 @@ format :html do
     type_card = Card[type_codename]
     res = Card.search type_id: type_card.id, return: :name, sort: "name", dir: order
     return res unless max_length
+
     res.map { |i| [trim_option(i, max_length), i] }
   end
 

data/mod/search/set/abstract/02_search_params.rb

@@ -24,23 +24,25 @@ format do
 
   def query_params
     return nil unless (vars = params[:query])
+
     Card.safe_param vars
   end
 
   def default_limit
     100
   end
+
+  def extra_paging_path_args
+    return {} unless (vars = query_params)
+
+    { query: vars }
+  end
 end
 
 format :html do
   def default_limit
     Cardio.config.paging_limit || 20
   end
-
-  def extra_paging_path_args
-    return {} unless (vars = query_params)
-    { query: vars }
-  end
 end
 
 format :json do