card 1.101.2 → 1.102.0

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

@@ -0,0 +1,69 @@
+# test for updating referer content
+event :prepare_referer_update, :validate, on: :update, changed: :name do
+  self.update_referers = ![nil, false, "false"].member?(update_referers)
+end
+
+# on rename, update names in cards that refer to self by name (as directed)
+event :update_referer_content, :finalize, on: :update, when: :update_referers do
+  referers.each do |card|
+    next if card.structure
+
+    card.skip_event! :validate_renaming, :check_permissions
+    card.content = card.replace_references name_before_act, name
+    attach_subcard card
+  end
+end
+
+# on rename, when NOT updating referer content, update references to ensure
+# that partial references are correctly tracked
+# eg.  A links to X+Y.  if X+Y is renamed and we're not updating the link in A,
+# then we need to be sure that A has a partial reference
+event :update_referer_references_out, :finalize,
+      changed: :name, on: :update, when: :not_update_referers do
+  referers.map(&:update_references_out)
+end
+
+# when name changes, update references to card
+event :refresh_references_in, :finalize, changed: :name, on: :save do
+  Reference.unmap_referees id if action == :update && !update_referers
+  Reference.map_referees key, id
+end
+
+# when content changes, update references to other cards
+event :refresh_references_out, :finalize, on: :save, changed: :content do
+  update_references_out
+end
+
+# clean up reference table when card is deleted
+event :clear_references, :finalize, on: :delete do
+  delete_references_out
+  Reference.unmap_referees id
+end
+
+# replace references in card content
+def replace_references old_name, new_name
+  cont = content_object
+  cont.find_chunks(:Reference).each do |chunk|
+    next unless replace_reference chunk, old_name, new_name
+  end
+  cont.to_s
+end
+
+protected
+
+def not_update_referers
+  !update_referers
+end
+
+private
+
+def replace_reference chunk, old_name, new_name
+  return unless (old = chunk.referee_name) && (new = old.swap old_name, new_name)
+
+  chunk.referee_name = chunk.replace_reference old_name, new_name
+  update_reference old.key, new.key
+end
+
+def update_reference old_key, new_key
+  Reference.where(referee_key: old_key).update_all referee_key: new_key
+end

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

@@ -17,8 +17,8 @@ module ClassMethods
   def real? mark
     quick_fetch(mark).present?
   end
-  alias exist? real?
-  alias exists? real?
+  alias_method :exist?, :real?
+  alias_method :exists?, :real?
 
   def known? mark
     fetch(mark).present?
@@ -71,8 +71,8 @@ def new?
   new_record? ||       # not yet in db (from ActiveRecord)
     !@from_trash.nil?  # in process of restoration from trash
 end
-alias new_card? new?
-alias unreal? new?
+alias_method :new_card?, :new?
+alias_method :unreal?, :new?
 
 # has not been edited directly by human users.  bleep blorp.
 def pristine?
@@ -81,4 +81,4 @@ end
 
 def user_changes?
   actions.joins(:act).where("card_acts.actor_id != ?", WagnBotID).exists?
-end
+end

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

@@ -1,107 +1,7 @@
-def field tag, opts={}
-  Card.fetch name.field(tag), opts
-end
-
-def subcard card_name
-  subcards.card card_name
-end
-
-def subfield field_name
-  subcards.field field_name
-end
-
-def field? tag
-  field(tag) || subfield(tag)
-end
-
-def subcards
-  @subcards ||= Card::Subcards.new self
-end
-
-def subcards?
-  subcards.present?
-end
-
-def expire_subcards
-  subcards.clear
-end
-
-# phase_method :attach_subcard, before: :store do |name_or_card, args=nil|
-# TODO: handle differently in different stages
-def add_subcard name_or_card, args={}
-  subcards.add name_or_card, args
-end
-alias_method :attach_subcard, :add_subcard
-
-def add_subcard! name_or_card, args={}
-  subcard = subcards.add name_or_card, args
-  subcard.director.reset_stage
-  subcard
-end
-alias_method :attach_subcard!, :add_subcard!
-
-# phase_method :attach_subfield, before: :approve do |name_or_card, args=nil|
-def attach_subfield name_or_card, args={}
-  subcards.add_field name_or_card, args
-end
-alias_method :add_subfield, :attach_subfield
-
-def attach_subfield! name_or_card, args={}
-  subcard = subcards.add_field name_or_card, args
-  subcard.director.reset_stage
-  subcard
-end
-
-def detach_subcard name_or_card
-  subcards.remove name_or_card
-end
-alias_method :remove_subcard, :detach_subcard
-
-def detach_subfield name_or_card
-  subcards.remove_field name_or_card
-end
-alias_method :remove_subfield, :detach_subfield
-
-def clear_subcards
-  subcards.clear
-end
-
-# ensures subfield is present
-# does NOT override subfield content if already present
-def ensure_subfield field_name, args={}
-  if subfield_present? field_name
-    subfield field_name
-  else
-    add_subfield field_name, args
-  end
-end
-
-def subfield_present? field_name
-  subfield(field_name)&.content&.present?
-end
-
-def deep_clear_subcards
-  subcards.deep_clear
-end
-
-def handle_subcard_errors
-  subcards.each do |subcard|
-    subcard.errors.each do |error|
-      subcard_error subcard, error
-    end
-    subcard.errors.clear
-  end
-end
-
-def subcard_error subcard, error
-  msg = error.message
-  msg = "#{error.attribute} #{msg}" unless %i[content abort].member? error.attribute
-  errors.add subcard.name.from(name), msg
-end
-
 event :reject_empty_subcards, :prepare_to_validate do
   subcards.each_with_key do |subcard, key|
     next unless subcard.new? && subcard.unfilled?
+
     remove_subcard(key)
     director.subdirectors.delete(subcard)
   end

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

@@ -29,15 +29,17 @@ module ClassMethods
     # TODO: handle cloud files
     return unless dir
 
-    trashed_card_ids = all_trashed_card_ids
-    file_ids = all_file_ids
-    file_ids.each do |file_id|
-      next unless trashed_card_ids.member?(file_id)
-      raise Card::Error, tr(:exception_almost_deleted) if Card.exists?(file_id)
-      ::FileUtils.rm_rf "#{dir}/#{file_id}", secure: true
+    (all_trashed_card_ids & all_file_ids).each do |file_id|
+      delete_files_with_id dir, file_id
     end
   end
 
+  def delete_files_with_id dir, file_id
+    raise Card::Error, t(:core_exception_almost_deleted) if Card.exists?(file_id)
+
+    ::FileUtils.rm_rf "#{dir}/#{file_id}", secure: true
+  end
+
   def all_file_ids
     dir = Card.paths["files"].existent.first
     Dir.entries(dir)[2..-1].map(&:to_i)
@@ -50,6 +52,10 @@ module ClassMethods
   end
 end
 
+def trash?
+  trash
+end
+
 def delete args={}
   add_to_trash args do |delete_args|
     update delete_args
@@ -64,6 +70,7 @@ end
 
 def add_to_trash args
   return if new_card?
+
   yield args.merge trash: true
 end
 
@@ -76,6 +83,7 @@ end
 def pull_from_trash!
   return unless (id = Card::Lexicon.id key) # name is already known
   return unless (trashed_card = Card.where(id: id).take)&.trash
+
   # confirm name is actually in trash
 
   db_attributes["id"] = trashed_card.db_attributes["id"]
@@ -91,28 +99,26 @@ end
 
 event :validate_delete, :validate, on: :delete do
   unless codename.blank?
-    errors.add :delete, tr(:error_system_card, name: name, codename: codename)
+    errors.add :delete, t(:core_error_system_card, name: name, codename: codename)
   end
 
   undeletable_all_rules_tags =
     %w[default style layout create read update delete]
   # FIXME: HACK! should be configured in the rule
 
-  if junction? && left&.codename == :all &&
+  if compound? && left&.codename == :all &&
      undeletable_all_rules_tags.member?(right.codename.to_s)
-    errors.add :delete, tr(:error_indestructible, name: name)
+    errors.add :delete, t(:core_error_indestructible, name: name)
   end
 
-  errors.add :delete, tr(:error_user_edits, name: name) if account && has_edits?
+  errors.add :delete, t(:core_error_user_edits, name: name) if account && has_edits?
 end
 
 event :validate_delete_children, after: :validate_delete, on: :delete do
   return if errors.any?
-  each_child do |child|
-    next unless child
-    # prevents errors in cases where a child is deleted prior to this point
-    # and thus is not returned by the fetch in #children
 
+  each_child do |child|
+    child.include_set_modules
     delete_as_subcard child
     # next if child.valid?
     # child.errors.each do |field, message|

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

@@ -1,4 +1,3 @@
-
 module ClassMethods
   def default_type_id
     @@default_type_id ||= Card[:all].fetch(:default, skip_modules: true).type_id
@@ -7,6 +6,7 @@ end
 
 def type_card
   return if type_id.nil?
+
   Card.quick_fetch type_id.to_i
 end
 
@@ -29,7 +29,7 @@ def type_cardname
 end
 
 def type= type_name
-  self.type_id = Card.fetch_id type_name
+  self.type_id = type_name.card_id
 end
 
 def type_id= card_or_id
@@ -38,24 +38,24 @@ end
 
 def type_id_from_template
   return unless name && (t = template)
+
   reset_patterns # still necessary even with new template handling?
   self.type_id = t.type_id
 end
 
 event :validate_type_change, :validate, on: :update, changed: :type_id do
-  if (c = dup) && c.action == :create && !c.valid?
-    errors.add :type, tr(
-      :error_cant_change_errors,
-      name: name, type_id: type_id,
-      error_messages: c.errors.full_messages
-    )
-  end
+  return unless (c = dup) && c.action == :create && !c.valid?
+
+  errors.add :type, t(:core_error_cant_change_errors,
+                      name: name,
+                      type_id: type_id,
+                      error_messages: c.errors.full_messages)
 end
 
 event :validate_type, :validate, changed: :type_id, on: :save do
-  errors.add :type, tr(:error_no_such_type) unless type_name
+  errors.add :type, t(:core_error_no_such_type) unless type_name
 
   if (rt = structure) && rt.assigns_type? && type_id != rt.type_id
-    errors.add :type, tr(:error_hard_templated, name: name, type_name: rt.type_name)
+    errors.add :type, t(:core_error_hard_templated, name: name, type_name: rt.type_name)
   end
 end

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

@@ -41,7 +41,7 @@ module ClassMethods
 
   def resolve_file_attributes! attribs
     %i[image file].each do |attach|
-      next unless attribs[attach] && attribs[attach].is_a?(String)
+      next unless attribs[attach].is_a?(String)
 
       attribs[attach] = ::File.open(attribs[attach])
     end
@@ -87,6 +87,9 @@ def mod_root modname
   end
 end
 
+delegate :t, to: Cardio
+
 format do
+  delegate :t, to: Cardio
   delegate :measure, to: :card
 end

data/mod/core/set/self/trash.rb

@@ -0,0 +1,64 @@
+format :html do
+  view :core do
+    rows = trashed_cards.map { |tc| trash_table_row(tc) }
+    output [
+      restored,
+      (empty_trash_link if rows.present?),
+      table(rows, header: ["card", "deleted", "by", ""])
+    ]
+  end
+
+  def trashed_cards
+    Card.where(trash: true).order(updated_at: :desc)
+  end
+
+  def trash_table_row card
+    [
+      card.name,
+      "#{time_ago_in_words(card.updated_at)} ago",
+      Card[card.updater_id].name,
+      "#{history_link(card)} | #{restore_link(card)}"
+    ]
+  end
+
+  def restored
+    return unless (res_id = Env.params[:restore]) &&
+                  (res_card = Card[res_id.to_i])
+
+    alert :success, true do
+      wrap_with(:h5, "restored") + subformat(res_card).render_bar
+    end
+  end
+
+  def empty_trash_link
+    wrap_with(
+      :p,
+      button_link("empty trash",
+                  btn_type: :default,
+                  path: { mark: :admin, action: :update, task: :empty_trash,
+                          success: { mark: "~#{card.id}" } },
+                  "data-confirm" => "Are you sure you want to delete "\
+                                    "all cards in the trash?")
+    )
+  end
+
+  def history_link trashed_card
+    link_to_card trashed_card, "history",
+                 path: { view: :history, look_in_trash: true }
+  end
+
+  def restore_link trashed_card
+    before_delete = trashed_card.actions[-2]
+    link_to "restore", method: :post,
+                       rel: "nofollow",
+                       remote: true,
+                       class: "slotter",
+                       path: { id: trashed_card.id,
+                               view: :open,
+                               look_in_trash: true,
+                               action: :update,
+                               restore: trashed_card.id,
+                               action_ids: [before_delete],
+                               success: { mark: "~#{card.id}" } }
+  end
+end

data/mod/core/set/self/version.rb

@@ -1,7 +1,5 @@
 # -*- encoding : utf-8 -*-
 
-# require "card/version"
-
 def ok_to_read
   true
 end
@@ -9,5 +7,3 @@ end
 def content
   Card::Version.release
 end
-
-# view :core, :raw

data/mod/core/set/type/cardtype.rb

@@ -11,18 +11,18 @@ def was_cardtype?
 end
 
 event :check_for_cards_of_type, after: :validate_delete do
-  errors.add :cardtype, tr(:cards_exist, cardname: name) if cards_of_type_exist?
+  errors.add :cardtype, t(:core_cards_exist, cardname: name) if cards_of_type_exist?
 end
 
 event :check_for_cards_of_type_when_type_changed,
       :validate, changing: :type, when: :was_cardtype? do
   if cards_of_type_exist?
-    errors.add :cardtype, tr(:error_cant_alter, name: name_before_act)
+    errors.add :cardtype, t(:core_error_cant_alter, name: name_before_act)
   end
 end
 
 event :validate_cardtype_name, :validate, on: :save, changed: :name do
   if %r{[<>/]}.match?(name)
-    errors.add :name, tr(:error_invalid_character_in_cardtype, banned: "<, >, /")
+    errors.add :name, t(:core_error_invalid_character_in_cardtype, banned: "<, >, /")
   end
 end