card 1.97.0.1 → 1.98.0

data/tmpsets/set/mod022-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, editor: "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/mod022-rules/rule/rule_form/rule_set_radio.rb

@@ -0,0 +1,94 @@
+# -*- 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: checked?, 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})"
+    end
+  end
+
+  def checked?
+    [@set_name, true].include? @format.selected_rule_set
+  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/mod022-rules/rule/rule_form/set_selection.rb

@@ -0,0 +1,55 @@
+# -*- 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 "", editor: "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
+
+  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
+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/mod022-rules/rule/rules.rb

@@ -0,0 +1,93 @@
+# -*- 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 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
+  if is_preference?
+    self[0..-3]
+  else
+    trunk
+  end
+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 ~~

data/tmpsets/set/mod022-rules/rule/table.rb

@@ -0,0 +1,36 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Rule
+# Set: All rule cards (Table)
+#
+module Table;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/rules/set/rule/table.rb"; end
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  view :open_rule, cache: :never, unknown: true,
+                   wrap: { modal: { size: :large,
+                                    title: :edit_rule_title,
+                                    footer: "" } } do
+    current_rule_form success_view: :rule_row, form_type: :modal
+  end
+
+  def edit_rule_title
+    output [
+      wrap_with(:h5, setting_title, class: "title font-weight-bold"),
+      render_overlay_rule_help
+    ]
+  end
+
+  # used in tables shown in set cards' core view
+  view :rule_row, cache: :never, unknown: true do
+    rule_card = find_existing_rule_card
+    cols = %i[setting set]
+    cols.insert(1, :content) if voo.show? :content
+    wrap_closed_rule rule_card do
+      cols.map do |cell|
+        send "closed_rule_#{cell}_cell", rule_card
+      end
+    end
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/rules/set/rule/table.rb ~~

data/tmpsets/set/mod022-rules/rule/table_row.rb

@@ -0,0 +1,72 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Rule
+# Set: All rule cards (TableRow)
+#
+module TableRow;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/rules/set/rule/table_row.rb"; end
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  view :rule_link, unknown: true do
+    rule_card = find_existing_rule_card
+    wrap_closed_rule rule_card do
+      %i[link set].map do |cell|
+        send "closed_rule_#{cell}_cell", rule_card
+      end
+    end
+  end
+
+  view :rule_modal_link, unknown: true do
+    rule_card = find_existing_rule_card
+      wrap_closed_rule rule_card do
+        %i[modal_link set].map do |cell|
+          send "closed_rule_#{cell}_cell", rule_card
+        end
+      end
+  end
+
+  def wrap_closed_rule rule_card
+    klass = rule_card&.real? ? "known-rule" : "missing-rule"
+    wrap(true, { class: "closed-rule #{klass}" }, :tr) { yield }
+  end
+
+  def closed_rule_link_cell _rule_card
+    wrap_rule_cell "rule-setting" do
+      opts = bridge_link_opts(class: "edit-rule-link")
+      opts[:path].delete(:layout)
+      link_to_view :overlay_rule, setting_title, opts
+    end
+  end
+
+  def closed_rule_modal_link_cell _rule_card
+    wrap_rule_cell "rule-setting" do
+      opts = bridge_link_opts(class: "edit-rule-link")
+      opts[:path].delete(:layout)
+      opts["data-modal-class"] = "modal-lg"
+      link_to_view :modal_rule, setting_title, opts
+    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 d-none d-sm-table-cell" do
+      rule_card ? rule_card.trunk.label : ""
+    end
+  end
+
+  def wrap_rule_cell css_class
+    wrap_with(:td, class: "rule-cell #{css_class}") { yield }
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/rules/set/rule/table_row.rb ~~

data/tmpsets/set/mod022-rules/self/script_rules.rb

@@ -0,0 +1,12 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Self
+# Set: The card "ScriptRules"
+#
+module ScriptRules;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/rules/set/self/script_rules.rb"; end
+include_set Abstract::CodeFile
+
+Self::ScriptMods.add_item :script_rules
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/rules/set/self/script_rules.rb ~~

data/tmpsets/set/mod022-rules/type/set.rb

@@ -0,0 +1,91 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Type
+# Set: All "Set" cards
+#
+module Set;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/rules/set/type/set.rb"; end
+include_set Type::SearchType
+
+def inheritable?
+  return true if junction_only?
+
+  name.trunk_name.junction? &&
+    name.tag_name.key == 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
+end
+
+def junction_only?
+  if @junction_only.nil?
+    @junction_only = subclass_for_set.junction_only
+  else
+    @junction_only
+  end
+end
+
+def label
+  if (klass = subclass_for_set)
+    klass.label name.left
+  else
+    ""
+  end
+end
+
+def uncapitalized_label
+  label = label.to_s
+  return label unless label[0]
+
+  label[0] = label[0].downcase
+  label
+end
+
+def all_user_ids_with_rule_for setting_code
+  Card.all_user_ids_with_rule_for self, setting_code
+end
+
+def setting_codenames_by_group
+  result = {}
+  Card::Setting.groups.each do |group, settings|
+    visible_settings =
+      settings.reject { |s| !s || !s.applies_to_cardtype(prototype.type_id) }
+    result[group] = visible_settings.map(&:codename) unless visible_settings.empty?
+  end
+  result
+end
+
+def visible_setting_codenames
+  @visible_setting_codenames ||= visible_settings.map(&:codename)
+end
+
+def visible_settings group=nil
+  settings =
+    (group && Card::Setting.groups[group]) || Card::Setting.groups.values.flatten.compact
+  settings.reject do |setting|
+    !setting || !setting.applies_to_cardtype(prototype.type_id)
+  end
+end
+
+def broader_sets
+  prototype.set_names[1..-1]
+end
+
+def prototype
+  opts = subclass_for_set.prototype_args name.trunk_name
+  Card.fetch opts[:name], new: opts
+end
+
+def related_sets with_self=false
+  if subclass_for_set.anchorless?
+    prototype.related_sets with_self
+  else
+    left(new: {}).related_sets with_self
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/rules/set/type/set.rb ~~