card 1.99.6 → 1.100.0

data/tmpsets/set/mod023-rules/rule/html_views.rb

@@ -0,0 +1,22 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Rule
+# Set: All rule cards (HtmlViews)
+#
+module HtmlViews;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/rules/set/rule/html_views.rb"; end
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  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 == SearchTypeID
+      render_raw
+    else
+      super()
+    end
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/rules/set/rule/html_views.rb ~~

data/tmpsets/set/mod023-rules/rule/quick_editor.rb

@@ -0,0 +1,48 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Rule
+# Set: All rule cards (QuickEditor)
+#
+module QuickEditor;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/rules/set/rule/quick_editor.rb"; end
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  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
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/rules/set/rule/quick_editor.rb ~~

data/tmpsets/set/mod023-rules/rule/rule_form.rb

@@ -0,0 +1,66 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Rule
+# Set: All rule cards (RuleForm)
+#
+module RuleForm;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/rules/set/rule/rule_form.rb"; end
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  view :rule_form, cache: :never, unknown: true do
+    @success_view ||= :open
+    @rule_context ||= card
+    @form_type ||= :overlay
+
+    wrap do
+      edit_rule_form @success_view do
+        [
+          hidden_tags(success: @edit_rule_success),
+          haml(:rule_form)
+        ].join
+      end
+    end
+  end
+
+  def form_type
+    @form_type || :overlay
+  end
+
+  def current_rule_form success_view: :overlay_rule, form_type: :overlay
+    current_rule_format = subformat current_rule
+    current_rule_format.rule_form success_view, card, form_type
+  end
+
+  def rule_form success_view, rule_context, form_type=:overlay
+    validate_form_type form_type
+
+    @rule_context = rule_context
+    @form_type = form_type
+    @success_view = success_view
+
+    render_rule_form
+  end
+
+  def validate_form_type form_type
+    return if form_type.in? %i[overlay modal]
+
+    raise "invalid rule_form type: #{form_type}; has to be overlay or modal"
+  end
+
+  def edit_rule_form success_view, &block
+    @rule_context ||= card
+    @edit_rule_success = edit_rule_success(success_view)
+    action_args = { action: :update, no_mark: true }
+    card_form action_args, rule_form_args, &block
+  end
+
+  def rule_form_args
+    { class: "card-rule-form", "data-slotter-mode": "update-origin" }
+  end
+
+  def edit_rule_success view="overlay_rule"
+    { id: @rule_context.name.url_key,
+      view: view }
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/rules/set/rule/rule_form.rb ~~

data/tmpsets/set/mod023-rules/rule/rule_form/buttons.rb

@@ -0,0 +1,55 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Rule; module RuleForm;
+# Set: All rule cards (RuleForm, Buttons)
+#
+module Buttons;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/rules/set/rule/rule_form/buttons.rb"; end
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  def edit_rule_buttons
+    wrap_with(:div, class: "button-area") do
+      [
+        standard_save_button(class: "_rule-submit-button"),
+        standard_save_and_close_button(class: "_rule-submit-button", close: form_type),
+        edit_rule_cancel_button,
+        edit_rule_delete_button
+      ]
+    end
+  end
+
+  def edit_rule_cancel_button
+    send "#{form_type}_close_button", "Cancel", situation: "secondary", class: "btn-sm"
+  end
+
+  def edit_rule_delete_button args={}
+    return if card.new_card?
+
+    delete_opts = {
+      confirm: delete_confirm(args[:fallback_set]),
+      # 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]
+    wrap_with :span, class: "rule-delete-section" do
+      delete_button delete_opts
+    end
+  end
+
+  def delete_confirm fallback_set
+    setting = card.rule_setting_name
+
+    if fallback_set && (fallback_set_card = Card.fetch(fallback_set))
+      "Deleting will revert to #{setting} rule for #{fallback_set_card.label}"
+    else
+      "Are you sure you want to delete the #{setting} rule for #{rule_set_description}?"
+    end
+  end
+
+  def edit_rule_submit_button
+    submit_button class: "_rule-submit-button"
+  end
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/rules/set/rule/rule_form/buttons.rb ~~

data/tmpsets/set/mod023-rules/rule/rule_form/form_elements.rb

@@ -0,0 +1,61 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Rule; module RuleForm;
+# Set: All rule cards (RuleForm, FormElements)
+#
+module FormElements;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/rules/set/rule/rule_form/form_elements.rb"; end
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  #### DEPRECATED
+
+  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 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 option_list title
+    formgroup title, input: "set", class: "col-xs-6", help: false do
+      wrap_with :ul do
+        wrap_each_with(:li, class: "radio") { yield }
+      end
+    end
+  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
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/rules/set/rule/rule_form/form_elements.rb ~~

data/tmpsets/set/mod023-rules/rule/rule_form/rule_set_radio.rb

@@ -0,0 +1,91 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Rule
+# Set: All rule cards (RuleForm)
+#
+#! no set module
+module RuleForm;
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/rules/set/rule/rule_form/rule_set_radio.rb"; end
+class RuleSetRadio
+  attr_reader :format
+  delegate :link_to_card, :radio_button, :wrap_with, :icon_tag,
+           to: :format
+
+  # @param state [:current, :overwritten]
+  def initialize format, set_name, tag, state
+    @format = format
+    @card = format.card
+    @set_name = set_name
+    @tag = tag
+    @state = state
+  end
+
+  def html narrower
+    @narrower_rules = narrower
+
+    rule_radio do
+      radio_text = "#{@set_name}+#{@tag}"
+      radio_button :name, radio_text, checked: false, warning: warning
+    end
+  end
+
+  private
+
+  def current?
+    @state == :current
+  end
+
+  def overwritten?
+    @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
+  end
+
+  def label
+    label = Card.fetch(@set_name).label
+    label += " <em>#{extra_info}</em>".html_safe if extra_info
+    label
+  end
+
+  def extra_info
+    case @state
+    when :current
+      "(current)"
+    when :overwritten, :exists
+      link_to_card "#{@set_name}+#{@card.rule_user_setting_name}", "(#{@state})",
+                   target: "_blank"
+    end
+  end
+
+  def warning
+    if @set_name == "*all"
+      "This rule will affect all cards! Are you sure?"
+    else
+      narrower_warning
+    end
+  end
+
+  # warn user if rule change won't have a effect on the current card
+  # because there is a narrower rule
+  def narrower_warning
+    return unless @state.in? %i[current overwritten]
+
+    @narrower_rules << Card.fetch(@set_name).uncapitalized_label
+    return unless @state == :overwritten
+
+    narrower_warning_message
+  end
+
+  def narrower_warning_message
+    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
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/rules/set/rule/rule_form/rule_set_radio.rb ~~

data/tmpsets/set/mod023-rules/rule/rule_form/set_selection.rb

@@ -0,0 +1,48 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Rule; module RuleForm;
+# Set: All rule cards (RuleForm, SetSelection)
+#
+module SetSelection;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/rules/set/rule/rule_form/set_selection.rb"; end
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  def bridge_rule_set_selection
+    wrap_with :div, class: "set-list" do
+      bridge_rule_set_formgroup
+    end
+  end
+
+  def bridge_rule_set_formgroup
+    tag = @rule_context.rule_user_setting_name
+    narrower = []
+
+    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
+    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
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/rules/set/rule/rule_form/set_selection.rb ~~

data/tmpsets/set/mod023-rules/rule/rules.rb

@@ -0,0 +1,101 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Rule
+# Set: All rule cards (Rules)
+#
+module Rules;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/rules/set/rule/rules.rb"; end
+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
+  end
+end
+
+def rule_set_key
+  rule_set_name.key
+end
+
+def rule_set_name
+  if is_preference?
+    name.trunk_name.trunk_name
+  else
+    name.trunk_name
+  end
+end
+
+def rule_set_pattern_name
+  rule_set_name.tag_name
+end
+
+def rule_set
+  if is_preference?
+    self[0..-3]
+  else
+    trunk
+  end
+end
+
+def rule_setting
+  right
+end
+
+def rule_setting_name
+  name.tag
+end
+
+def short_help_text
+  Card[rule_setting_name].short_help_text
+end
+
+def rule_setting_title
+  rule_setting_name.tr "*", ""
+end
+
+def rule_user_setting_name
+  if is_preference?
+    "#{rule_user_name}+#{rule_setting_name}"
+  else
+    rule_setting_name
+  end
+end
+
+# ~~~~~~~~~~ determine the set options to which a user can apply the rule.
+def set_options
+  candidates = set_prototype.set_names
+  first = first_set_option_index candidates
+  tally = { existing: 0, options: [] }
+  candidates[first..-1].each do |set_name|
+    tally_set_option set_name, tally
+  end
+  tally[:options]
+end
+
+def tally_set_option set_name, tally
+  state =
+    if Card.exists?("#{set_name}+#{rule_user_setting_name}")
+      tally[:existing] += 1
+      tally[:existing] == 1 ? :current : :overwritten
+    else
+      tally[:existing] < 1 ? :enabled : :disabled
+    end
+  tally[:options] << [set_name, state]
+end
+
+# the narrowest rule should be the one attached to the set being viewed.
+# So, eg, if you're looking at the '*all plus' set, you shouldn't
+# have the option to create rules based on arbitrary narrower sets, though
+# narrower sets will always apply to whatever prototype we create
+def first_set_option_index candidates
+  new_card? ? 0 : candidates.index { |c| c.to_name.key == rule_set_key }
+end
+
+def set_prototype
+  if is_preference?
+    self[0..-3].prototype
+  else
+    trunk.prototype
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/rules/set/rule/rules.rb ~~