card 1.16.15 → 1.17.0

data/tmpsets/set/mod001-01_core/all/phases.rb

@@ -146,7 +146,8 @@ def phase_ok? opts
   phase && (
     (opts[:during] && in?(opts[:during])) ||
     (opts[:before] && before?(opts[:before])) ||
-    (opts[:after]  && after?(opts[:after]))
+    (opts[:after]  && after?(opts[:after])) ||
+    true # no phase restriction in opts
   )
 end
 

data/tmpsets/set/mod001-01_core/all/references.rb

@@ -2,118 +2,94 @@
 class Card; module Set; module All; module References; extend Card::Set
 # ~~~~~~~~~~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/references.rb ~~~~~~~~~~~
 
+PARTIAL_REF_CODE = 'P'
+
 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 }
+  Card.joins(:references_to).where card_references: { referee_key: link_name }
 end
 
 def extended_referencers
-  # FIXME .. we really just need a number here.
-  (dependents + [self]).map(&:referencers).flatten.uniq
+  # FIXME: .. we really just need a number here.
+  (descendants + [self]).map(&:referencers).flatten.uniq
 end
 
-
 # replace references in card content
 def replace_references old_name, new_name
-  obj_content = Card::Content.new raw_content, card=self
-  obj_content.find_chunks( Card::Chunk::Reference ).select do |chunk|
-    if old_ref_name = chunk.referee_name and new_ref_name = old_ref_name.replace_part(old_name, new_name)
-      chunk.referee_name = chunk.replace_reference old_name, new_name
-      Card::Reference.where( referee_key: old_ref_name.key ).update_all referee_key: new_ref_name.key
-    end
+  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
   end
 
   obj_content.to_s
 end
 
 # update entries in reference table
-def update_references rendered_content = nil, refresh = false
-  raise "update references should not be called on new cards" if id.nil?
-
-  Card::Reference.delete_all_from self
+def update_references rendered_content=nil
+  raise 'update references should not be called on new cards' if id.nil?
 
-  # FIXME: why not like this: references_expired = nil # do we have to make sure this is saved?
-  #Card.update( id, references_expired: nil )
-  #  or just this and save it elsewhere?
-  #references_expired=nil
+  Card::Reference.delete_all_from self unless self.new_card?
 
-  Card.connection.execute("update cards set references_expired=NULL where id=#{id}")
-#  references_expired = nil
-  expire if refresh
-
-  rendered_content ||= Card::Content.new(raw_content, card=self)
+  rendered_content ||= Card::Content.new raw_content, self
   rendered_content.find_chunks(Card::Chunk::Reference).each do |chunk|
-    if referee_name = chunk.referee_name # name is referenced (not true of commented inclusions)
-      referee_id = chunk.referee_id
-      if id != referee_id               # not self reference
-
-        #update_references chunk.referee_name if Card::Content === chunk.referee_name
-        # for the above to work we will need to get past delete_all!
-        referee_name.piece_names.each do |name|
-          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 =
-              if name == referee_name
-                case chunk
-                when Card::Chunk::Link then 'L'
-                when Card::Chunk::QueryReference then 'Q'
-                else 'I'
-                end
-              else 'P'
-              end
-            Card::Reference.create!(
-              referer_id:  id,
-              referee_id:  Card.where(key: name.key).pluck(:id).first,
-              referee_key: name.key,
-              ref_type:    ref_type,
-              present:     1
-            )
-          end
-        end
-      end
-
-    end
+    create_reference_to chunk
   end
 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
+    )
+  end
+end
 
 def referencers
-  return [] unless refs = references_from
-  refs.map(&:referer_id).map( &Card.method(:fetch) ).compact
+  references_from.map(&:referer_id).map(&Card.method(:fetch)).compact
 end
 
 def includers
-  return [] unless refs = references_from.where( ref_type: 'I' )
-  refs.map(&:referer_id).map( &Card.method(:fetch) ).compact
+  references_from.where(ref_type: 'I')
+    .map(&:referer_id).map(&Card.method(:fetch)).compact
 end
 
 def referees
-  return [] unless refs = references_to
-  refs.map { |ref| Card.fetch ref.referee_key, new: {} }.compact
+  references_to.map { |ref| Card.fetch ref.referee_key, new: {} }
 end
 
 def includees
-  return [] unless refs = references_to.where( ref_type: 'I' )
-  refs.map { |ref| Card.fetch ref.referee_key, new: {} }.compact
+  references_to.where(ref_type: 'I')
+    .map { |ref| Card.fetch ref.referee_key, new: {} }
 end
 
-
-
 protected
 
-
-event :refresh_references, after: :store, on: :save do
-  self.update_references
-  expire_structuree_references
+event :refresh_references, after: :store, on: :save, changed: :content do
+  update_references
 end
 
 event :refresh_references_on_create, before: :refresh_references, on: :create do
@@ -123,7 +99,6 @@ end
 
 event :refresh_references_on_delete, after: :store, on: :delete do
   Card::Reference.update_on_delete self
-  expire_structuree_references
 end
 
 

data/tmpsets/set/mod001-01_core/all/rules.rb

@@ -1,10 +1,9 @@
 # -*- encoding : utf-8 -*-
 class Card; module Set; module All; module Rules; extend Card::Set
 # ~~~~~~~~~~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/rules.rb ~~~~~~~~~~~
-
-
 RuleSQL = %{
-  select rules.id as rule_id, settings.id as setting_id, sets.id as set_id, sets.left_id as anchor_id, sets.right_id as set_tag_id
+  select rules.id as rule_id, settings.id as setting_id, sets.id as set_id,
+    sets.left_id as anchor_id, sets.right_id as set_tag_id
   from cards rules
   join cards sets     on rules.left_id  = sets.id
   join cards settings on rules.right_id = settings.id
@@ -22,15 +21,15 @@ ReadRuleSQL = %{
   where read_rules.right_id = #{Card::ReadID} and read_rules.trash is false and sets.type_id = #{Card::SetID};
 }
 
- def is_rule?
-   is_standard_rule? || is_user_rule?
- end
+def is_rule?
+  is_standard_rule? || is_user_rule?
+end
 
 def is_standard_rule?
-  (r = right( skip_modules: true )) &&
-  r.type_id == Card::SettingID       &&
-  (l = left( skip_modules: true ))  &&
-  l.type_id == Card::SetID
+  (r = right( skip_modules: true ))  &&
+    r.type_id == Card::SettingID     &&
+    (l = left( skip_modules: true )) &&
+    l.type_id == Card::SetID
 end
 
 def is_user_rule?
@@ -51,7 +50,7 @@ def rule setting_code, options={}
 end
 
 def rule_card setting_code, options={}
-  Card.fetch rule_card_id( setting_code, options ), options
+  Card.fetch rule_card_id(setting_code, options), options
 end
 
 def rule_card_id setting_code, options={}
@@ -74,21 +73,24 @@ def rule_card_id setting_code, options={}
 end
 
 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
+  # refers to sets that users may configure from the current card -
+  # NOT to sets to which the current card belongs
 
-  sets = []
-  sets << ["#{name}+*type",  Card::TypeSet.label( name) ] if known? && type_id==Card::CardtypeID
-  sets << ["#{name}+*self",  Card::SelfSet.label( name) ] if with_self
-  sets << ["#{name}+*right", Card::RightSet.label(name) ] if known? && cardname.simple?
+  # FIXME: change to use codenames!!
 
-#      Card.search(type: 'Set',left: {right: name},right: '*type plus right',return: 'name').each do |set_name|
-#        sets<< set_name
-#      end
+  sets = []
+  if known? && type_id == Card::CardtypeID # FIXME: belongs in type/cardtype
+    sets << ["#{name}+*type", Card::TypeSet.label(name)]
+  end
+  if with_self
+    sets << ["#{name}+*self", Card::SelfSet.label(name)]
+  end
+  if known? && cardname.simple?
+    sets << ["#{name}+*right", Card::RightSet.label(name)]
+  end
   sets
 end
 
-
-
 module ClassMethods
 
   # User-specific rule use the pattern
@@ -113,18 +115,20 @@ module ClassMethods
       join cards settings  on user_rules.right_id = settings.id
       join cards users     on user_sets.right_id  = users.id
       join cards sets      on user_sets.left_id = sets.id
-      where   sets.type_id      = #{Card::SetID }               and sets.trash       is false
-        and   settings.type_id  = #{Card::SettingID}            and settings.trash   is false
-        and   ( #{user_restriction} or users.codename = 'all' ) and users.trash      is false
-        and                                                         user_sets.trash  is false
-        and                                                         user_rules.trash is false;
+      where sets.type_id     = #{Card::SetID }
+        and settings.type_id = #{Card::SettingID}
+        and (#{user_restriction} or users.codename = 'all')
+        and sets.trash       is false
+        and settings.trash   is false
+        and users.trash      is false
+        and user_sets.trash  is false
+        and user_rules.trash is false;
     }
   end
 
-
-  def setting name
+  def global_setting name
     Auth.as_bot do
-      card=Card[name] and !card.db_content.strip.empty? and card.db_content
+      (card = Card[name]) && !card.db_content.strip.empty? && card.db_content
     end
   end
 
@@ -177,11 +181,12 @@ module ClassMethods
   end
 
   def all_user_ids_with_rule_for set_card, setting_code
-    key = if (l=set_card.left) and (r=set_card.right)
-        set_class_code = Codename[ r.id ]
+    key =
+      if (l = set_card.left) && (r = set_card.right)
+        set_class_code = Codename[r.id]
         "#{l.id}+#{set_class_code}+#{setting_code}"
       else
-        set_class_code = Codename[ set_card.id ]
+        set_class_code = Codename[set_card.id]
         "#{set_class_code}+#{setting_code}"
       end
     user_ids = user_ids_cache[key] || []
@@ -190,11 +195,14 @@ module ClassMethods
     else
       user_ids
     end
-
   end
 
   def user_rule_cards user_name, setting_code
-    Card.search right: {codename: setting_code}, left: {left: {type_id: SetID}, right: user_name}
+    Card.search(
+      { right: { codename: setting_code },
+        left: { left: { type_id: SetID }, right: user_name }
+        }, "rule cards for user: #{user_name}"
+    )
   end
 
   def rule_cache
@@ -285,15 +293,15 @@ module ClassMethods
     Card.cache.write 'RULE_KEYS', hash
   end
 
-
-
   def read_rule_cache
     Card.cache.read('READRULES') || begin
       hash = {}
-      ActiveRecord::Base.connection.select_all( Card::Set::All::Rules::ReadRuleSQL ).each do |row|
-        party_id, read_rule_id = row['party_id'].to_i, row['read_rule_id'].to_i
+      ActiveRecord::Base.connection.select_all(
+        Card::Set::All::Rules::ReadRuleSQL
+      ).each do |row|
+        party_id = row['party_id'].to_i
         hash[party_id] ||= []
-        hash[party_id] << read_rule_id
+        hash[party_id] << row['read_rule_id'].to_i
       end
       Card.cache.write 'READRULES', hash
     end
@@ -302,22 +310,8 @@ module ClassMethods
   def clear_read_rule_cache
     Card.cache.write 'READRULES', nil
   end
-=begin
-  def default_rule setting_code, fallback=nil
-    card = default_rule_card setting_code, fallback
-    return card && card.content
-  end
-
-  def default_rule_card setting_code, fallback=nil
-    rule_id = rule_cache["all+#{setting_code}"]
-    rule_id ||= fallback && rule_cache["all+#{fallback}"]
-    Card[rule_id] if rule_id
-  end
-=end
 end
 
 
-
-
 # ~~~~~~~~~~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/rules.rb ~~~~~~~~~~~
 end;end;end;end;

data/tmpsets/set/mod001-01_core/all/templating.rb

@@ -16,117 +16,61 @@ def template
   @template ||= begin
     @virtual = false
 
-    # NEW CARDS
     if new_card?
-      default = rule_card :default, skip_modules: true
-
-      dup_card = dup
-      dup_card.type_id = default ? default.type_id : Card.default_type_id
-
-      if structure = dup_card.structure_rule_card
-        @virtual = true if junction?
-        self.type_id = structure.type_id if assign_type_to?(structure)
-        structure
-      else
-        default
-      end
-
-    # EXISTING CARDS
-    elsif structure = structure_rule_card
-      repair_type structure.type_id if assign_type_to?(structure)
-      structure
+      new_card_template
+    else
+      structure_rule_card
     end
   end
 end
 
-def assign_type_to? structure
-  type_id != structure.type_id and structure.assigns_type?
-end
-
-def structure
-  if template && template.is_structure?
-    template
-  end
-end
-
-def virtual?
-  return false unless new_card?
-  if @virtual.nil?
-    cardname.simple? ? @virtual=false : template
-  end
-  @virtual
-end
+def new_card_template
+  default = rule_card :default, skip_modules: true
 
-def structure_rule_card
-  card = rule_card :structure, skip_modules: true
-  card && card.db_content.strip == '_self' ? nil : card
-end
+  dup_card = dup
+  dup_card.type_id = default ? default.type_id : Card.default_type_id
 
-def structuree_names
-  if wql = structuree_spec
-    Auth.as_bot do
-      Card::Query.run(wql.merge return: :name)
-    end
+  if (structure = dup_card.structure_rule_card)
+    @virtual = true if junction?
+    self.type_id = structure.type_id if assign_type_to?(structure)
+    structure
   else
-    []
+    default
   end
 end
 
-# FIXME: content settings -- do we really need the reference expiration system?
-#
-# I kind of think so.  otherwise how do we handled patterned references in hard-templated cards?
-# I'll leave the FIXME here until the need (and/or other solution) is well documented.  -efm
-
-def expire_structuree_references
-  update_structurees references_expired: 1
-end
-
-def update_structurees args
-  # note that this is not smart about overriding templating rules
-  # for example, if someone were to change the type of a +*right+*structure rule that was overridden
-  # by a +*type plus right+*structure rule, the override would not be respected.
-  if query = structuree_spec
-    Auth.as_bot do
-      query[:return] = :id
-      Card::Query.run(query).each_slice(100) do |id_batch|
-        Card.where( id: id_batch ).update_all args
-      end
-    end
-  end
+def assign_type_to? structure
+  return if type_id == structure.type_id
+  structure.assigns_type?
 end
 
 def assigns_type?
   # needed because not all *structure templates govern the type of set members
   # for example, X+*type+*structure governs all cards of type X,
   # but the content rule does not (in fact cannot) have the type X.
-  if is_structure?
-    if set_pattern = Card.fetch( cardname.trunk_name.tag_name, skip_modules: true )
-      pattern_code = set_pattern.codename and
-      set_class    = Card::SetPattern.find( pattern_code ) and
-      set_class.assigns_type
-    end
-  end
+  return unless (set_pattern = Card.fetch cardname.trunk_name.tag_name,
+                                          skip_modules: true)
+  return unless (pattern_code = set_pattern.codename)
+  return unless (set_class = Card::SetPattern.find pattern_code)
+  set_class.assigns_type
 end
 
-private
-
-def repair_type template_type_id
-  # this is a mechanism for repairing bad data.  like #repair_key, it should be obviated and removed.
-  self.type_id = template_type_id
-  update_column :type_id, type_id
-  reset_patterns
+def structure
+  return unless template && template.is_structure?
+  template
 end
 
-def structuree_spec
-  if is_structure? and c=trunk and c.type_id = Card::SetID  #could use is_rule?...
-    c.get_query
+def virtual?
+  return false unless new_card?
+  if @virtual.nil?
+    cardname.simple? ? (@virtual = false) : template
   end
+  @virtual
 end
 
-event :update_structurees_type, after: :store, changed: :type_id do
-  if assigns_type? # certain *structure templates
-    update_structurees type_id: type_id
-  end
+def structure_rule_card
+  card = rule_card :structure, skip_modules: true
+  card && card.db_content.strip == '_self' ? nil : card
 end