card 1.101.2 → 1.102.0

data/mod/core/set/all/codename.rb

@@ -19,11 +19,12 @@ private
 def validate_codename_permission
   return if Auth.always_ok? || Auth.as_id == creator_id
 
-  errors.add :codename, tr(:only_admins_codename)
+  errors.add :codename, t(:core_only_admins_codename)
 end
 
 def validate_codename_uniqueness
   return (self.codename = nil) if codename.blank?
   return if errors.present? || !Card.find_by_codename(codename)
-  errors.add :codename, tr(:error_code_in_use, codename: codename)
+
+  errors.add :codename, t(:core_error_code_in_use, codename: codename)
 end

data/mod/core/set/all/collection.rb

@@ -1,10 +1,8 @@
 # shared methods for card collections (Pointers, Searches, Sets, etc.)
 module ClassMethods
-  def search spec, comment=nil
+  def search spec, comment=nil, &block
     results = ::Card::Query.run(spec, comment)
-    if block_given? && results.is_a?(Array)
-      results.each { |result| yield result }
-    end
+    results.each(&block) if block_given? && results.is_a?(Array)
     results
   end
 
@@ -14,22 +12,22 @@ module ClassMethods
     search spec.merge(return: "count")
   end
 
-  def find_each options={}
+  def find_each **options, &block
     # this is a copy from rails (3.2.16) and is needed because this
     # is performed by a relation (ActiveRecord::Relation)
-    find_in_batches(options) do |records|
-      records.each { |record| yield record }
+    find_in_batches(**options) do |records|
+      records.each(&block)
     end
   end
 
-  def find_in_batches options={}
+  def find_in_batches **options
     if block_given?
-      super(options) do |records|
+      super do |records|
         yield(records)
         Card::Cache.reset_soft
       end
     else
-      super(options)
+      super
     end
   end
 end

data/mod/core/set/all/content.rb

@@ -1,127 +1,3 @@
-def content= value
-  self.db_content = standardize_content(value)
-end
-
-def content
-  structured_content || standard_content
-end
-alias raw_content content #DEPRECATED!
-
-def content?
-  content.present?
-end
-
-def standard_content
-  db_content || (new_card? && template.db_content)
-end
-
-def standardize_content value
-  value.is_a?(Array) ? value.join("\n") : value
-end
-
-def structured_content
-  structure && template.db_content
-end
-
-def refresh_content
-  self.content = Card.find(id)&.db_content
-end
-
-format do
-  ONE_LINE_CHARACTER_LIMIT = 60
-
-  def chunk_list # override to customize by set
-    :default
-  end
-
-  view :one_line_content do
-    with_nest_mode :compact do
-      one_line_content
-    end
-  end
-
-  # DEPRECATED
-  view :closed_content, :one_line_content
-
-  view :raw_one_line_content do
-    raw_one_line_content
-  end
-
-  view :label do
-    card.label.to_s
-  end
-
-  view :smart_label, cache: :never, unknown: true do
-    label_with_description render_label, label_description
-  end
-
-  def label_with_description label, description
-    return label unless description
-
-    "#{label} #{popover_link description}"
-  end
-
-  # TODO: move this into a nest once popovers are stub safe
-  def label_description
-    return unless (desc = card.field :description)
-
-    desc.format.render_core
-  end
-
-  def raw_one_line_content
-    cut_with_ellipsis render_raw
-  end
-
-  def one_line_content
-    Card::Content.smart_truncate render_core
-  end
-
-  def cut_with_ellipsis text, limit=one_line_character_limit
-    if text.size <= limit
-      text
-    else
-      text[0..(limit - 3)] + "..."
-    end
-  end
-
-  def one_line_character_limit
-    voo.size || ONE_LINE_CHARACTER_LIMIT
-  end
-end
-
-format :html do
-  view :hidden_content_field, unknown: true, cache: :never do
-    hidden_field :content, class: "d0-card-content"
-  end
-end
-
-# seems like this should be moved to format so we can fall back on title
-# rather than name. (In fact, name, title, AND label is a bit much.
-# Trim to 2?)
-def label
-  name
-end
-
-def creator
-  Card[creator_id]
-end
-
-def updater
-  Card[updater_id]
-end
-
-def save_content_draft _content
-  clear_drafts
-end
-
-def clear_drafts
-  drafts.created_by(Card::Auth.current_id).each(&:delete)
-end
-
-def last_draft_content
-  drafts.last.card_changes.last.value
-end
-
 event :set_content, :store, on: :save do
   self.db_content = prepare_db_content
   @selected_action_id = @selected_content = nil
@@ -143,6 +19,22 @@ def draft?
   Env.params["draft"] == "true"
 end
 
+def clean_html?
+  true
+end
+
+def use_default_content?
+  !db_content_changed? && template && template.db_content.present?
+end
+
+def unfilled?
+  blank_content? && blank_comment? && !subcards?
+end
+
+def blank_comment?
+  comment.blank? || comment.strip.blank?
+end
+
 def prepare_db_content
   cont = standard_db_content || "" # necessary?
   clean_html? ? Card::Content.clean!(cont) : cont
@@ -157,22 +49,17 @@ def standard_db_content
   end
 end
 
-def clean_html?
-  true
-end
-
-def use_default_content?
-  !db_content_changed? && template && template.db_content.present?
-end
-
-def unfilled?
-  blank_content? && blank_comment? && !subcards?
+# seems like this should be moved to format so we can fall back on title
+# rather than name. (In fact, name, title, AND label is a bit much.
+# Trim to 2?)
+def label
+  name
 end
 
-def blank_content?
-  content.blank? || content.strip.blank?
+def creator
+  Card[creator_id]
 end
 
-def blank_comment?
-  comment.blank? || comment.strip.blank?
+def updater
+  Card[updater_id]
 end

data/mod/core/set/all/debug.rb

@@ -3,21 +3,18 @@ def to_s
 end
 
 def inspect
-  tags = []
-  tags << "trash"    if trash
-  tags << "new"      if new_card?
-  tags << "frozen"   if frozen?
-  tags << "readonly" if readonly?
-  tags << "virtual"  if @virtual
-  tags << "set_mods_loaded" if @set_mods_loaded
-
   error_messages = errors.any? ? "<E*#{errors.full_messages * ', '}*>" : ""
-
-  "#<Card##{id}[#{debug_type}](#{name})#{error_messages}{#{tags * ','}}"
+  "#<Card##{id}[#{debug_type}](#{name})#{error_messages}{#{inspect_tags * ','}}"
 end
 
 private
 
+def inspect_tags
+  %w[trash new frozen readonly virtual set_mods_loaded].map do |tag|
+    tag if send "#{tag}?"
+  end.compact
+end
+
 def debug_type
   "#{type_code || ''}:#{type_id}"
 end

data/mod/core/set/all/initialize.rb

@@ -71,6 +71,10 @@ def include_set_modules
   self
 end
 
+def set_mods_loaded?
+  @set_mods_loaded == true
+end
+
 def uncacheable?
   @uncacheable == true
 end

data/mod/core/set/all/name_events.rb

@@ -3,123 +3,119 @@
 event :validate_name, :validate, on: :save, changed: :name, when: :no_autoname? do
   validate_legality_of_name
   return if errors.any?
+
   Card.write_to_soft_cache self
   validate_uniqueness_of_name
 end
 
+# called by validate_name
 event :validate_uniqueness_of_name, skip: :allowed do
-  # validate uniqueness of name
-
   return unless (existing_id = Card::Lexicon.id key) && existing_id != id
   # The above is a fast check but cannot detect if card is in trash
 
   # TODO: perform the following as a remote-only fetch (not yet supported)
   return unless (existing_card = Card.where(id: existing_id, trash: false).take)
 
-  errors.add :name, tr(:error_name_exists, name: existing_card.name)
+  errors.add :name, t(:core_error_name_exists, name: existing_card.name)
 end
 
+# called by validate_name
 event :validate_legality_of_name do
   if name.length > 255
-    errors.add :name, tr(:error_too_long, length: name.length)
+    errors.add :name, t(:core_error_too_long, length: name.length)
   elsif name.blank?
-    errors.add :name, tr(:error_blank_name)
+    errors.add :name, t(:core_error_blank_name)
   elsif name_incomplete?
-    errors.add :name, tr(:is_incomplete)
+    errors.add :name, t(:core_is_incomplete)
   elsif !name.valid?
-    errors.add :name, tr(:error_banned_characters, banned: Card::Name.banned_array * " ")
-  elsif changing_existing_tag_to_junction?
-    errors.add :name, tr(:error_name_tag, name: name)
+    errors.add :name, t(:core_error_banned_characters,
+                        banned: Card::Name.banned_array * " ")
+  elsif changing_existing_tag_to_compound?
+    errors.add :name, t(:core_error_name_tag, name: name)
   end
 end
 
 event :validate_key, after: :validate_name, on: :save, when: :no_autoname? do
   if key.empty?
-    errors.add :key, tr(:error_blank_key) if errors.empty?
+    errors.add :key, t(:core_error_blank_key) if errors.empty?
   elsif key != name.key
-    errors.add :key, tr(:error_wrong_key, key: key, name: name)
+    errors.add :key, t(:core_error_wrong_key, key: key, name: name)
   end
 end
 
-# STAGE: store
+event :validate_renaming, :validate, on: :update, changed: :name, skip: :allowed do
+  return if name_before_act&.to_name == name # just changing to new variant
 
-event :set_autoname, :prepare_to_store, on: :create, when: :autoname? do
-  self.name = autoname rule(:autoname)
-  autoname_card = rule_card :autoname
-  autoname_card.update_column :db_content, name
-  autoname_card.expire
-  pull_from_trash!
-  Card.write_to_soft_cache self
+  errors.add :content, t(:core_cannot_change_content) if content_is_changing?
+  errors.add :type, t(:core_cannot_change_type) if type_is_changing?
+  detect_illegal_compound_names
 end
 
+# STAGE: store
+
 event :expire_old_name, :store, changed: :name, on: :update do
   Director.expirees << name_before_act
 end
 
-event :update_lexicon_on_create, :finalize, changed: :name, on: :create do
-  Card::Lexicon.add self
-end
+event :rename_in_trash, after: :expire_old_name, on: :update do
+  existing_card = Card.find_by_key_and_trash name.key, true
+  return if !existing_card || existing_card == self
 
-event :update_lexicon_on_rename, :finalize, changed: :name, on: :update do
-  Card::Lexicon.update self
-end
-
-def lex
-  simple? ? name : [left_id, right_id]
-end
-
-def old_lex
-  if (old_left_id = left_id_before_act)
-    [old_left_id, right_id_before_act]
-  else
-    name_before_act
-  end
+  existing_card.rename_as_trash_obstacle
 end
 
 event :prepare_left_and_right, :store, changed: :name, on: :save do
   return if name.simple?
+
   prepare_side :left
   prepare_side :right
 end
 
-def prepare_side side
-  side_id = send "#{side}_id"
-  sidename = name.send "#{side}_name"
-  prepare_obstructed_side(side, side_id, sidename) ||
-    prepare_new_side(side, side_id, sidename)
+event :update_lexicon, :finalize, changed: :name, on: :save do
+  lexicon_action = @action == :create ? :add : :update
+  Card::Lexicon.send lexicon_action, self
 end
 
-def prepare_new_side side, side_id, sidename
-  return unless side_id == -1 || !Card[side_id]&.real?
+event :cascade_name_changes, :finalize, on: :update, changed: :name do
+  each_descendant { |d| d.rename_as_descendant update_referers }
+end
 
-  sidecard = Director.card(sidename) || add_subcard(sidename)
-  send "#{side}_id=", sidecard
+protected
+
+def rename_as_trash_obstacle
+  self.name = "#{name}*trash"
+  rename_in_trash_without_callbacks
+  save!
 end
 
-def prepare_obstructed_side side, side_id, sidename
-  return unless side_id && side_id == id
-  clear_name sidename
-  send "#{side}_id=", add_subcard(sidename)
-  true
+def rename_as_descendant referers=true
+  self.action = :update
+  referers ? update_referers : update_referer_references_out
+  refresh_references_in
+  refresh_references_out
+  expire
+  Card::Lexicon.update self
 end
 
+private
+
 def name_incomplete?
   name.parts.include?("") && !superleft&.autoname?
 end
 
-def no_autoname?
-  !autoname?
+def changed_from_simple_to_compound?
+  name.compound? && name_before_act.to_name.simple?
 end
 
-def autoname?
-  name.blank? &&
-    (@autoname_rule.nil? ? (@autoname_rule = rule(:autoname).present?) : @autoname_rule)
+def detect_illegal_compound_names
+  return unless changed_from_simple_to_compound? && child_ids(:right).present?
+
+  errors.add :name, "illegal name change; existing names end in +#{name_before_act}"
 end
 
-private
+def changing_existing_tag_to_compound?
+  return false unless changing_name_to_compound?
 
-def changing_existing_tag_to_junction?
-  return false unless changing_name_to_junction?
   name_in_use_as_tag?
 end
 
@@ -127,8 +123,8 @@ def name_in_use_as_tag?
   !Card.where(right_id: id, trash: false).take.nil?
 end
 
-def changing_name_to_junction?
-  name.junction? && simple?
+def changing_name_to_compound?
+  name.compound? && simple?
 end
 
 def old_name_in_way? sidecard
@@ -143,3 +139,25 @@ def clear_name name
   Card::Lexicon.cache.reset # probably overkill, but this for an edge case...
   # Card::Lexicon.delete id, key
 end
+
+def prepare_side side
+  side_id = send "#{side}_id"
+  sidename = name.send "#{side}_name"
+  prepare_obstructed_side(side, side_id, sidename) ||
+    prepare_new_side(side, side_id, sidename)
+end
+
+def prepare_new_side side, side_id, sidename
+  return unless side_id == -1 || !Card[side_id]&.real?
+
+  sidecard = Director.card(sidename) || add_subcard(sidename)
+  send "#{side}_id=", sidecard
+end
+
+def prepare_obstructed_side side, side_id, sidename
+  return unless side_id && side_id == id
+
+  clear_name sidename
+  send "#{side}_id=", add_subcard(sidename)
+  true
+end