card 1.16.8 → 1.16.9

data/mod/01_core/set/all/initialize.rb

@@ -1,7 +1,7 @@
 JUNK_INIT_ARGS = %w{ missing skip_virtual id }
 
 module ClassMethods
-  def new args={}, options={}
+  def new args = {}, _options = {}
     args = (args || {}).stringify_keys
     JUNK_INIT_ARGS.each { |a| args.delete(a) }
     %w{ type type_code }.each { |k| args.delete(k) if args[k].blank? }
@@ -10,30 +10,17 @@ module ClassMethods
   end
 end
 
-def initialize args={}
-  args['name']    = args['name'   ].to_s
-  args['type_id'] = args['type_id'].to_i
-
-  args.delete('type_id') if args['type_id'] == 0 # can come in as 0, '', or nil
-  @type_args = {
-    type:      args.delete('type'     ),
-    type_code: args.delete('type_code'),
-    type_id:   args[       'type_id'  ]
-  }
-
+def initialize args = {}
+  args['name'] = args['name'].to_s
   args['db_content'] = args.delete('content') if args['content']
-
-  #FIXME -- too much of the above is duplicated by assign_attributes (tracked_attributes.rb)
-
   @supercard = args.delete 'supercard' # must come before name =
   skip_modules = args.delete 'skip_modules'
+  skip_type_lookup = args['skip_type_lookup']
 
   super args # ActiveRecord #initialize
-
-  if tid = get_type_id( @type_args )
-    self.type_id = tid
+  if !type_id && !skip_type_lookup
+    self.type_id = get_type_id_from_structure
   end
-
   include_set_modules unless skip_modules
   self
 end
@@ -44,12 +31,11 @@ def include_set_modules
       singleton_class.send :include, m
     end
     assign_set_specific_attributes
-    @set_mods_loaded=true
+    @set_mods_loaded = true
   end
   self
 end
 
-
 event :initialize_success_object, before: :handle do
   Env[:success] = Success.new(cardname, Env.params[:success])
-end
+end

data/mod/01_core/set/all/name.rb

@@ -1,24 +1,43 @@
 require 'uuid'
 
+module ClassMethods
+  def uniquify_name name, rename=false
+    return name unless Card[name]
+    uniq_name = "#{name} 1"
+    while Card[uniq_name]
+      uniq_name.next!
+    end
+    return uniq_name unless rename
+
+    Card[name].update_attributes! name: uniq_name,
+                                  update_referencers: true
+    # name conflict resolved; original name can be used
+    name
+  end
+end
+
 def name= newname
   cardname = newname.to_name
   if @supercard
-    @relative_name = cardname.to_s
-    relparts = @relative_name.to_name.parts
-    @superleft = @supercard if relparts.size==2 && relparts.first.blank?
-    cardname = @relative_name.to_name.to_absolute_name @supercard.name
+    @supercard.subcards.rename key, cardname.key
+    @contextual_name = cardname.to_s
+    relparts = cardname.parts
+    if relparts.size == 2 &&
+       (relparts.first.blank? || relparts.first.to_name.key == @supercard.key)
+      @superleft = @supercard
+    end
+    cardname = cardname.to_absolute_name @supercard.name
   end
 
   newkey = cardname.key
   if key != newkey
     self.key = newkey
-    reset_patterns_if_rule # reset the old name - should be handled in tracked_attributes!!
+    # reset the old name - should be handled in tracked_attributes!!
+    reset_patterns_if_rule
     reset_patterns
   end
-
-  subcards.each do |subkey, subcard|
-    next unless Card===subcard
-    subcard.name = subkey.to_name.to_absolute cardname
+  subcards.each do |subcard|
+    subcard.name = subcard.cardname.replace_part name, newname
   end
 
   write_attribute :name, cardname.s
@@ -45,49 +64,63 @@ def junction?
   cardname.junction?
 end
 
+def contextual_name
+  @contextual_name || name
+end
+
+def relative_name context_name=nil
+  if !context_name && @supercard
+    context_name = @supercard.cardname
+  end
+  cardname.relative_name(context_name)
+end
 
-def relative_name
-  @relative_name || name
+def absolute_name context_name=nil
+  if !context_name && @supercard
+    context_name = @supercard.cardname
+  end
+  cardname.absolute_name(context_name)
 end
 
 def left *args
-  if !simple?
-    @superleft or begin
-      unless name_changed? and name.to_name.trunk_name.key == name_was.to_name.key
-        # prevent recursion when, eg, renaming A+B to A+B+C
-        Card.fetch cardname.left, *args
-      end
+  return if simple?
+  @superleft || begin
+    unless name_changed? &&
+           name.to_name.trunk_name.key == name_was.to_name.key
+      # prevent recursion when, eg, renaming A+B to A+B+C
+      Card.fetch cardname.left, *args
     end
   end
 end
 
 def right *args
-  Card.fetch( cardname.right, *args ) if !simple?
+  Card.fetch(cardname.right, *args) if !simple?
 end
 
 def [] *args
-  if args[0].kind_of?(Fixnum) || args[0].kind_of?(Range)
+  case args[0]
+  when Fixnum, Range
     fetch_name = Array.wrap(cardname.parts[args[0]]).compact.join '+'
-    Card.fetch( fetch_name, args[1] || {} ) if !simple?
+    Card.fetch(fetch_name, args[1] || {}) if !simple?
   else
     super
   end
 end
 
 def trunk *args
-  simple? ? self : left( *args )
+  simple? ? self : left(*args)
 end
 
 def tag *args
-  simple? ? self : Card.fetch( cardname.right, *args )
+  simple? ? self : Card.fetch(cardname.right, *args)
 end
 
 def left_or_new args={}
-  left args or Card.new args.merge(name: cardname.left)
+  left(args) || Card.new(args.merge(name: cardname.left))
 end
 
 def children
-  Card.search( { (simple? ? :part : :left) => name } ).to_a
+  Card.search((simple? ? :part : :left) => name).to_a
 end
 
 def dependents
@@ -101,7 +134,7 @@ def dependents
           array + card.dependents
         end
       end
-    #Rails.logger.warn "dependents[#{inspect}] #{@dependents.inspect}"
+    # Rails.logger.warn "dependents[#{inspect}] #{@dependents.inspect}"
   end
   @dependents
 end
@@ -110,18 +143,18 @@ def repair_key
   Auth.as_bot do
     correct_key = cardname.key
     current_key = key
-    return self if current_key==correct_key
+    return self if current_key == correct_key
 
-    if key_blocker = Card.find_by_key_and_trash(correct_key, true)
+    if (key_blocker = Card.find_by_key_and_trash(correct_key, true))
       key_blocker.cardname = key_blocker.cardname + "*trash#{rand(4)}"
       key_blocker.save
     end
 
-    saved =   ( self.key  = correct_key and self.save! )
-    saved ||= ( self.cardname = current_key and self.save! )
+    saved =   (self.key      = correct_key) && self.save!
+    saved ||= (self.cardname = current_key) && self.save!
 
     if saved
-      self.dependents.each { |c| c.repair_key }
+      dependents.each(&:repair_key)
     else
       Rails.logger.debug "FAILED TO REPAIR BROKEN KEY: #{key}"
       self.name = "BROKEN KEY: #{name}"
@@ -133,13 +166,13 @@ rescue
   self
 end
 
-
 event :permit_codename, before: :approve, on: :update, changed: :codename do
   errors.add :codename, 'only admins can set codename' unless Auth.always_ok?
 end
 
 event :validate_unique_codename, after: :permit_codename do
-  if codename.present? and errors.empty? and Card.find_by_codename(codename).present?
+  if codename.present? && errors.empty? &&
+     Card.find_by_codename(codename).present?
     errors.add :codename, "codename #{codename} already in use"
   end
 end
@@ -147,45 +180,46 @@ end
 event :validate_name, before: :approve, on: :save do
   cdname = name.to_name
   if name.length > 255
-    errors.add :name, "is too long (255 character maximum)"
+    errors.add :name, 'is too long (255 character maximum)'
   elsif cdname.blank?
     errors.add :name, "can't be blank"
   elsif name_changed?
-    #Rails.logger.debug "valid name #{card.name.inspect} New #{name.inspect}"
+    # Rails.logger.debug "valid name #{card.name.inspect} New #{name.inspect}"
 
     unless cdname.valid?
-      errors.add :name, "may not contain any of the following characters: #{ Card::Name.banned_array * ' ' }"
+      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
-    if cdname.junction? and simple? and id and Auth.as_bot { Card.count_by_wql right_id: id } > 0
+    if cdname.junction? && simple? && id &&
+       Auth.as_bot { Card.count_by_wql right_id: id } > 0
       errors.add :name, "#{name} in use as a tag"
     end
 
     # validate uniqueness of name
-    condition_sql = "cards.key = ? and trash=?"
-    condition_params = [ cdname.key, false ]
+    condition_sql = 'cards.key = ? and trash=?'
+    condition_params = [cdname.key, false]
     unless new_record?
-      condition_sql << " AND cards.id <> ?"
+      condition_sql << ' AND cards.id <> ?'
       condition_params << id
     end
-    if c = Card.find_by(condition_sql, *condition_params)
+    if (c = Card.find_by(condition_sql, *condition_params))
       errors.add :name, "must be unique; '#{c.name}' already exists."
     end
   end
 end
 
-
 event :set_autoname, before: :validate_name, on: :create do
-  if name.blank? and autoname_card = rule_card(:autoname)
+  if name.blank? && (autoname_card = rule_card(:autoname))
     self.name = autoname autoname_card.content
-    Auth.as_bot { autoname_card.refresh.update_attributes! content: name }   #fixme, should give placeholder on new, do next and save on create
+    # FIXME: should give placeholder on new, do next and save on create
+    Auth.as_bot { autoname_card.refresh.update_attributes! content: name }
   end
 end
 
-
 event :validate_key, after: :validate_name, on: :save do
   if key.empty?
-    errors.add :key, "cannot be blank" if errors.empty?
+    errors.add :key, 'cannot be blank' if errors.empty?
   elsif key != cardname.key
     errors.add :key, "wrong key '#{key}' for name #{name}"
   end
@@ -197,9 +231,12 @@ event :set_name, before: :store, changed: :name do
   if cardname.junction?
     [:left, :right].each do |side|
       sidename = cardname.send "#{side}_name"
-      #warn "sidename #{name} / #{name_was} / #{cardname}, #{side}: #{sidename}"
+      # warn "sidename #{name} / #{name_was} / #{cardname},
+      # #{side}: #{sidename}"
       sidecard = Card[sidename]
-      old_name_in_way = (sidecard && sidecard.id==self.id) # eg, renaming A to A+B
+
+      # eg, renaming A to A+B
+      old_name_in_way = (sidecard && sidecard.id == id)
       suspend_name(sidename) if old_name_in_way
       send "#{side}_id=", begin
         if !sidecard || old_name_in_way
@@ -214,60 +251,72 @@ event :set_name, before: :store, changed: :name do
   end
 end
 
-
 event :rename, after: :set_name, on: :update do
-  if existing_card = Card.find_by_key_and_trash(cardname.key, true) and existing_card != self
-    existing_card.name = existing_card.name+'*trash'
+  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
 end
 
-def suspend_name(name)
+def suspend_name name
   # move the current card out of the way, in case the new name will require
   # re-creating a card with the current name, ie.  A -> A+B
   Card.expire name
-  tmp_name = "tmp:" + UUID.new.generate
-  Card.where(id: self.id).update_all(name: tmp_name, key: tmp_name)
+  tmp_name = 'tmp:' + UUID.new.generate
+  Card.where(id: id).update_all(name: tmp_name, key: tmp_name)
 end
 
-
 event :cascade_name_changes, after: :store, on: :update, changed: :name do
-  #Rails.logger.info "------------------- #{name_was} CASCADE #{self.name} -------------------------------------"
-
-  self.update_referencers = false if self.update_referencers == 'false' #handle strings from cgi
+  # Rails.logger.info "------------------- #{name_was} CASCADE #{self.name} " \
+  #                   " -------------------------------------"
+  # handle strings from cgi
+  self.update_referencers = false if update_referencers == 'false'
   Card::Reference.update_on_rename self, name, self.update_referencers
 
-  deps = self.dependents
-  #warn "-------------------#{name_was}---- CASCADE #{self.name} -> deps: #{deps.map(&:name)*", "} -----------------------"
+  deps = dependents
+  # warn "-------------------#{name_was}---- CASCADE #{self.name} -> deps: " \
+  #      " #{deps.map(&:name)*', '} -----------------------"
 
-  @dependents = nil #reset
+  @dependents = nil # reset
 
   deps.each do |dep|
-    # here we specifically want NOT to invoke recursive cascades on these cards, have to go this low level to avoid callbacks.
+    # here we specifically want NOT to invoke recursive cascades on these
+    # cards, have to go this low level to avoid callbacks.
     Rails.logger.info "cascading name: #{dep.name}"
-    Card.expire dep.name #old name
+    Card.expire dep.name # old name
     newname = dep.cardname.replace_part name_was, name
-    Card.where( id: dep.id ).update_all name: newname.to_s, key: newname.key
+    Card.where(id: dep.id).update_all name: newname.to_s, key: newname.key
     Card::Reference.update_on_rename dep, newname, update_referencers
     Card.expire newname
   end
-  if update_referencers
-    Auth.as_bot do
-      [self.name_referencers(name_was)+(deps.map &:referencers)].flatten.uniq.each do |card|
-        # FIXME  using "name_referencers" instead of plain "referencers" for self because there are cases where trunk and tag
-        # have already been saved via association by this point and therefore referencers misses things
-        # eg.  X includes Y, and Y is renamed to X+Z.  When X+Z is saved, X is first updated as a trunk before X+Z gets to this point.
-        # so at this time X is still including Y, which does not exist.  therefore #referencers doesn't find it, but name_referencers(old_name) does.
-        # some even more complicated scenario probably breaks on the dependents, so this probably needs a more thoughtful refactor
-        # aligning the dependent saving with the name cascading
-
-        Rails.logger.debug "------------------ UPDATE REFERER #{card.name}  ------------------------"
-        unless card == self or card.structure
-          card = card.refresh
-          card.db_content = card.replace_references name_was, name
-          card.save!
-        end
+  execute_referencers_update(deps) if update_referencers
+end
+
+def execute_referencers_update dependents
+  Auth.as_bot do
+    [name_referencers(name_was) + dependents.map(&:referencers)]
+      .flatten.uniq.each do |card|
+      # FIXME:  using 'name_referencers' instead of plain 'referencers' for self
+      # because there are cases where trunk and tag
+      # have already been saved via association by this point and therefore
+      # referencers misses things
+      # eg.  X includes Y, and Y is renamed to X+Z.  When X+Z is saved, X is
+      # first updated as a trunk before X+Z gets to this point.
+      # so at this time X is still including Y, which does not exist.
+      # therefore #referencers doesn't find it, but name_referencers(old_name)
+      # does.
+      # some even more complicated scenario probably breaks on the dependents,
+      # so this probably needs a more thoughtful refactor
+      # aligning the dependent saving with the name cascading
+
+      Rails.logger.debug "------------------ UPDATE REFERER #{card.name} " \
+                         '------------------------'
+      unless card == self || card.structure
+        card = card.refresh
+        card.db_content = card.replace_references name_was, name
+        card.save!
       end
     end
   end

data/mod/01_core/set/all/phases.rb

@@ -1,31 +1,32 @@
 
-# The Card#abort method is for cleanly exiting an action without continuing to process any further events.
+# The Card#abort method is for cleanly exiting an action without continuing
+# to process any further events.
 #
 # Three statuses are supported:
 #
 #   failure: adds an error, returns false on save
 #   success: no error, returns true on save
-#   triumph: similar to success, but if called on a subcard it causes the entire action to abort (not just the subcard)
+#   triumph: similar to success, but if called on a subcard
+#            it causes the entire action to abort (not just the subcard)
 
-def abort status, msg='action canceled'
+def abort status, msg = 'action canceled'
   if status == :failure && errors.empty?
     errors.add :abort, msg
-  elsif Hash === status and status[:success]
+  elsif Hash === status && status[:success]
     success << status[:success]
     status = :success
   end
-  raise Card::Abort.new( status, msg)
+  raise Card::Abort.new(status, msg)
 end
 
-
 def abortable
   yield
 rescue Card::Abort => e
   if e.status == :triumph
-    @supercard ? raise( e ) : true
+    @supercard ? raise(e) : true
   elsif e.status == :success
     if @supercard
-      @supercard.subcards.delete_if { |k,v| v==self }
+      @supercard.subcards.delete(key)
     end
     true
   end
@@ -35,7 +36,8 @@ def valid_subcard?
   abortable { valid? }
 end
 
-# this is an override of standard rails behavior that rescues abortmakes it so that :success abortions do not rollback
+# this is an override of standard rails behavior that rescues abort
+# makes it so that :success abortions do not rollback
 def with_transaction_returning_status
   status = nil
   self.class.transaction do
@@ -47,78 +49,122 @@ def with_transaction_returning_status
 end
 
 # perhaps above should be in separate module?
-#~~~~~~
+# ~~~~~~
+
+PHASES = {}
+[:prepare, :approve, :store, :stored, :extend, :subsequent]
+  .each_with_index do |phase, i|
+    PHASES[phase] = i
+  end
+
+def run_phase phase, &block
+  @phase = phase
+  @subphase = :before
+  if block_given?
+    block.call
+  else
+    run_callbacks phase
+  end
+  @subphase = :after
+end
+
+def simulate_phase opts, &block
+  @phase
+end
+
+def phase
+  @phase || (@supercard && @supercard.phase)
+end
+
+def subphase
+  @subphase || (@supercard && @supercard.subphase)
+end
 
 def prepare
   @action = identify_action
   # the following should really happen when type, name etc are changed
   reset_patterns
   include_set_modules
-  run_callbacks :prepare
-rescue =>e
+  run_phase :prepare
+rescue => e
   rescue_event e
 end
 
 def approve
   @action ||= identify_action
-  run_callbacks :approve
+  run_phase :approve
   expire_pieces if errors.any?
   errors.empty?
-rescue =>e
+rescue => e
   rescue_event e
 end
 
 def identify_action
   case
-  when trash     ; :delete
-  when new_card? ; :create
-  else             :update
+  when trash     then :delete
+  when new_card? then :create
+  else :update
   end
 end
 
-
 def store
-  run_callbacks :store do
-    yield #unless @draft
-    @virtual = false
+  run_phase :store do
+    run_callbacks :store do
+      yield # unless @draft
+      @virtual = false
+    end
   end
-  run_callbacks :stored
-rescue =>e
+  run_phase :stored
+rescue => e
   rescue_event e
 ensure
-  @from_trash = @last_action_id = @last_content_action_id = nil
+  @from_trash =  @last_content_action_id = nil
 end
 
-
 def extend
-
-  run_callbacks :extend
-  run_callbacks :subsequent
-rescue =>e
+  run_phase :extend
+  run_phase :subsequent
+rescue => e
   rescue_event e
 ensure
   @action = nil
 end
 
-
-
-
 def rescue_event e
   @action = nil
   expire_pieces
-  subcards.each do |key, card|
-    next unless Card===card
-    card.expire_pieces
-  end
+  subcards.each(&:expire_pieces)
   raise e
-#rescue Card::Cancel
-#  false
+  # rescue Card::Cancel
+  # false
 end
 
-event :notable_exception_raised do
-  Rails.logger.debug "BT:  #{Card::Error.current.backtrace*"\n  "}"
+def phase_ok? opts
+  phase && (
+    (opts[:during] && in?(opts[:during])) ||
+    (opts[:before] && before?(opts[:before])) ||
+    (opts[:after]  && after?(opts[:after]))
+  )
+end
+
+def before? allowed_phase
+  PHASES[allowed_phase] > PHASES[phase] ||
+    (PHASES[allowed_phase] == PHASES[phase] && subphase == :before)
 end
 
+def after? allowed_phase
+  PHASES[allowed_phase] < PHASES[phase] ||
+    (PHASES[allowed_phase] == PHASES[phase] && subphase == :after)
+end
+
+def in? allowed_phase
+  (allowed_phase.is_a?(Array) && allowed_phase.include?(phase)) ||
+    allowed_phase == phase
+end
+
+event :notable_exception_raised do
+  Rails.logger.debug "BT:  #{Card::Error.current.backtrace * "\n  "}"
+end
 
 def event_applies? opts
   on_condition_applies?(opts[:on]) &&
@@ -136,8 +182,13 @@ end
 
 def changed_condition_applies? db_column
   if db_column
-    db_column = 'db_content' if db_column.to_sym == :content
-    @action != :delete && changes[db_column.to_s]
+    db_column =
+      case db_column.to_sym
+      when :content then 'db_content'
+      when :type    then 'type_id'
+      else db_column.to_s
+      end
+    @action != :delete && changes[db_column]
   else
     true
   end
@@ -151,59 +202,6 @@ def when_condition_applies? block
   end
 end
 
-
-def subcards
-  @subcards ||= {}
-end
-
-
-event :process_subcards, after: :approve, on: :save do
-  subcards.keys.each do |sub_name|
-    opts = @subcards[sub_name] || {}
-    opts = { 'content' => opts } if String===opts
-    ab_name = sub_name.to_name.to_absolute_name name
-    next if ab_name.key == key # don't resave self!
-
-    opts = opts.stringify_keys
-    opts['subcards'] = extract_subcard_args! opts
-
-    opts[:supercard] = self
-
-    subcard =
-      if known_card = Card[ab_name]
-        known_card.refresh.assign_attributes opts
-        known_card
-      elsif (opts['content'].present? && opts['content'].strip.present?) ||
-        opts['subcards'].present? || opts['file'].present? || opts['image'].present?
-        Card.new opts.reverse_merge 'name' => sub_name
-      end
-
-    if subcard
-      @subcards[sub_name] = subcard
-    else
-      @subcards.delete sub_name
-    end
-  end
-end
-
-event :approve_subcards, after: :process_subcards do
-  subcards.each do |key, subcard|
-    if !subcard.valid_subcard?
-      subcard.errors.each do |field, err|
-        err = "#{field} #{err}" unless [:content, :abort].member? field
-        errors.add subcard.relative_name, err
-      end
-    end
-  end
-end
-
-event :store_subcards, after: :store do
-  subcards.each do |key, sub|
-    sub.save! validate: false #unless @draft
-  end
-end
-
 def success
   Env.success(cardname)
 end
-