card 1.101.1 → 1.101.6

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/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,
-      changed: :name, 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, changed: :name, 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

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

@@ -1,33 +0,0 @@
-event :rename_in_trash, after: :expire_old_name, on: :update do
-  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_in_trash_without_callbacks
-  existing_card.save!
-end
-
-event :validate_renaming, :validate, on: :update, changed: :name, skip: :allowed do
-  return if name_before_act&.to_name == name # just changing to new variant
-  errors.add :content, tr(:cannot_change_content) if content_is_changing?
-  errors.add :type, tr(:cannot_change_type) if type_is_changing?
-  detect_illegal_compound_names
-end
-
-event :cascade_name_changes, :finalize, on: :update, changed: :name do
-  each_descendant do |d|
-    d.action = :update
-    update_referers ? d.update_referers : d.update_referer_references_out
-    d.refresh_references_in
-    d.refresh_references_out
-    d.expire
-  end
-end
-
-def changed_from_simple_to_compound?
-  name.compound? && name_before_act.to_name.simple?
-end
-
-def detect_illegal_compound_names
-  return unless changed_from_simple_to_compound? && child_ids(:right).present?
-  errors.add :name, "illegal name change; existing names end in +#{name_before_act}"
-end

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

@@ -1,81 +0,0 @@
-def rule setting_code
-  rule_card(setting_code, skip_modules: true)&.db_content
-end
-
-def rule_card setting_code, options={}
-  Card.fetch rule_card_id(setting_code), options
-end
-
-def rule_card_id setting_code
-  rule_id_lookup Card::Rule.rule_cache, setting_code
-end
-
-def preference setting_code, user=nil
-  preference_card(setting_code, user, skip_modules: true)&.db_content
-end
-
-def preference_card setting_code, user=nil, options={}
-  Card.fetch preference_card_id(setting_code, user), options
-end
-
-def preference_card_id setting_code, user=nil
-  return unless (user_id = preference_user_id user)
-  rule_id_lookup Card::Rule.preference_cache,
-                 "#{setting_code}+#{user_id}",
-                 "#{setting_code}+#{AllID}"
-end
-
-def is_rule?
-  is_standard_rule? || is_preference?
-end
-
-def is_standard_rule?
-  (r = right(skip_modules: true)) &&
-    r.type_id == SettingID &&
-    (l = left(skip_modules: true)) &&
-    l.type_id == SetID
-end
-
-def is_preference?
-  name.parts.length > 2 &&
-    (r = right(skip_modules: true)) &&
-    r.type_id == SettingID &&
-    (set = self[0..-3, skip_modules: true]) &&
-    set.type_id == SetID &&
-    (user = self[-2, skip_modules: true]) &&
-    (user.type_id == UserID || user.codename == :all)
-end
-
-# FIXME: move to a better place (if still needed) and use codenames
-def related_sets with_self=false
-  # refers to sets that users may configure from the current card -
-  # NOT to sets to which the current card belongs
-
-  sets = []
-  sets << ["#{name}+*self", Card::Set::Self.label(name)] if with_self
-  if known? && name.simple?
-    sets << ["#{name}+*right", Card::Set::Right.label(name)]
-  end
-  sets
-end
-
-private
-
-def preference_user_id user
-  case user
-  when Integer then user;
-  when Card    then user
-  when nil     then Auth.current_id
-  else
-    raise Card::ServerError, "invalid preference user"
-  end
-end
-
-def rule_id_lookup lookup_hash, cache_suffix, fallback_suffix=nil
-  rule_set_keys.each do |rule_set_key|
-    rule_id = lookup_hash["#{rule_set_key}+#{cache_suffix}"]
-    rule_id ||= fallback_suffix && lookup_hash["#{rule_set_key}+#{fallback_suffix}"]
-    return rule_id if rule_id
-  end
-  nil
-end

data/mod/core/spec/set/all/actify_spec.rb

@@ -1,58 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-RSpec.describe Card::Set::All::Actify do
-  describe "#act" do
-    let(:card) { Card["A"] }
-
-    before do
-      allow(card).to receive(:act).and_return nil
-    end
-
-    it "is called by valid?" do
-      card.valid?
-      expect(card).to have_received :act
-    end
-
-    it "is called by #save!" do
-      card.save!
-      expect(card).to have_received :act
-    end
-
-    it "is called by #save" do
-      card.save
-      expect(card).to have_received :act
-    end
-
-    it "is called by #update" do
-      card.update content: "A"
-      expect(card).to have_received :act
-    end
-
-    it "is called by #update!" do
-      card.update! content: "A"
-      expect(card).to have_received :act
-    end
-
-    it "is called by #update_attributes" do
-      card.update_attributes content: "A"
-      expect(card).to have_received :act
-    end
-
-    it "is called by #update_attributes!" do
-      card.update_attributes! content: "A"
-      expect(card).to have_received :act
-    end
-  end
-
-  describe "Card.create!" do
-    it "does not prevent validations when run as subcard" do
-      with_test_events do
-        test_event :finalize do
-          expect { Card.create! name: "A" }.to raise_error(/unique/)
-          raise Card::Error, "woot"
-        end
-        expect { Card["B"].update! content: "what" }.to raise_error(/woot/)
-      end
-    end
-  end
-end