card 1.17.1 → 1.17.2

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

@@ -1,6 +1,6 @@
 
 def patterns
-  @patterns ||= set_patterns.map { |sub| sub.new(self) }.compact
+  @patterns ||= set_patterns.map { |sub| sub.new self }.compact
 end
 
 def patterns_with_new
@@ -9,7 +9,10 @@ end
 alias_method_chain :patterns, :new
 
 def reset_patterns
-  @set_mods_loaded = @patterns = @set_modules = @junction_only = @set_names = @template = @rule_set_keys = @virtual = nil
+  @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
 
@@ -45,7 +48,7 @@ end
 
 def set_names
   if @set_names.nil?
-    @set_names = patterns.map &:to_s
+    @set_names = patterns.map(&:to_s)
     Card.set_members @set_names, key
   end
   @set_names

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

@@ -1,99 +1,172 @@
+# frozen_string_literal: true
 
-PARTIAL_REF_CODE = 'P'
+# 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.
 
-def name_referencers link_name=nil
-  link_name = link_name.nil? ? key : link_name.to_name.key
-  Card.joins(:references_to).where card_references: { referee_key: link_name }
+PARTIAL_REF_CODE = 'P'.freeze
+
+# cards that refer to self
+def referers
+  references_in.map(&:referer_id).map(&Card.method(:fetch)).compact
+end
+
+# cards that include self
+def includers
+  refs = references_in.where(ref_type: 'I')
+  refs.map(&:referer_id).map(&Card.method(:fetch)).compact
+end
+
+# cards that self refers to
+def referees
+  references_out.map { |ref| Card.fetch ref.referee_key, new: {} }
 end
 
-def extended_referencers
-  # FIXME: .. we really just need a number here.
-  (descendants + [self]).map(&:referencers).flatten.uniq
+# cards that self includes
+def includees
+  refs = references_out.where(ref_type: 'I')
+  refs.map { |ref| Card.fetch ref.referee_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
+
+# cards that refer to self or any descendant
+def family_referers
+  @family_referers ||= ([self] + descendants).map(&:referers).flatten.uniq
+  # FIXME: could be much more efficient!
 end
 
 # replace references in card content
-def replace_references old_name, new_name
+def replace_reference_syntax old_name, new_name
   obj_content = Card::Content.new raw_content, self
   obj_content.find_chunks(Card::Chunk::Reference).select do |chunk|
     next unless (old_ref_name = chunk.referee_name)
     next unless (new_ref_name = old_ref_name.replace_part old_name, new_name)
     chunk.referee_name = chunk.replace_reference old_name, new_name
-    old_references = Card::Reference.where(referee_key: old_ref_name.key)
-    old_references.update_all referee_key: new_ref_name.key
+    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
 
-# update entries in reference table
-def update_references rendered_content=nil
-  raise 'update references should not be called on new cards' if id.nil?
-
-  Card::Reference.delete_all_from self unless self.new_card?
-
-  rendered_content ||= Card::Content.new raw_content, self
-  rendered_content.find_chunks(Card::Chunk::Reference).each do |chunk|
-    create_reference_to chunk
-  end
+# delete old references from this card's content, create new ones
+def update_references_out
+  delete_references_out
+  create_references_out
 end
 
-def create_reference_to chunk
-  referee_name = chunk.referee_name
-  return false unless referee_name # eg no commented nest
-
-  referee_name.piece_names.each do |name|
-    next if name.key == key # don't create self reference
-
-    # reference types:
-    # L = link
-    # I = inclusion
-    # P = partial (i.e. the name is part of a compound name that is
-    #  referenced by a link or inclusion)
-
-    # The partial type is needed to keep track of references of virtual cards.
-    # For example a link [[A+*self]] won't make it to the reference table
-    # because A+*self is virtual and doesn't have an id but when A's name is
-    # changed we have to find and update that link.
-    ref_type = name != referee_name ? PARTIAL_REF_CODE : chunk.reference_code
-    Card::Reference.create!(
-      referer_id:  id,
-      referee_id:  Card.fetch_id(name),
-      referee_key: name.key,
-      ref_type:    ref_type,
-      present:     1
-    )
+# interpret references from this card's content and
+# insert entries in reference table
+def create_references_out
+  ref_hash = {}
+  content_obj = Card::Content.new raw_content, self
+  content_obj.find_chunks(Card::Chunk::Reference).each do |chunk|
+    interpret_reference ref_hash, chunk.referee_name, chunk.reference_code
   end
+  return if ref_hash.empty?
+  Card::Reference.mass_insert reference_values_array(ref_hash)
 end
 
-def referencers
-  references_from.map(&:referer_id).map(&Card.method(:fetch)).compact
+# delete references from this card
+def delete_references_out
+  fail 'id required to delete references' if id.nil?
+  Card::Reference.delete_all referer_id: id
 end
 
-def includers
-  references_from.where(ref_type: 'I')
-    .map(&:referer_id).map(&Card.method(:fetch)).compact
+# interpretation phase helps to prevent duplicate references
+# results in hash like:
+# { referee1_key: [referee1_id, referee1_type1, referee1_type2],
+#   referee2_key...
+# }
+def interpret_reference ref_hash, referee_name, ref_type
+  return unless referee_name # eg commented nest has no referee_name
+  referee_key = (referee_name = referee_name.to_name).key
+  return if referee_key == key # don't create self reference
+
+  referee_id = Card.fetch_id(referee_name)
+  ref_hash[referee_key] ||= [referee_id]
+  ref_hash[referee_key] << ref_type
+
+  interpret_partial_references ref_hash, referee_name unless referee_id
 end
 
-def referees
-  references_to.map { |ref| Card.fetch ref.referee_key, new: {} }
+# 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
+  [referee_name.left, referee_name.right].each do |sidename|
+    interpret_reference ref_hash, sidename, PARTIAL_REF_CODE
+  end
 end
 
-def includees
-  references_to.where(ref_type: 'I')
-    .map { |ref| Card.fetch ref.referee_key, new: {} }
+# 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
 
 protected
 
-event :refresh_references, after: :store, on: :save, changed: :content do
-  update_references
+# test for updating referer content & preload referer list
+event :prepare_referer_update, before: :approve, on: :update, changed: :name do
+  self.update_referers = ![nil, false, 'false'].member?(update_referers)
+  family_referers
 end
 
-event :refresh_references_on_create, before: :refresh_references, on: :create do
-  Card::Reference.update_existing_key self
-  # FIXME: bogus blank default content is set on structured cards...
+# when name changes, update references to card
+event :refresh_references_in, after: :store, on: :save, changed: :name 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, after: :store, on: :save, changed: :content do
+  update_references_out
+end
+
+# clean up reference table when card is deleted
+event :clear_references, after: :store, on: :delete do
+  delete_references_out
+  Card::Reference.unmap_referees id
+end
+
+# on rename, update names in cards that refer to self by name (as directed)
+event :update_referer_content,
+      after: :store, on: :update, changed: :name,
+      when: proc { |c| c.update_referers } do
+  # FIXME: break into correct stages
+  Auth.as_bot do
+    family_referers.each do |card|
+      next if card == self || card.structure
+      card = card.refresh
+      card.db_content = card.replace_reference_syntax name_was, name
+      card.save!
+    end
+  end
 end
 
-event :refresh_references_on_delete, after: :store, on: :delete do
-  Card::Reference.update_on_delete self
+# 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,
+      after: :store, on: :update, changed: :name,
+      when: proc { |c| !c.update_referers } do
+  family_referers.map(&:update_references_out)
 end

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

@@ -141,5 +141,5 @@ end
 event :expire_related_names, before: :expire_related, changed: :name do
   # FIXME: look for opportunities to avoid instantiating the following
   descendants.each { |c| c.expire(true) }
-  name_referencers.each { |c| c.expire(true) }
+  name_referers.each { |c| c.expire(true) }
 end

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

@@ -4,8 +4,8 @@ module ClassMethods
     Card.delete_trashed_files
     Card.where(trash: true).delete_all
     Card::Action.delete_cardless
-    Card::Reference.repair_missing_referees
-    Card::Reference.delete_missing_referers
+    Card::Reference.unmap_if_referee_missing
+    Card::Reference.delete_if_referer_missing
     Card.delete_tmp_files_of_cached_uploads
   end
 

data/mod/01_core/spec/set/all/references_spec.rb

@@ -1,8 +1,9 @@
 # -*- encoding : utf-8 -*-
 
 describe Card::Set::All::References do
-  it "should replace references should work on inclusions inside links" do
-    card = Card.create!(name: "ref test", content: "[[test_card|test{{test}}]]"  )
-    assert_equal "[[test_card|test{{best}}]]", card.replace_references("test", "best" )
+  it 'should replace references should work on inclusions inside links' do
+    card = Card.create! name: 'ref test', content: '[[test_card|test{{test}}]]'
+    assert_equal '[[test_card|test{{best}}]]',
+                 card.replace_reference_syntax('test', 'best')
   end
 end

data/mod/01_core/spec/set/all/tracked_attributes_spec.rb

@@ -6,7 +6,7 @@ module RenameMethods
       content:     card.content,
       # updater_id:  card.updater_id,
       # revisions:   card.actions.count,
-      referencers: card.referencers.map(&:name).sort,
+      referers: card.referers.map(&:name).sort,
       referees:    card.referees.map(&:name).sort,
       descendants:  card.descendants.map(&:id).sort
     }
@@ -16,7 +16,7 @@ module RenameMethods
     attrs_before = name_invariant_attributes(card)
     actions_count_before = card.actions.count
     card.name = new_name
-    card.update_referencers = true
+    card.update_referers = true
     card.save!
     expect(card.actions.count).to eq(actions_count_before + 1)
     assert_equal attrs_before, name_invariant_attributes(card)
@@ -119,13 +119,13 @@ describe Card::Set::All::TrackedAttributes do
       c = Card['Menu']
       c.name = 'manure'
       c.save!
-      expect(Card['manure'].references_from.size).to eq(0)
+      expect(Card['manure'].references_in.size).to eq(0)
     end
 
     it 'picks up new references' do
       Card.create name: 'kinds of poop', content: '[[manure]]'
       assert_rename Card['Menu'], 'manure'
-      expect(Card['manure'].references_from.size).to eq(2)
+      expect(Card['manure'].references_in.size).to eq(2)
     end
 
     it 'handles name variants' do
@@ -155,15 +155,9 @@ describe Card::Set::All::TrackedAttributes do
     end
 
     it 'test_update_descendants' do
-      card_list = [
-        Card['One+Two'],
-        Card['One+Two+Three'],
-        Card['Four+One'],
-        Card['Four+One+Five']
-      ]
-
-      old_names = %w{ One+Two One+Two+Three Four+One Four+One+Five }
-      new_names = %w{ Uno+Two Uno+Two+Three Four+Uno Four+Uno+Five }
+      old_names = %w( One+Two One+Two+Three Four+One Four+One+Five )
+      new_names = %w( Uno+Two Uno+Two+Three Four+Uno Four+Uno+Five )
+      card_list = old_names.map { |name| Card[name] }
 
       assert_equal old_names, card_list.map(&:name)
       Card['One'].update_attributes! name: 'Uno'
@@ -193,24 +187,24 @@ describe Card::Set::All::TrackedAttributes do
       expect(Card['Banana Card']).not_to be_nil
     end
 
-    it 'test_rename_should_not_fail_when_updating_inaccessible_referencer' do
+    it 'test_rename_should_not_fail_when_updating_inaccessible_referer' do
       Card.create! name: 'Joe Card', content: 'Whattup'
       Card::Auth.as 'joe_admin' do
         Card.create! name: 'Admin Card', content: '[[Joe Card]]'
       end
       c = Card['Joe Card']
-      c.update_attributes! name: 'Card of Joe', update_referencers: true
+      c.update_attributes! name: 'Card of Joe', update_referers: true
       assert_equal '[[Card of Joe]]', Card['Admin Card'].content
     end
 
-    it 'test_rename_should_update_structured_referencer' do
+    it 'test_rename_should_update_structured_referer' do
       Card::Auth.as_bot do
         c = Card.create! name: 'Pit'
         Card.create! name: 'Orange', type: 'Fruit', content: '[[Pit]]'
         Card.create! name: 'Fruit+*type+*structure', content: 'this [[Pit]]'
 
         assert_equal 'this [[Pit]]', Card['Orange'].raw_content
-        c.update_attributes! name: 'Seed', update_referencers: true
+        c.update_attributes! name: 'Seed', update_referers: true
         assert_equal 'this [[Seed]]', Card['Orange'].raw_content
       end
     end
@@ -260,14 +254,14 @@ describe Card::Set::All::TrackedAttributes do
       it 'test_renaming_card_with_self_link_should_not_hang' do
         c = Card['Dairy']
         c.name = 'Buttah'
-        c.update_referencers = true
+        c.update_referers = true
         c.save!
         assert_equal '[[/new/{{_self|name}}|new]]', Card['Buttah'].content
       end
 
       it 'should rename card without updating references' do
         c = Card['Dairy']
-        c.update_attributes name: 'Newt', update_referencers: false
+        c.update_attributes name: 'Newt', update_referers: false
         assert_equal '[[/new/{{_self|name}}|new]]', Card['Newt'].content
       end
     end
@@ -291,7 +285,7 @@ describe Card::Set::All::TrackedAttributes do
         c1 = Card['Blue']
         c2 = Card['blue includer 1']
         c3 = Card['blue includer 2']
-        c1.update_attributes name: 'Red', update_referencers: true
+        c1.update_attributes name: 'Red', update_referers: true
         assert_equal '{{Red}}', Card.find(c2.id).content
         # NOTE these attrs pass through a hash stage that may not preserve order
         assert_equal '{{Red|closed;other:stuff}}', Card.find(c3.id).content
@@ -301,7 +295,7 @@ describe Card::Set::All::TrackedAttributes do
         c1 = Card['Blue']
         c2 = Card['blue includer 1']
         c1.update_attributes name: 'blue includer 1+color',
-                             update_referencers: true
+                             update_referers: true
         assert_equal '{{blue includer 1+color}}', Card.find(c2.id).content
       end
 
@@ -310,7 +304,7 @@ describe Card::Set::All::TrackedAttributes do
         c2 = Card['blue linker 1']
         c3 = Card['blue linker 2']
         c1.reload.name = 'Red'
-        c1.update_referencers = true
+        c1.update_referers = true
         c1.save!
         assert_equal '[[Red]]', Card.find(c2.id).content
         assert_equal '[[Red]]', Card.find(c3.id).content

data/mod/01_history/lib/card/act.rb

@@ -2,39 +2,39 @@
 class Card
   class Act < ActiveRecord::Base
     before_save :set_actor
-    has_many :actions, -> { order :id },
-      { foreign_key: :card_act_id, inverse_of: :act, class_name: "Card::Action" }
+    has_many :actions,
+             -> { order :id },
+             foreign_key: :card_act_id,
+             inverse_of: :act,
+             class_name: 'Card::Action'
 
-    belongs_to :actor, class_name: "Card"
+    belongs_to :actor, class_name: 'Card'
     belongs_to :card
-    def set_actor
-      self.actor_id ||= Auth.current_id
-    end
 
-    def self.delete_actionless
-      Card::Act.where(
-        "id NOT IN (?)",
-        Card::Action.pluck("card_act_id"),
-      ).delete_all
-    end
+    class << self
+      def delete_actionless
+        joins(
+          'LEFT JOIN card_actions '\
+          'ON card_acts.id = card_actions.card_act_id'
+        ).where(
+          'card_actions.id is null'
+        ).delete_all
+      end
 
-    def self.find_all_with_actions_on card_ids, args={}
-      sql = 'card_actions.card_id IN (:card_ids) AND ( (draft is not true) '
-      sql << ( args[:with_drafts] ? 'OR actor_id = :current_user_id)' : ')' )
-      vars = {card_ids: card_ids, current_user_id: Card::Auth.current_id }
-      Card::Act.joins(:actions).where( sql, vars ).uniq.order(:id).reverse_order
+      def find_all_with_actions_on card_ids, args={}
+        sql = 'card_actions.card_id IN (:card_ids) AND ( (draft is not true) '
+        sql << (args[:with_drafts] ? 'OR actor_id = :current_user_id)' : ')')
+        vars = { card_ids: card_ids, current_user_id: Card::Auth.current_id }
+        joins(:actions).where(sql, vars).uniq.order(:id).reverse_order
+      end
     end
 
-    # def actor
-    #   Card[ actor_id ]
-    # end
-
-    # def card
- #      Card[ card_id ]
- #    end
+    def set_actor
+      self.actor_id ||= Auth.current_id
+    end
 
     def action_on card_id
-      actions.where( "card_id = #{card_id} and draft is not true" ).first
+      actions.where("card_id = #{card_id} and draft is not true").first
     end
 
     def main_action
@@ -47,20 +47,22 @@ class Card
 
     def relevant_drafts_for card
       drafts.select do |action|
-        card.included_card_ids.include?(action.card_id) || (card.id == action.card_id)
+        card.included_card_ids.include?(action.card_id) ||
+          (card.id == action.card_id)
       end
     end
 
-    def relevant_actions_for card, with_drafts=false
+    def relevant_actions_for card
       actions.select do |action|
-        card.included_card_ids.include?(action.card_id) || (card.id == action.card_id)
+        card.included_card_ids.include?(action.card_id) ||
+          (card.id == action.card_id)
       end
     end
 
-  private
+    private
+
     def timestamp_attributes_for_create
       super << :acted_at
     end
-
   end
 end