card 1.101.0 → 1.101.5

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

@@ -1,35 +0,0 @@
-module ClassMethods
-  # a fetch method to support the needs of the card controller.
-  # should be in Decko?
-  def controller_fetch args
-    card_opts = controller_fetch_opts args
-    if args[:action] == "create"
-      # FIXME: we currently need a "new" card to catch duplicates
-      # (otherwise save will just act like a normal update)
-      # We may need a "#create" instance method to handle this checking?
-      Card.new card_opts
-    else
-      standard_controller_fetch args, card_opts
-    end
-  end
-
-  private
-
-  def standard_controller_fetch args, card_opts
-    mark = args[:mark] || card_opts[:name]
-    card = Card.fetch mark, skip_modules: true,
-                            look_in_trash: args[:look_in_trash],
-                            new: card_opts
-    card.assign_attributes card_opts if args[:assign] && card&.real?
-    card&.include_set_modules
-    card
-  end
-
-  def controller_fetch_opts args
-    opts = Env.hash args[:card]
-    opts[:type] ||= args[:type] if args[:type]
-    # for /new/:type shortcut.  we should handle in routing and deprecate this
-    opts[:name] ||= Card::Name.url_key_to_standard args[:mark]
-    opts
-  end
-end

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

@@ -1,11 +0,0 @@
-def tr key, args={}
-  args[:scope] ||= Card::Set.scope(caller)
-  ::I18n.t key, args
-end
-
-format do
-  def tr key, args={}
-    args[:scope] ||= Card::Set.scope(caller)
-    ::I18n.t key, args
-  end
-end

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

@@ -1,229 +0,0 @@
-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
-  @name ||= left_id ? Card::Lexicon.lex_to_name([left_id, right_id]) : super.to_name
-end
-
-def key
-  @key ||= left_id ? name.key : super
-end
-
-def name= newname
-  @name = superize_name newname.to_name
-  self.key = @name.key
-  update_subcard_names @name
-  write_attribute :name, (@name.simple? ? @name.s : nil)
-  assign_side_ids
-  @name
-end
-
-def assign_side_ids
-  if name.simple?
-    self.left_id = self.right_id = nil
-  else
-    assign_side_id :left_id=, :left_name
-    assign_side_id :right_id=, :right_name
-  end
-end
-
-# assigns left_id and right_id based on names.
-# if side card is new, id is temporarily stored as -1
-def assign_side_id side_id_equals, side_name
-  side_id = Card::Lexicon.id(name.send(side_name)) || -1
-  send side_id_equals, side_id
-end
-
-def superize_name cardname
-  return cardname unless @supercard
-
-  @supercard.subcards.rename key, cardname.key
-  update_superleft cardname
-  @supercard.name.relative? ? cardname : cardname.absolute_name(@supercard.name)
-end
-
-def update_superleft cardname
-  @superleft = @supercard if cardname.field_of? @supercard.name
-end
-
-def key= newkey
-  return if newkey == key
-  update_cache_key key do
-    write_attribute :key, (name.simple? ? newkey : nil)
-    @key = newkey
-  end
-  clean_patterns
-  @key
-end
-
-def clean_patterns
-  return unless patterns?
-  reset_patterns
-  patterns
-end
-
-def update_cache_key oldkey
-  yield
-  was_in_cache = Card.cache.soft.delete oldkey
-  Card.write_to_soft_cache self if was_in_cache
-end
-
-def update_subcard_names new_name, name_to_replace=nil
-  return unless @subcards
-  subcards.each do |subcard|
-    update_subcard_name subcard, new_name, name_to_replace if subcard.new?
-  end
-end
-
-def update_subcard_name subcard, new_name, name_to_replace
-  name_to_replace ||= name_to_replace_for_subcard subcard, new_name
-  subcard.name = subcard.name.swap name_to_replace, new_name.s
-  subcard.update_subcard_names new_name, name # needed?  shouldn't #name= trigger this?
-end
-
-def name_to_replace_for_subcard subcard, new_name
-  # 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
-  if subcard.name.starts_with_joint? && new_name.parts.first.present?
-    "".to_name
-  else
-    name
-  end
-end
-
-def autoname name
-  if Card.exists?(name) || Director.include?(name)
-    autoname name.next
-  else
-    name
-  end
-end
-
-# FIXME: use delegations and include all name functions
-delegate :simple?, :compound?, :junction?, to: :name
-
-def left *args
-  case
-  when simple?    then nil
-  when superleft then superleft
-  when name_is_changing? && name.to_name.trunk_name == name_before_act.to_name
-    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
-
-# NOTE: for all these helpers, method returns *all* fields/children/descendants.
-# (Not just those current user has permission to read.)
-
-def fields
-  field_ids.map { |id| Card[id] }
-end
-
-def field_names
-  field_ids.map { |id| Card::Name[id] }
-end
-
-def field_ids
-  child_ids :left
-end
-
-def each_child
-  child_ids.each do |id|
-    (child = Card[id]) && yield(child)
-    # check should not be needed (remove after fixing data problems)
-  end
-end
-
-# eg, A+B is a child of A and B
-def child_ids side=nil
-  return [] unless id
-  side ||= name.simple? ? :part : :left_id
-  Auth.as_bot do
-    Card.search({ side => id, return: :id, limit: 0 }, "children of #{name}")
-  end
-end
-
-def each_descendant &block
-  each_child do |child|
-    yield child
-    child.each_descendant(&block)
-  end
-end
-
-def right_id= cardish
-  write_card_or_id :right_id, cardish
-end
-
-def left_id= cardish
-  write_card_or_id :left_id, cardish
-end
-
-def write_card_or_id attribute, cardish
-  when_id_exists(cardish) { |id| write_attribute attribute, id }
-end
-
-def when_id_exists cardish, &block
-  if (card_id = Card.id cardish)
-    yield card_id
-  elsif cardish.is_a? Card
-    with_id_after_store cardish, &block
-  else
-    yield cardish # eg nil
-  end
-end
-
-# subcards are usually saved after super cards;
-# after_store forces it to save the subcard first
-# and callback afterwards
-def with_id_after_store subcard
-  add_subcard subcard
-  subcard.director.after_store { |card| yield card.id }
-end

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

@@ -1,54 +0,0 @@
-def patterns?
-  defined? @patterns
-end
-
-def all_patterns
-  @all_patterns ||= set_patterns.map { |sub| sub.new self }.compact
-end
-
-# new cards do not
-def patterns
-  @patterns ||= (new_card? ? all_patterns[1..-1] : all_patterns)
-end
-
-def reset_patterns
-  # Rails.logger.info "resetting patterns: #{name}"
-  @patterns = @all_patterns = nil
-  @template = @virtual = nil
-  @set_mods_loaded = @set_modules = @set_names = @rule_set_keys = nil
-  @junction_only = nil # only applies to set cards
-  true
-end
-
-def safe_set_keys
-  patterns.map(&:safe_key).reverse * " "
-end
-
-def set_modules
-  @set_modules ||= all_patterns[0..-2].reverse.map(&:module_list).flatten.compact
-end
-
-def set_format_modules klass
-  @set_format_modules ||= {}
-  @set_format_modules[klass] =
-    all_patterns[0..-2].reverse.map do |pattern|
-      pattern.format_module_list klass
-    end.flatten.compact
-end
-
-def set_names
-  @set_names = patterns.map(&:to_s) if @set_names.nil?
-  @set_names
-end
-
-def in_set? set_module
-  patterns.map(&:module_key).include? set_module.shortname
-end
-
-def rule_set_keys
-  @rule_set_keys ||= patterns.map(&:rule_set_key).compact
-end
-
-def include_module? set
-  singleton_class&.include? set
-end

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

@@ -1,191 +0,0 @@
-# frozen_string_literal: true
-
-# Cards can refer to other cards in their content, eg via links and nests.
-# The card that refers is the "referer", the card that is referred to is
-# the "referee". The reference itself has its own class (Card::Reference),
-# which handles id-based reference tracking.
-
-PARTIAL_REF_CODE = "P".freeze
-
-# cards that refer to self
-def referers
-  referer_cards_from_references references_in
-end
-
-# cards that include self
-def nesters
-  referer_cards_from_references references_in.where(ref_type: "I")
-end
-
-def referer_cards_from_references references
-  references.map(&:referer_id).uniq.map(&Card.method(:fetch)).compact
-end
-
-# cards that self refers to
-def referees
-  referees_from_references references_out
-end
-
-# cards that self includes
-def nestees
-  referees_from_references references_out.where(ref_type: "I")
-end
-
-def referees_from_references references
-  references.map(&:referee_key).uniq.map { |key| Card.fetch key, new: {} }
-end
-
-# cards that refer to self by name
-# (finds cards not yet linked by id)
-def name_referers
-  Card.joins(:references_out).where card_references: { referee_key: key }
-end
-
-# replace references in card content
-def replace_reference_syntax old_name, new_name
-  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.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
-  end
-
-  obj_content.to_s
-end
-
-# delete old references from this card's content, create new ones
-def update_references_out
-  delete_references_out
-  create_references_out
-end
-
-# interpret references from this card's content and
-# insert entries in reference table
-def create_references_out
-  ref_hash = {}
-  each_reference_out do |referee_name, ref_type|
-    interpret_reference ref_hash, referee_name, ref_type
-  end
-  return if ref_hash.empty?
-  Card::Reference.mass_insert reference_values_array(ref_hash)
-end
-
-# delete references from this card
-def delete_references_out
-  raise "id required to delete references" if id.nil?
-  Card::Reference.where(referer_id: id).delete_all
-end
-
-# interpretation phase helps to prevent duplicate references
-# results in hash like:
-# { referee1_key: [referee1_id, referee1_type2],
-#   referee2_key...
-# }
-def interpret_reference ref_hash, raw_referee_name, ref_type
-  with_normalized_referee raw_referee_name do |referee_name, referee_key, referee_id|
-    ref_hash[referee_key] ||= [referee_id]
-    ref_hash[referee_key] << ref_type
-    interpret_partial_references ref_hash, referee_name unless referee_id
-  end
-end
-
-# Partial references are needed to track references to virtual cards.
-# For example a link to virual card [[A+*self]] won't have a referee_id,
-# but when A's name is changed we have to find and update that link.
-def interpret_partial_references ref_hash, referee_name
-  return if referee_name.simple?
-  [referee_name.left, referee_name.right].each do |sidename|
-    interpret_reference ref_hash, sidename, PARTIAL_REF_CODE
-  end
-end
-
-# translate interpreted reference hash into values array,
-# removing duplicate and unnecessary ref_types
-def reference_values_array ref_hash
-  values = []
-  ref_hash.each do |referee_key, hash_val|
-    referee_id = hash_val.shift || "null"
-    ref_types = hash_val.uniq
-    ref_types.delete PARTIAL_REF_CODE if ref_types.size > 1
-    # partial references are not necessary if there are explicit references
-    ref_types.each do |ref_type|
-      values << [id, referee_id, "'#{referee_key}'", "'#{ref_type}'"]
-    end
-  end
-  values
-end
-
-# invokes the given block for each reference in content with
-# the reference name and reference type
-def each_reference_out
-  content_object.find_chunks(Card::Content::Chunk::Reference).each do |chunk|
-    yield chunk.referee_name, chunk.reference_code
-  end
-end
-
-def has_nests?
-  content_object.has_chunk? Card::Content::Chunk::Nest
-end
-
-def content_object
-  Card::Content.new content, self
-end
-
-protected
-
-# 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_reference_syntax 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,
-      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, on: :save do
-  Card::Reference.unmap_referees id if action == :update && !update_referers
-  Card::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
-  Card::Reference.unmap_referees id
-end
-
-def not_update_referers
-  !update_referers
-end
-
-private
-
-def with_normalized_referee referee_name
-  return unless referee_name # eg commented nest has no referee_name
-  referee_name = referee_name.to_name
-  referee_key = referee_name.key
-  return if referee_key == key # don't create self reference
-  yield referee_name, referee_key, Card::Lexicon.id(referee_name)
-end