card 1.17.4 → 1.18.0

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

@@ -1,6 +1,6 @@
 format do
   def render_haml locals={}, template=nil, a_binding=nil, &block
-    template ||= block.call
+    template ||= yield
     a_binding ||= binding
     ::Haml::Engine.new(template).render(a_binding, locals)
   end

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

@@ -1,41 +1,35 @@
-JUNK_INIT_ARGS = %w{ missing skip_virtual id }
-
-module ClassMethods
-  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? }
-    args.delete('content') if args['attach'] # should not be handled here!
-    super args
-  end
-end
-
-def initialize args = {}
-  args['name'] = args['name'].to_s
-  args['db_content'] = args.delete('content') if args['content']
-  @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 !type_id && !skip_type_lookup
-    self.type_id = get_type_id_from_structure
-  end
-  include_set_modules unless skip_modules
-  self
-end
-
-def include_set_modules
-  unless @set_mods_loaded
-    set_modules.each do |m|
-      singleton_class.send :include, m
-    end
-    assign_set_specific_attributes
-    @set_mods_loaded = true
-  end
-  self
-end
-
-event :initialize_success_object, before: :handle do
-  Env[:success] = Success.new(cardname, Env.params[:success])
-end
+JUNK_INIT_ARGS = %w( missing skip_virtual id ).freeze
+
+module ClassMethods
+  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? }
+    args.delete('content') if args['attach'] # should not be handled here!
+    super args
+  end
+end
+
+def initialize args={}
+  args['name'] = args['name'].to_s
+  args['db_content'] = args.delete('content') if args['content']
+  @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
+  self.type_id = get_type_id_from_structure if !type_id && !skip_type_lookup
+  include_set_modules unless skip_modules
+  self
+end
+
+def include_set_modules
+  unless @set_mods_loaded
+    set_modules.each do |m|
+      singleton_class.send :include, m
+    end
+    assign_set_specific_attributes
+    @set_mods_loaded = true
+  end
+  self
+end

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

@@ -1,10 +1,8 @@
-event :discard_deleted_locations, after: :store, on: :delete do
+event :discard_deleted_locations, in: :finalize, on: :delete do
   Env.discard_locations_for self
-  if success.target == self
-    success.target = :previous
-  end
+  success.target = :previous if success.target == self
 end
 
-event :save_current_location, before: :show, on: :read do
+event :save_current_location, before: :show_page, on: :read do
   Env.save_location self
 end

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

@@ -4,9 +4,7 @@ module ClassMethods
   def uniquify_name name, rename=:new
     return name unless Card.exists?(name)
     uniq_name = "#{name} 1"
-    while Card.exists?(uniq_name)
-      uniq_name.next!
-    end
+    uniq_name.next! while Card.exists?(uniq_name)
     if rename == :old
       # name conflict resolved; original name can be used
       Card[name].update_attributes! name: uniq_name,
@@ -38,8 +36,10 @@ def name= newname
     reset_patterns_if_rule
     reset_patterns
   end
-  subcards.each do |subcard|
-    subcard.name = subcard.cardname.replace_part name, newname
+  if @director
+    subcards.each do |subcard|
+      subcard.name = subcard.cardname.replace_part name, newname
+    end
   end
 
   write_attribute :name, cardname.s
@@ -166,8 +166,8 @@ def repair_key
       key_blocker.save
     end
 
-    saved =   (self.key      = correct_key) && self.save!
-    saved ||= (self.cardname = current_key) && self.save!
+    saved =   (self.key      = correct_key) && save!
+    saved ||= (self.cardname = current_key) && save!
 
     if saved
       descendants.each(&:repair_key)
@@ -182,50 +182,7 @@ 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? && errors.empty? &&
-     Card.find_by_codename(codename).present?
-    errors.add :codename, "codename #{codename} already in use"
-  end
-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)'
-  elsif cdname.blank?
-    errors.add :name, "can't be blank"
-  elsif name_changed?
-    # 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 * ' '}"
-    end
-    # this is to protect against using a plus card as a tag
-    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]
-    unless new_record?
-      condition_sql << ' AND cards.id <> ?'
-      condition_params << id
-    end
-    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
+event :set_autoname, :prepare_to_validate, on: :create do
   if name.blank? && (autoname_card = rule_card(:autoname))
     self.name = autoname autoname_card.content
     # FIXME: should give placeholder in approve phase
@@ -234,34 +191,28 @@ event :set_autoname, before: :validate_name, on: :create do
   end
 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
-    errors.add :key, "wrong key '#{key}' for name #{name}"
-  end
-end
-
-event :set_name, before: :store, changed: :name do
+event :set_name, :store, changed: :name do
   Card.expire name
   Card.expire name_was
+end
+
+event :set_left_and_right, :store,
+      changed: :name, on: :save do
   if cardname.junction?
     [:left, :right].each do |side|
       sidename = cardname.send "#{side}_name"
-      # warn "sidename #{name} / #{name_was} / #{cardname},
-      # #{side}: #{sidename}"
       sidecard = Card[sidename]
 
       # 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
+      side_id_or_card =
         if !sidecard || old_name_in_way
-          Card.create! name: sidename, supercard: self
+          add_subcard(sidename.s)
         else
-          sidecard
-        end.id
-      end
+          sidecard.id
+        end
+      send "#{side}_id=", side_id_or_card
     end
   else
     self.left_id = self.right_id = nil
@@ -285,7 +236,7 @@ def suspend_name name
   Card.where(id: id).update_all(name: tmp_name, key: tmp_name)
 end
 
-event :cascade_name_changes, after: :store, on: :update, changed: :name do
+event :cascade_name_changes, :finalize, on: :update, changed: :name do
   des = descendants
   @descendants = nil # reset
 

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

@@ -0,0 +1,56 @@
+event :permit_codename, :validate,
+      on: :update, changed: :codename do
+  errors.add :codename, 'only admins can set codename' unless Auth.always_ok?
+  validate_uniqueness_of_codename
+end
+
+event :validate_uniqueness_of_codename do
+  return unless codename.present? && errors.empty? &&
+                Card.find_by_codename(codename).present?
+  errors.add :codename, "codename #{codename} already in use"
+end
+
+event :validate_name, :validate,
+      on: :save, changed: :name do
+  validate_legality_of_name
+  return if errors.any?
+  validate_uniqueness_of_name
+end
+
+event :validate_uniqueness_of_name do
+  # validate uniqueness of name
+  condition_sql = 'cards.key = ? and trash=?'
+  condition_params = [cardname.key, false]
+  unless new_record?
+    condition_sql << ' AND cards.id <> ?'
+    condition_params << id
+  end
+  if (c = Card.find_by(condition_sql, *condition_params))
+    errors.add :name, "must be unique; '#{c.name}' already exists."
+  end
+end
+
+event :validate_legality_of_name do
+  if name.length > 255
+    errors.add :name, 'is too long (255 character maximum)'
+  elsif cardname.blank?
+    errors.add :name, "can't be blank"
+  else
+    unless cardname.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 &&
+                  Auth.as_bot { Card.count_by_wql right_id: id } > 0
+    errors.add :name, "#{name} in use as a tag"
+  end
+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
+    errors.add :key, "wrong key '#{key}' for name #{name}"
+  end
+end

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

@@ -24,13 +24,13 @@ def reset_patterns_if_rule saving=false
 
     # FIXME: should be in right/read.rb
     if saving && right.id == Card::ReadID
-      self.add_to_read_rule_update_queue(set.item_cards limit: 0)
+      add_to_read_rule_update_queue(set.item_cards limit: 0)
     end
   end
 end
 
 def safe_set_keys
-  patterns.map(&:safe_key).reverse * " "
+  patterns.map(&:safe_key).reverse * ' '
 end
 
 def set_modules

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

@@ -98,7 +98,7 @@ end
 
 def permitted? action
   return if Card.config.read_only
-  return true if action != :comment and Auth.always_ok?
+  return true if action != :comment && Auth.always_ok?
 
   permitted_ids = who_can action
   if action == :comment && Auth.always_ok?
@@ -110,9 +110,7 @@ def permitted? action
 end
 
 def permit action, verb=nil
-  if Card.config.read_only # not called by ok_to_read
-    deny_because 'Currently in read-only mode'
-  end
+  deny_because 'Currently in read-only mode' if Card.config.read_only # not called by ok_to_read
 
   return if permitted? action
   verb ||= action.to_s
@@ -127,10 +125,9 @@ def ok_to_create
     # left is supercard; create permissions will get checked there.
     next if side == :left && @superleft
     part_card = send side, new: {}
-    if part_card && part_card.new_card? # if no card, there must be other errors
-      unless part_card.ok? :create
-        deny_because you_cant("create #{part_card.name}")
-      end
+    next unless part_card && part_card.new_card? # if no card, there must be other errors
+    unless part_card.ok? :create
+      deny_because you_cant("create #{part_card.name}")
     end
   end
 end
@@ -161,12 +158,12 @@ def ok_to_comment
   deny_because 'No comments allowed on structured content' if structure
 end
 
-event :clear_read_rule, before: :store, on: :delete do
+event :clear_read_rule, :store, on: :delete do
   self.read_rule_id = self.read_rule_class = nil
 end
 
-event :set_read_rule, before: :store, on: :save do
-  # avoid doing this on simple content saves?
+event :set_read_rule, :store,
+      on: :save, changed: [:type_id, :name] do
   read_rule_id, read_rule_class = permission_rule_id_and_class(:read)
   self.read_rule_id = read_rule_id
   self.read_rule_class = read_rule_class
@@ -188,20 +185,18 @@ end
 def update_read_rule
   Card.record_timestamps = false
   reset_patterns # why is this needed?
-  rcard, rclass = permission_rule_card :read
+  rcard_id, rclass = permission_rule_id_and_class :read
   # these two are just to make sure vals are correct on current object
-  self.read_rule_id = rcard.id
+  self.read_rule_id = rcard_id
   self.read_rule_class = rclass
-  Card.where(id: id).update_all read_rule_id: rcard.id, read_rule_class: rclass
+  Card.where(id: id).update_all read_rule_id: rcard_id, read_rule_class: rclass
   expire_hard
 
   # currently doing a brute force search for every card that may be impacted.
   # may want to optimize(?)
   Auth.as_bot do
     fields.each do |field|
-      if field.rule(:read) == '_left'
-        field.update_read_rule
-      end
+      field.update_read_rule if field.rule(:read) == '_left'
     end
   end
 
@@ -209,12 +204,11 @@ ensure
   Card.record_timestamps = true
 end
 
-
 def add_to_read_rule_update_queue updates
   @read_rule_update_queue = Array.wrap(@read_rule_update_queue).concat updates
 end
 
-event :check_permissions, after: :approve do
+event :check_permissions, :validate do
   task =
     if @action != :delete && comment # will be obviated by new comment handling
       :comment
@@ -256,7 +250,7 @@ def have_recaptcha_keys?
     end
 end
 
-event :recaptcha, before: :approve do
+event :recaptcha, :validate do
   if !@supercard && !Env[:recaptcha_used] && recaptcha_on?
     Env[:recaptcha_used] = true
     Env[:controller].verify_recaptcha model: self, attribute: :captcha

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

@@ -1,208 +1,17 @@
-
-# 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)
-
-def abort status, msg = 'action canceled'
-  if status == :failure && errors.empty?
-    errors.add :abort, msg
-  elsif Hash === status && status[:success]
-    success << status[:success]
-    status = :success
-  end
-  raise Card::Abort.new(status, msg)
-end
-
-def abortable
-  yield
-rescue Card::Abort => e
-  if e.status == :triumph
-    @supercard ? raise(e) : true
-  elsif e.status == :success
-    if @supercard
-      @supercard.subcards.delete(key)
-    end
-    true
-  end
-end
-
-def valid_subcard?
-  abortable { valid? }
-end
-
-# 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
-    add_to_transaction
-    status = abortable { yield }
-    raise ActiveRecord::Rollback unless status
-  end
-  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
+def prepare_for_phases
+  identify_action
   reset_patterns
   include_set_modules
-  run_phase :prepare
-rescue => e
-  rescue_event e
 end
 
-def approve
-  @action ||= identify_action
-  run_phase :approve
-  expire_pieces if errors.any?
-  errors.empty?
-rescue => e
-  rescue_event e
+def run_phases?
+  director.main? && !skip_phases
 end
 
-def identify_action
-  case
-  when trash     then :delete
-  when new_card? then :create
-  else :update
-  end
-end
-
-def store
-  run_phase :store do
-    run_callbacks :store do
-      yield # unless @draft
-      @virtual = false
-    end
-  end
-  run_phase :stored
-rescue => e
-  rescue_event e
-ensure
-  @from_trash =  @last_content_action_id = nil
-end
-
-def extend
-  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(&:expire_pieces)
-  raise e
-  # rescue Card::Cancel
-  # false
-end
-
-def phase_ok? opts
-  phase && (
-    (opts[:during] && in?(opts[:during])) ||
-    (opts[:before] && before?(opts[:before])) ||
-    (opts[:after]  && after?(opts[:after])) ||
-    true # no phase restriction in opts
-  )
-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]) &&
-    changed_condition_applies?(opts[:changed]) &&
-    when_condition_applies?(opts[:when])
-end
-
-def on_condition_applies? action
-  if action
-    Array.wrap(action).member? @action
-  else
-    true
-  end
-end
-
-def changed_condition_applies? db_column
-  if db_column
-    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
-end
-
-def when_condition_applies? block
-  if block
-    block.call self
-  else
-    true
-  end
-end
+delegate :validation_phase, to: :director
+delegate :storage_phase, to: :director
+delegate :integration_phase, to: :director
 
-def success
-  Env.success(cardname)
+def clean_up
+  Card::DirectorRegister.clear
 end