card 1.96.8 → 1.97.0

data/mod/standard/set/rstar/rules_editor.rb

@@ -1,371 +0,0 @@
-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}"
-  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
-      [render_rule_help,
-       open_rule_setting_links,
-       open_rule_body(rule_view)]
-    end
-  end
-
-  def open_rule_body rule_view
-    wrap_with :div, class: "d0-card-body" do
-      current_rule_format = subformat current_rule
-      current_rule_format.rule_context = card
-      current_rule_format.render rule_view
-    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
-    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 :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
-      %i[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.name.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.name.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
-
-  view :rule_help, tags: :unknown_ok, perms: :none, cache: :never do
-    wrap_with :div, class: "alert alert-info rule-instruction" do
-      rule_based_help
-    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
-    return "not a rule" unless card.is_rule?
-    @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),
-       rule_editor,
-       edit_rule_buttons].join
-    end
-  end
-
-  def edit_rule_success
-    { id:   @rule_context.name.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 rule_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: "set-list" do
-      [rule_set_formgroup, related_set_formgroup]
-    end
-  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? %i[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).name.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 = icon_tag "open_in_new", "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: "decko_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 += " <em>#{extra_info}</em>".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

data/mod/standard/set/self/activity_toolbar_button.rb

@@ -1,14 +0,0 @@
-include_set Abstract::ToolbarSplitButton
-
-format :html do
-  view :core, cache: :never do
-    subject.toolbar_split_button "activity", view: :history, icon: :history do
-      {
-        history: (subject._render_history_link if card.history?),
-        discussion: subject.link_to_related(:discussion, "discuss", class: "dropdown-item"),
-        follow: (subject.follow_link(class: "dropdown-item") if show_follow?),
-        editors: subject.link_to_related(:editors, "editors", class: "dropdown-item")
-      }
-    end
-  end
-end

data/mod/standard/set/self/rules_toolbar_button.rb

@@ -1,44 +0,0 @@
-include_set Abstract::ToolbarSplitButton
-
-format :html do
-  view :core, cache: :never do
-    subject.toolbar_split_button("rules", view: :edit_rules, icon: :list) do
-      dropdown_items
-    end
-  end
-
-  def dropdown_items
-    button_hash = {
-      common_rules:  edit_rules_link("common",   :common_rules),
-      grouped_rules: edit_rules_link("by group", :grouped_rules),
-      all_rules:     edit_rules_link("by name",  :all_rules)
-    }
-    recently_edited_rules_link button_hash
-    # nest_rules_link button_hash
-    button_hash
-  end
-
-  def recently_edited_rules_link button_hash
-    return unless recently_edited_settings?
-    button_hash[:recent_rules] = edit_rules_link "recent", :recent_rules
-  end
-
-  def edit_rules_link text, rule_view
-    subject.link_to_view :edit_rules, text,
-                         path: { rule_view: rule_view },
-                         class: "dropdown-item"
-  end
-
-  # FIXME: edit_nest_rules removed because of recursion
-  #
-  # def nest_rules_link button_hash
-  #   return unless nested_fields.present?
-  #   button_hash[:separator] = separator
-  #   button_hash[:edit_nest_rules] = edit_nest_rules_link "nests"
-  # end
-  #
-  # def edit_nest_rules_link text
-  #   subject.link_to_view :edit_nest_rules, text,
-  #                        path: { rule_view: :field_related_rules }
-  # end
-end

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

@@ -1,155 +0,0 @@
-
-format :html do
-  COMMON_RULE_SETTINGS =
-    %i[create read update delete structure default style].freeze
-
-  view :core, cache: :never do
-    voo.show :set_label, :rule_navbar
-    voo.hide :set_navbar
-    rule_view = params[:rule_view] || :common_rules
-    _render rule_view
-  end
-
-  def with_label_and_navbars selected_view
-    @selected_rule_navbar_view = selected_view
-    wrap do
-      [
-        _render_set_label,
-        _render_rule_navbar,
-        _render_set_navbar,
-        yield
-      ]
-    end
-  end
-
-  view :all_rules do
-    with_label_and_navbars :all_rules do
-      rules_table card.visible_setting_codenames.sort
-    end
-  end
-
-  view :grouped_rules 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 do
-    with_label_and_navbars :recent_rules do
-      recent_settings = Card[:recent_settings].item_cards.map(&:codename)
-      settings = recent_settings.map(&:to_sym) & card.visible_setting_codenames
-      rules_table settings
-    end
-  end
-
-  view :common_rules do
-    with_label_and_navbars :common_rules do
-      settings = card.visible_setting_codenames & COMMON_RULE_SETTINGS
-      # "&" = set intersection
-      rules_table settings
-    end
-  end
-
-  view :field_related_rules do
-    with_label_and_navbars :field_related_rules do
-      field_settings = %i[default help structure]
-      if card.type_id == PointerID
-        # FIXME: should be done with override in pointer set module
-        field_settings += %i[input options options_label]
-      end
-      settings = card.visible_setting_codenames & field_settings
-      rules_table settings
-    end
-  end
-
-  view :set_label do
-    wrap_with :h3, 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
-    haml :rules_table, settings: settings
-  end
-
-  view :editor do
-    "Cannot currently edit Sets" # ENGLISH
-  end
-
-  view :closed_content do
-    ""
-  end
-
-  view :set_navbar do
-    id = "set-navbar-#{card.name.safe_key}-#{voo.home_view}"
-    related_sets = card.related_sets(true)
-    return "" if related_sets.size <= 1
-    navbar id, brand: "Set", toggle_align: :right,
-               class: "slotter toolbar navbar-expand-md",
-               navbar_type: "dark",
-               collapsed_content: close_link("float-right d-sm-none") do
-      set_navbar_content related_sets
-    end
-  end
-
-  def li_pill content, active
-    "<li role='presentation' class='nav-item #{'active' if active}'>#{content}</li>"
-  end
-
-  view :rule_navbar do
-    navbar "rule-navbar-#{card.name.safe_key}-#{voo.home_view}",
-           brand: "Rules", toggle_align: :right,
-           class: "slotter toolbar navbar-expand-md bg-dark", navbar_type: "dark",
-           collapsed_content: close_link("float-right d-sm-none") do
-      rule_navbar_content
-    end
-  end
-
-  def rule_navbar_pills
-    pills = [["common",   :common_rules],
-             ["by group", :grouped_rules],
-             ["by name",  :all_rules]]
-    pills.unshift ["field", :field_related_rules] if card.junction?
-    pills.push ["recent", :recent_rules] if recently_edited_settings?
-    pills
-  end
-
-  def rule_navbar_content
-    wrap_with :ul, class: "nav navbar-nav nav-pills" do
-      rule_navbar_pills.map do |label, symbol|
-        view_link_pill label, symbol
-      end
-    end
-  end
-
-  def set_navbar_content related_sets
-    wrap_with :ul, class: "nav navbar-nav nav-pills" do
-      related_sets.map do |name, label|
-        slot_opts = { hide: "header set_label rule_navbar",
-                      show: "subheader set_navbar" }
-        link = link_to_card name, label, remote: true,
-                                         path: { view: @slot_view,
-                                                 slot: slot_opts },
-                                         class: "nav-link"
-        li_pill link, name == card.name
-      end
-    end
-  end
-
-  def view_link_pill name, view
-    selected_view = @selected_rule_navbar_view || @slot_view || voo.home_view
-    link = link_to_view view, name, class: "nav-link slotter", role: "pill",
-                                    path: { slot: { show: :rule_navbar } }
-    li_pill link, selected_view == view
-  end
-end