card 1.92.2 → 1.93.0

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

@@ -52,6 +52,10 @@ format do
     end
   end
 
+  def render_haml_partial partial, locals={}, a_binding=nil
+    render_haml "_#{partial}".to_sym, locals, a_binding
+  end
+
   # @todo Make this more like Rails a implicit feature of a view.
   #   For a start use a different view command. Example
   #   # view/type/basic/my_view.haml:

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

@@ -30,8 +30,8 @@ def handle_skip_args args
 end
 
 def initial_name name
-  name = Card.compose_mark name if name.is_a? Array
-  name.to_s
+  return name if name.is_a? String
+  Card::Name[name].to_s
 end
 
 def include_set_modules

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

@@ -13,54 +13,36 @@ module ClassMethods
   end
 
   # translates various inputs into either an id or a name.
-  #
-  # @param mark [Symbol, Integer, Card, String, or Card::Name]
+  # @param parts [Array<Symbol, Integer, String, Card::Name, Card>] a mark or mark parts
   # @return [Integer or Card::Name]
-  def id_or_name mark
+  def id_or_name parts
+    mark = parts.flatten
+    mark = mark.first if mark.size <= 1
+    id_from_mark(mark) || name_from_mark(mark)
+  end
+
+  def id_from_mark mark
     case mark
-    when Symbol            then id_from_codename! mark
-    when Integer           then mark
-    when Card              then mark.cardname
-    when nil               then "".to_name
-    when String, Cardname  then id_or_name_from_string mark.to_s
-    # there are some situations where this breaks if we use Card::Name
-    # rather than Cardname, which would seem more correct.
-    # very hard to reproduce, not captured in a spec :(
+    when Integer then mark
+    when Symbol  then Card::Codename.id! mark
+    when String  then id_from_string mark
     end
   end
 
-  # translates string identifiers into an id or name, including:
+  # translates string identifiers into an id:
   #   - string id notation (eg "~75")
   #   - string codename notation (eg ":options")
   #
   # @param mark [String]
-  # @return [Integer or Card::Name]
-  def id_or_name_from_string mark
+  # @return [Integer or nil]
+  def id_from_string mark
     case mark
     when /^\~(\d+)$/  then  Regexp.last_match[1].to_i
-    when /^\:(\w+)$/  then  id_from_codename!Regexp.last_match[1].to_sym
-    else                    mark.to_name
+    when /^\:(\w+)$/  then  Card::Codename.id! Regexp.last_match[1]
     end
   end
 
-  # @param parts [Array] of mark or mark parts
-  # @return [Integer or Card::Name]
-  def compose_mark parts
-    parts.flatten!
-    return id_or_name(parts.first) if parts.size == 1
-    parts.map do |part|
-      Card::Name.cardish id_or_name(part)
-    end.join("+").to_name
-  end
-
-  # @param codename [Symbol]
-  # @return [Integer]
-  def id_from_codename! codename
-    Card::Codename[codename] || missing_codename!
+  def name_from_mark mark
+    Card::Name[mark]
   end
-
-  def missing_codename!
-    raise Card::Error::NotFound, "missing card with codename: #{mark}"
-  end
-
 end

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

@@ -20,6 +20,10 @@ module ClassMethods
   end
 end
 
+def name
+  super.to_name
+end
+
 def name= newname
   cardname = superize_name newname.to_name
   newkey = cardname.key
@@ -55,23 +59,19 @@ def update_subcard_names new_name, name_to_replace=nil
     # +C should change to A+B+C. #replace doesn't work in this case
     # because the old name +B is not a part of +C
     name_to_replace ||=
-      if subcard.cardname.junction? &&
-         subcard.cardname.parts.first.empty? &&
+      if subcard.name.junction? &&
+         subcard.name.parts.first.empty? &&
          new_name.parts.first.present?
         # replace the empty part
         "".to_name
       else
         name
       end
-    subcard.name = subcard.cardname.replace name_to_replace, new_name.s
+    subcard.name = subcard.name.swap name_to_replace, new_name.s
     subcard.update_subcard_names new_name, name
   end
 end
 
-def cardname
-  name.to_name
-end
-
 def codename
   super&.to_sym
 end
@@ -84,13 +84,13 @@ def autoname name
   end
 end
 
-# FIXME: use delegations and include all cardname functions
+# FIXME: use delegations and include all name functions
 def simple?
-  cardname.simple?
+  name.simple?
 end
 
 def junction?
-  cardname.junction?
+  name.junction?
 end
 
 def raw_name
@@ -98,13 +98,13 @@ def raw_name
 end
 
 def relative_name context_name=nil
-  context_name ||= @supercard.cardname if @supercard
-  cardname.name_from context_name
+  context_name ||= @supercard.name if @supercard
+  name.name_from context_name
 end
 
 def absolute_name context_name=nil
-  context_name ||= @supercard.cardname if @supercard
-  cardname.absolute_name context_name
+  context_name ||= @supercard.name if @supercard
+  name.absolute_name context_name
 end
 
 def left *args
@@ -114,18 +114,18 @@ def left *args
   when attribute_is_changing?(:name) && name.to_name.trunk_name.key == name_before_act.to_name.key
     nil # prevent recursion when, eg, renaming A+B to A+B+C
   else
-    Card.fetch cardname.left, *args
+    Card.fetch name.left, *args
   end
 end
 
 def right *args
-  Card.fetch(cardname.right, *args) unless simple?
+  Card.fetch(name.right, *args) unless simple?
 end
 
 def [] *args
   case args[0]
   when Integer, Range
-    fetch_name = Array.wrap(cardname.parts[args[0]]).compact.join "+"
+    fetch_name = Array.wrap(name.parts[args[0]]).compact.join Card::Name.joint
     Card.fetch(fetch_name, args[1] || {}) unless simple?
   else
     super
@@ -137,11 +137,11 @@ def trunk *args
 end
 
 def tag *args
-  simple? ? self : Card.fetch(cardname.right, *args)
+  simple? ? self : Card.fetch(name.right, *args)
 end
 
 def left_or_new args={}
-  left(args) || Card.new(args.merge(name: cardname.left))
+  left(args) || Card.new(args.merge(name: name.left))
 end
 
 def fields
@@ -184,17 +184,17 @@ end
 
 def repair_key
   Auth.as_bot do
-    correct_key = cardname.key
+    correct_key = name.key
     current_key = key
     return self if current_key == correct_key
 
     if (key_blocker = Card.find_by_key_and_trash(correct_key, true))
-      key_blocker.cardname = key_blocker.cardname + "*trash#{rand(4)}"
+      key_blocker.name = key_blocker.name + "*trash#{rand(4)}"
       key_blocker.save
     end
 
     saved =   (self.key      = correct_key) && save!
-    saved ||= (self.cardname = current_key) && save!
+    saved ||= (self.name = current_key) && save!
 
     if saved
       descendants.each(&:repair_key)
@@ -211,7 +211,7 @@ end
 
 event :set_autoname, :prepare_to_validate, on: :create do
   if name.blank? && (autoname_card = rule_card(:autoname))
-    self.name = autoname autoname_card.content
+    self.name = autoname autoname_card.db_content
     # FIXME: should give placeholder in approve phase
     # and finalize/commit change in store phase
     autoname_card.refresh.update_column :db_content, name
@@ -224,9 +224,9 @@ end
 
 event :set_left_and_right, :store,
       changed: :name, on: :save do
-  if cardname.junction?
+  if name.junction?
     %i[left right].each do |side|
-      sidename = cardname.send "#{side}_name"
+      sidename = name.send "#{side}_name"
       sidecard = Card[sidename]
 
       # eg, renaming A to A+B

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

@@ -20,7 +20,7 @@ end
 event :validate_uniqueness_of_name do
   # validate uniqueness of name
   condition_sql = "cards.key = ? and trash=?"
-  condition_params = [cardname.key, false]
+  condition_params = [name.key, false]
   unless new_record?
     condition_sql << " AND cards.id <> ?"
     condition_params << id
@@ -33,17 +33,17 @@ end
 event :validate_legality_of_name do
   if name.length > 255
     errors.add :name, "is too long (255 character maximum)"
-  elsif cardname.blank?
+  elsif name.blank?
     errors.add :name, "can't be blank"
-  elsif cardname.parts.include? ""
+  elsif name.parts.include? ""
     errors.add :name, "is incomplete"
   else
-    unless cardname.valid?
+    unless name.valid?
       errors.add :name, "may not contain any of the following characters: " \
                         "#{Card::Name.banned_array * ' '}"
     end
     # this is to protect against using a plus card as a tag
-    return unless cardname.junction? && simple? && id &&
+    return unless name.junction? && simple? && id &&
                   Auth.as_bot { Card.count_by_wql right_id: id } > 0
     errors.add :name, "#{name} in use as a tag"
   end
@@ -52,7 +52,7 @@ end
 event :validate_key, after: :validate_name, on: :save do
   if key.empty?
     errors.add :key, "cannot be blank" if errors.empty?
-  elsif key != cardname.key
+  elsif key != name.key
     errors.add :key, "wrong key '#{key}' for name #{name}"
   end
 end

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

@@ -100,7 +100,7 @@ def require_permission_rule! rule_id, action
 end
 
 def rule_class_name
-  trunk.type_id == Card::SetID ? cardname.trunk_name.tag : nil
+  trunk.type_id == Card::SetID ? name.trunk_name.tag : nil
 end
 
 def you_cant what

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

@@ -11,6 +11,6 @@ delegate :validation_phase, to: :director
 delegate :storage_phase, to: :director
 delegate :integration_phase, to: :director
 
-def clean_up
-  Card::ActManager.clear
-end
+# def clean_up
+#   Card::A# ctManager.clear
+# end

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

@@ -43,10 +43,10 @@ end
 
 # replace references in card content
 def replace_reference_syntax old_name, new_name
-  obj_content = Card::Content.new raw_content, self
+  obj_content = Card::Content.new content, self
   obj_content.find_chunks(Card::Content::Chunk::Reference).select do |chunk|
     next unless (old_ref_name = chunk.referee_name)
-    next unless (new_ref_name = old_ref_name.replace old_name, new_name)
+    next unless (new_ref_name = old_ref_name.swap old_name, new_name)
     chunk.referee_name = chunk.replace_reference old_name, new_name
     refs = Card::Reference.where referee_key: old_ref_name.key
     refs.update_all referee_key: new_ref_name.key
@@ -120,10 +120,10 @@ def reference_values_array ref_hash
   values
 end
 
-# invokes the given block for each reference in raw_content with
+# invokes the given block for each reference in content with
 # the reference name and reference type
 def each_reference_out
-  content_obj = Card::Content.new raw_content, self
+  content_obj = Card::Content.new content, self
   content_obj.find_chunks(Card::Content::Chunk::Reference).each do |chunk|
     yield(chunk.referee_name, chunk.reference_code)
   end

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

@@ -1,10 +1,9 @@
 event :rename, after: :set_name, on: :update do
-  if (existing_card = Card.find_by_key_and_trash(cardname.key, true)) &&
-    existing_card != self
-    existing_card.name = existing_card.name + "*trash"
-    existing_card.rename_without_callbacks
-    existing_card.save!
-  end
+  existing_card = Card.find_by_key_and_trash name.key, true
+  return if !existing_card || existing_card == self
+  existing_card.name = existing_card.name + "*trash"
+  existing_card.rename_without_callbacks
+  existing_card.save!
 end
 
 def suspend_name name
@@ -25,7 +24,7 @@ event :cascade_name_changes, :finalize, on: :update, changed: :name,
     # cards, have to go this low level to avoid callbacks.
     Rails.logger.info "cascading name: #{de.name}"
     Card.expire de.name # old name
-    newname = de.cardname.replace name_before_last_save, name
+    newname = de.name.swap name_before_last_save, name
     Card.where(id: de.id).update_all name: newname.to_s, key: newname.key
     de.update_referers = update_referers
     de.refresh_references_in

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

@@ -68,7 +68,7 @@ def is_standard_rule?
 end
 
 def is_preference?
-  cardname.parts.length > 2 &&
+  name.parts.length > 2 &&
     (r = right(skip_modules: true)) &&
     r.type_id == Card::SettingID &&
     (set = self[0..-3, skip_modules: true]) &&
@@ -121,7 +121,7 @@ def related_sets with_self=false
     sets << ["#{name}+*type", Card::Set::Type.label(name)]
   end
   sets << ["#{name}+*self", Card::Set::Self.label(name)] if with_self
-  if known? && cardname.simple?
+  if known? && name.simple?
     sets << ["#{name}+*right", Card::Set::Right.label(name)]
   end
   sets

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

@@ -5,9 +5,9 @@ def director
   @director ||= Card::ActManager.fetch self
 end
 
-def identify_action
+def identify_action explicit_delete=false
   @action =
-    if trash && trash_changed?
+    if explicit_delete || (trash && trash_changed?)
       :delete
     elsif new_card?
       :create
@@ -15,12 +15,3 @@ def identify_action
       :update
     end
 end
-
-def current_act= act
-  raise Card::Error, "not allowed to override current act" if Card.current_act
-  Card.current_act = act
-end
-
-def current_act
-  @current_act ||= Card.current_act
-end

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

@@ -1,5 +1,5 @@
 def field tag, opts={}
-  Card.fetch cardname.field(tag), opts
+  Card.fetch name.field(tag), opts
 end
 
 def subcard card_name

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

@@ -1,10 +1,10 @@
 
 def is_template?
-  cardname.trait_name? :structure, :default
+  name.trait_name? :structure, :default
 end
 
 def is_structure?
-  cardname.trait_name? :structure
+  name.trait_name? :structure
 end
 
 def template
@@ -49,7 +49,7 @@ def assigns_type?
   # needed because not all *structure templates govern the type of set members
   # for example, X+*type+*structure governs all cards of type X,
   # but the content rule does not (in fact cannot) have the type X.
-  return unless (set_pattern = Card.fetch cardname.trunk_name.tag_name,
+  return unless (set_pattern = Card.fetch name.trunk_name.tag_name,
                                           skip_modules: true)
   return unless (pattern_code = set_pattern.codename)
   return unless (set_class = Set::Pattern.find pattern_code)
@@ -64,7 +64,7 @@ end
 def virtual?
   return false unless new_card?
   if @virtual.nil?
-    cardname.simple? ? (@virtual = false) : template
+    name.simple? ? (@virtual = false) : template
   end
   @virtual
 end

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

@@ -1,7 +1,7 @@
 
 module ClassMethods
   def default_type_id
-    @@default_type_id ||= Card[:all].fetch(trait: :default).type_id
+    @@default_type_id ||= Card[:all].fetch(trait: :default, skip_modules: true).type_id
   end
 end
 
@@ -25,7 +25,7 @@ def type_name_or_default
 end
 
 def type_cardname
-  type_card.try :cardname
+  type_card.try :name
 end
 
 def type= type_name