card-mod-rules 0.11.0

data/set/rule/rule_form/form_elements.rb

@@ -0,0 +1,52 @@
+format :html do
+  #### 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&.present?
+
+    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

data/set/rule/rule_form/rule_form.haml

@@ -0,0 +1,20 @@
+.guide-line.rule-section.mt-4
+  %h5
+    .guide-line-number 1
+    Define rule
+    -# = popover_link "Help text to explain this section"
+  .card-editor
+    = rules_type_formgroup
+    = rule_content_formgroup
+.rule-section
+  %h5
+    .guide-line-number 2
+    Apply to set
+    = popover_link "Each rule applies to a set of cards. Rules for more specific sets override rules for more general ones."
+  .card-editor
+    = bridge_rule_set_selection
+    = edit_rule_buttons
+
+-##app-5
+-#  %p {{ message }}
+-#  %button{'v-on:click': 'reverseMessage'} Reverse Message

data/set/rule/rule_form/rule_set_radio.rb

@@ -0,0 +1,83 @@
+#! no set module
+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

data/set/rule/rule_form/set_selection.rb

@@ -0,0 +1,39 @@
+format :html do
+  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

data/set/rule/rules.rb

@@ -0,0 +1,109 @@
+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
+  @set_options ||= [].tap do |set_options|
+    set_option_candidates.each do |set_name|
+      set_options << [set_name, state_of_set(set_name)]
+    end
+  end
+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
+
+private
+
+def set_option_candidates
+  candidates = set_prototype.set_names
+  first = first_set_option_index candidates
+  candidates[first..-1]
+end
+
+def state_of_set set_name
+  @sets_with_existing_rules ||= 0
+  if rule_for_set? set_name
+    @sets_with_existing_rules += 1
+    state_of_existing_set
+  else
+    state_of_nonexisting_set
+  end
+end
+
+def state_of_existing_set
+  @sets_with_existing_rules == 1 ? :current : :overwritten
+end
+
+def state_of_nonexisting_set
+  @sets_with_existing_rules == 1 ? :current : :overwritten
+end
+
+def rule_for_set? set_name
+  Card.exists?("#{set_name}+#{rule_user_setting_name}")
+end

data/set/self/cardtype.rb

@@ -0,0 +1,42 @@
+GROUP = {
+  "Text" => %w[RichText PlainText Markdown Phrase HTML],
+  "Data" => %w[Number Toggle Date URI],
+  "Upload" => %w[File Image],
+  "Custom" => [],
+  "Organize" => ["List", "Pointer", "Search", "Link list", "Nest list"],
+  "Template" => ["Notification template", "Email template", "Twitter template"],
+  "Admin" => ["Cardtype", "User", "Role", "Sign up", "Session", "Set", "Setting"],
+  "Styling" => ["Layout", "Skin", "Bootswatch skin", "Customized bootswatch skin",
+                "CSS", "SCSS"],
+  "Scripting" => %w[JSON JavaScript CoffeeScript]
+}.freeze
+
+# DEFAULT_RULE_GROUPS = ["Text", "Data", "Upload", "Organize - Search"]
+# STRUCTURE_RULE_GROUPS = ["Text", "Organize > Search"]
+
+# group for each cardtype: { "RichText => "Content", "Layout" => "Admin", ... }
+GROUP_MAP = GROUP.each_with_object({}) do |(cat, types), h|
+  types.each { |t| h[t] = cat }
+end
+
+format :html do
+  view :grouped_list do
+    GROUP.keys.map do |group|
+      type_list = group == "Custom" ? custom_types : GROUP[group]
+      next if type_list.empty?
+
+      [wrap_with(:h5, group), wrap_with(:p, listing(type_list))]
+    end.flatten.join "\n"
+  end
+
+  def custom_types
+    custom_types = []
+
+    Card.search(type_id: Card::CardtypeID, return: "name").each do |name|
+      next if ::Card::Set::Self::Cardtype::GROUP_MAP[name]
+
+      custom_types << name
+    end
+    custom_types
+  end
+end

data/set/self/recent_settings.rb

@@ -0,0 +1,7 @@
+def history?
+  false
+end
+
+def followable?
+  false
+end

data/set/self/script_rules.rb

@@ -0,0 +1,3 @@
+include_set Abstract::CodeFile
+
+Self::ScriptMods.add_item :script_rules

data/set/type/set.rb

@@ -0,0 +1,107 @@
+include_set Type::SearchType
+
+def anchor_name
+  name.left_name
+end
+
+def anchor
+  Card[anchor_name]
+end
+
+def pattern_name
+  name.tag_name
+end
+
+def pattern
+  tag
+end
+
+def inheritable?
+  junction_only? || (anchor_name&.junction? && self_set?)
+end
+
+def self_set?
+  pattern_name == Card::Set::Self.pattern.key
+end
+
+def subclass_for_set
+  current_set_pattern_code = pattern.codename
+  Card.set_patterns.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
+end
+
+def label
+  klass = subclass_for_set
+  klass ? klass.label(anchor_name) : ""
+end
+
+def uncapitalized_label
+  label = label.to_s
+  return label unless label[0]
+
+  label[0] = label[0].downcase
+  label
+end
+
+def rule_cache_key_base
+  if (l = left) && (r = right)
+    "#{l.id}+#{Codename[r.id]}"
+  else
+    Codename[id].to_s
+  end
+end
+
+def all_user_ids_with_rule_for setting_code
+  Card::Rule.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, cardtype_id=nil
+  cardtype_id ||= prototype.type_id
+  settings =
+    (group && Card::Setting.groups[group]) || Card::Setting.groups.values.flatten.compact
+  settings.reject do |setting|
+    !setting || !setting.applies_to_cardtype(cardtype_id)
+  end
+end
+
+def broader_sets
+  prototype.set_names[1..-1]
+end
+
+def prototype
+  opts = subclass_for_set.prototype_args anchor_name
+  Card.fetch opts[:name], new: opts
+end
+
+def prototype_default_type_id
+  prototype_default_card.type_id
+end
+
+def prototype_default_card
+  prototype.rule_card(:default)
+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