card 1.97.0.1 → 1.98.0

data/tmpsets/set/mod003-core/all/location_history.rb

@@ -0,0 +1,28 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (LocationHistory)
+#
+module LocationHistory;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/location_history.rb"; end
+event :discard_deleted_locations, in: :finalize, on: :delete do
+  Env.discard_locations_for self
+  configure_successful_deletion if success.target == self
+end
+
+event :save_current_location, before: :show_page, on: :read do
+  Env.save_location self
+end
+
+# TO DISCUSS: should this default behavior be directly in the controller?
+# Or at least in decko?
+def configure_successful_deletion
+  if Env.ajax?
+    success.card = self
+    success.view = :missing unless success.view
+  else
+    success.target = :previous
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/location_history.rb ~~

data/tmpsets/set/mod003-core/all/name.rb

@@ -0,0 +1,242 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Name)
+#
+module Name;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/name.rb"; end
+require "uuid"
+
+module ClassMethods
+  def uniquify_name name, rename=:new
+    return name unless Card.exists? name
+    uniq_name = generate_alternative_name name
+    return uniq_name unless rename == :old
+    rename!(name, uniq_name)
+    name
+  end
+
+  def generate_alternative_name name
+    uniq_name = "#{name} 1"
+    uniq_name.next! while Card.exists?(uniq_name)
+    uniq_name
+  end
+
+  def rename! oldname, newname
+    Card[oldname].update! name: newname, update_referers: true
+  end
+end
+
+def name
+  super.to_name
+end
+
+def name= newname
+  cardname = superize_name newname.to_name
+  newkey = cardname.key
+  self.key = newkey if key != newkey
+  update_subcard_names cardname
+  write_attribute :name, cardname.s
+  name
+end
+
+def superize_name cardname
+  return cardname unless @supercard
+  @raw_name = cardname.s
+  @supercard.subcards.rename key, cardname.key
+  @superleft = @supercard if cardname.field_of? @supercard.name
+  cardname.absolute_name @supercard.name
+end
+
+def key= newkey
+  was_in_cache = Card.cache.soft.delete key
+  write_attribute :key, newkey
+  # keep the soft cache up-to-date
+  Card.write_to_soft_cache self if was_in_cache
+  # reset the old name - should be handled in tracked_attributes!!
+  reset_patterns_if_rule
+  reset_patterns
+  newkey
+end
+
+def update_subcard_names new_name, name_to_replace=nil
+  return unless @subcards
+  subcards.each do |subcard|
+    # if subcard has a relative name like +C
+    # and self is a subcard as well that changed from +B to A+B then
+    # +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.name.junction? &&
+         subcard.name.parts.first.empty? &&
+         new_name.parts.first.present?
+        # replace the empty part
+        "".to_name
+      else
+        name
+      end
+    subcard.name = subcard.name.swap name_to_replace, new_name.s
+    subcard.update_subcard_names new_name, name
+  end
+end
+
+def autoname name
+  if Card.exists?(name) || ActManager.include?(name)
+    autoname name.next
+  else
+    name
+  end
+end
+
+# FIXME: use delegations and include all name functions
+def simple?
+  name.simple?
+end
+
+def junction?
+  name.junction?
+end
+
+def raw_name
+  @raw_name || name
+end
+
+def left *args
+  case
+  when simple?    then nil
+  when @superleft then @superleft
+  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 name.left, *args
+  end
+end
+
+def right *args
+  Card.fetch(name.right, *args) unless simple?
+end
+
+def [] *args
+  case args[0]
+  when Integer, Range
+    fetch_name = Array.wrap(name.parts[args[0]]).compact.join Card::Name.joint
+    Card.fetch(fetch_name, args[1] || {}) unless simple?
+  else
+    super
+  end
+end
+
+def trunk *args
+  simple? ? self : left(*args)
+end
+
+def tag *args
+  simple? ? self : Card.fetch(name.right, *args)
+end
+
+def left_or_new args={}
+  left(args) || Card.new(args.merge(name: name.left))
+end
+
+def fields
+  field_names.map { |name| Card[name] }
+end
+
+def field_names parent_name=nil
+  child_names parent_name, :left
+end
+
+def children
+  child_names.map { |name| Card[name] }
+end
+
+def child_names parent_name=nil, side=nil
+  # eg, A+B is a child of A and B
+  parent_name ||= name
+  side ||= parent_name.to_name.simple? ? :part : :left
+  Card.search({ side => parent_name, return: :name },
+              "(#{side}) children of #{parent_name}")
+end
+
+# ids of children and children's children
+def descendant_ids parent_id=nil
+  return [] if new_card?
+  parent_id ||= id
+  Auth.as_bot do
+    child_ids = Card.search part: parent_id, return: :id
+    child_descendant_ids = child_ids.map { |cid| descendant_ids cid }
+    (child_ids + child_descendant_ids).flatten.uniq
+  end
+end
+
+# children and children's children
+# NOTE - set modules are not loaded
+# -- should only be used for name manipulations
+def descendants
+  @descendants ||= descendant_ids.map { |id| Card.quick_fetch id }
+end
+
+def repair_key
+  Auth.as_bot do
+    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.name = key_blocker.name + "*trash#{rand(4)}"
+      key_blocker.save
+    end
+
+    saved =   (self.key = correct_key) && save!
+    saved ||= (self.name = current_key) && save!
+
+    if saved
+      descendants.each(&:repair_key)
+    else
+      Rails.logger.debug "FAILED TO REPAIR BROKEN KEY: #{key}"
+      self.name = "BROKEN KEY: #{name}"
+    end
+    self
+  end
+rescue StandardError
+  Rails.logger.info "BROKE ATTEMPTING TO REPAIR BROKEN KEY: #{key}"
+  self
+end
+
+def right_id= card_or_id
+  write_card_or_id :right_id, card_or_id
+end
+
+def left_id= card_or_id
+  write_card_or_id :left_id, card_or_id
+end
+
+def type_id= card_or_id
+  write_card_or_id :type_id, card_or_id
+end
+
+def write_card_or_id attribute, card_or_id
+  if card_or_id.is_a? Card
+    write_attribute_to_card attribute, card_or_id
+  else
+    write_attribute attribute, card_or_id
+  end
+end
+
+def write_attribute_to_card attribute, card
+  if card.id
+    write_attribute attribute, card.id
+  else
+    add_subcard card
+    card.director.prior_store = true
+    with_id_when_exists(card) do |id|
+      write_attribute attribute, id
+    end
+  end
+end
+
+def with_id_when_exists card, &block
+  card.director.call_after_store(&block)
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/name.rb ~~

data/tmpsets/set/mod003-core/all/name_events.rb

@@ -0,0 +1,118 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (NameEvents)
+#
+# STAGE: prepare to validate
+module NameEvents;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/name_events.rb"; end
+
+event :set_autoname, :prepare_to_validate, on: :create do
+  if name.blank? && (autoname_card = rule_card(:autoname))
+    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
+  end
+end
+
+# STAGE: validate
+
+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
+  rel = Card.where key: name.key, trash: false
+  rel = rel.where "id <> ?", id if id
+  if (existing = rel.take)
+    errors.add :name, tr(:error_name_exists, name: existing.name)
+  end
+end
+
+event :validate_legality_of_name do
+  if name.length > 255
+    errors.add :name, tr(:error_too_long, length: name.length)
+  elsif name.blank?
+    errors.add :name, tr(:error_blank_name)
+  elsif name.parts.include? ""
+    errors.add :name, tr(: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)
+  end
+end
+
+event :validate_key, after: :validate_name, on: :save do
+  if key.empty?
+    errors.add :key, tr(:error_blank_key) if errors.empty?
+  elsif key != name.key
+    errors.add :key, tr(:error_wrong_key, key: key, name: name)
+  end
+end
+
+# STAGE: store
+
+event :set_name, :store, changed: :name do
+  expire
+end
+
+event :set_left_and_right, :store,
+      changed: :name, on: :save do
+  if name.junction?
+    %i[left right].each do |side|
+      assign_side_id side
+    end
+  else
+    self.left_id = self.right_id = nil
+  end
+end
+
+# STAGE: finalize
+
+event :name_change_finalized, :finalize, changed: :name, on: :save do
+  # The events to update references has to happen after :cascade_name_changes,
+  # but :cascade_name_changes is defined after the reference events and
+  # and additionaly it is defined on :update but some of the reference
+  # events are on :save. Hence we need this additional hook to organize these events.
+end
+
+private
+
+def changing_existing_tag_to_junction?
+  return false unless changing_name_to_junction?
+  name_in_use_as_tag?
+end
+
+def name_in_use_as_tag?
+  !Card.where(right_id: id, trash: false).take.nil?
+end
+
+def changing_name_to_junction?
+  name.junction? && simple?
+end
+
+def assign_side_id side
+  sidename = name.send "#{side}_name"
+  sidecard = Card[sidename] || ActManager.card(sidename)
+
+  # eg, renaming A to A+B
+  old_name_in_way = (sidecard&.id && sidecard&.id == id)
+  suspend_name(sidename) if old_name_in_way
+  send "#{side}_id=", side_id_or_card(old_name_in_way, sidecard, sidename)
+end
+
+def side_id_or_card old_name_in_way, sidecard, sidename
+  if !sidecard || old_name_in_way
+    add_subcard(sidename.s)
+  else
+    # if sidecard doesn't have an id, it's already part of this act
+    sidecard.id || sidecard
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/name_events.rb ~~

data/tmpsets/set/mod003-core/all/observer.rb

@@ -0,0 +1,31 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Observer)
+#
+module Observer;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/observer.rb"; end
+%i[create update delete].each do |action|
+  event "observer_#{action}".to_sym, :integrate, on: action do
+    execute_card_events on: action
+  end
+end
+
+event :cache_delete_card_events, :store, on: :delete do
+  @card_event_cache = event_cards :on_delete
+end
+
+def execute_card_events args
+  setting = "on_#{args[:on]}".to_sym
+  event_cards(setting).each do |event_card|
+    event_card.deliver self
+  end
+end
+
+def event_cards setting
+  @card_event_cache ||
+    ((event_rule = rule_card(setting)) && event_rule.extended_item_cards) ||
+    []
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/observer.rb ~~

data/tmpsets/set/{mod002-core → mod003-core}/all/pattern.rb

@@ -1,6 +1,10 @@
 # -*- encoding : utf-8 -*-
-class Card; module Set; class All; module Pattern; extend Card::Set
-# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/pattern.rb ~~
+class Card; module Set; class All
+# Set: All cards (Pattern)
+#
+module Pattern;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/pattern.rb"; end
 
 def patterns
   @patterns ||= set_patterns.map { |sub| sub.new self }.compact
@@ -19,17 +23,12 @@ def reset_patterns
   true
 end
 
-def reset_patterns_if_rule saving=false
-  if !new_card? && is_rule?
-    set = left
-    set.reset_patterns
-    set.include_set_modules
+def reset_patterns_if_rule _saving=false
+  return unless real? && is_rule? && (set = left)
 
-    # FIXME: should be in right/read.rb
-    if saving && right.id == Card::ReadID
-      add_to_read_rule_update_queue set.item_cards(limit: 0)
-    end
-  end
+  set.reset_patterns
+  set.include_set_modules
+  set
 end
 
 def safe_set_keys
@@ -61,7 +60,5 @@ end
 def rule_set_keys
   @rule_set_keys ||= patterns.map(&:rule_set_key).compact
 end
-
-
-# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/pattern.rb ~~
 end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/pattern.rb ~~