card 1.16.14 → 1.16.15

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

@@ -121,22 +121,31 @@ def left_or_new args={}
   left(args) || Card.new(args.merge(name: cardname.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
-  children_names.map { |name| Card[name] }
+  child_names.map { |name| Card[name] }
 end
 
-def children_names parent_name=nil
+def child_names parent_name=nil, side=nil
   # eg, A+B is a child of A and B
   parent_name ||= name
-  field = parent_name.to_name.simple? ? :part : :left
-  Card.search field => parent_name, return: :name
+  side ||= parent_name.to_name.simple? ? :part : :left
+  Card.search({ side => parent_name, return: :name },
+              "(#{side}) children of #{parent_name}")
 end
 
 def descendant_names parent_name=nil
   return [] if new_card?
   parent_name ||= name
   Auth.as_bot do
-    deps = children_names parent_name
+    deps = child_names parent_name
     deps.inject(deps) do |array, childname|
       array + descendant_names(childname)
     end
@@ -223,8 +232,9 @@ end
 event :set_autoname, before: :validate_name, on: :create do
   if name.blank? && (autoname_card = rule_card(:autoname))
     self.name = autoname autoname_card.content
-    # FIXME: should give placeholder on new, do next and save on create
-    Auth.as_bot { autoname_card.refresh.update_attributes! content: name }
+    # FIXME: should give placeholder in approve phase
+    # and finalize/commit change in store phase
+    autoname_card.refresh.update_column :db_content, name
   end
 end
 

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

@@ -19,26 +19,28 @@ def reset_patterns_if_rule saving=false
     set.reset_patterns
     set.include_set_modules
 
-    #this is really messy.
-    if saving
-      self.add_to_read_rule_update_queue( set.item_cards limit: 0 ) if right.id == Card::ReadID
+    # FIXME: should be in right/read.rb
+    if saving && right.id == Card::ReadID
+      self.add_to_read_rule_update_queue(set.item_cards limit: 0)
     end
   end
 end
 
 def safe_set_keys
-  patterns.map( &:safe_key ).reverse * " "
+  patterns.map(&:safe_key).reverse * " "
 end
 
 def set_modules
-  @set_modules ||= patterns_without_new[0..-2].reverse.map(&:module_list).flatten.compact
+  @set_modules ||=
+    patterns_without_new[0..-2].reverse.map(&:module_list).flatten.compact
 end
 
 def set_format_modules klass
   @set_format_modules ||= {}
-  @set_format_modules[klass] = patterns_without_new[0..-2].reverse.map do |pattern|
-    pattern.format_module_list klass
-  end.flatten.compact
+  @set_format_modules[klass] =
+    patterns_without_new[0..-2].reverse.map do |pattern|
+      pattern.format_module_list klass
+    end.flatten.compact
 end
 
 def set_names
@@ -50,7 +52,6 @@ def set_names
 end
 
 def rule_set_keys
-  set_names #this triggers set_members cache.  need better solution!
-  @rule_set_keys ||= patterns.map( &:rule_set_key ).compact
+  set_names # this triggers set_members cache.  need better solution!
+  @rule_set_keys ||= patterns.map(&:rule_set_key).compact
 end
-

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

@@ -32,32 +32,39 @@ end
 def who_can action
   # warn "who_can[#{name}] #{(prc=permission_rule_card(action)).inspect},
   # #{prc.first.item_cards.map(&:id)}" if action == :update
-  permission_rule_card(action).first.item_cards.map &:id
+  permission_rule_card(action).item_cards.map &:id
+end
+
+def permission_rule_id_and_class action
+  direct_rule_id = rule_card_id action
+  require_permission_rule! direct_rule_id, action
+  direct_rule = Card.fetch direct_rule_id, skip_modules: true
+  [applicable_permission_rule_id(direct_rule, action),
+   direct_rule.rule_class_name]
+end
+
+def applicable_permission_rule_id direct_rule, action
+  if junction? && direct_rule.db_content =~ /^\[?\[?_left\]?\]?$/
+    lcard = left_or_new(skip_virtual: true, skip_modules: true)
+    if action == :create && lcard.real? && !lcard.action == :create
+      action = :update
+    end
+    lcard.permission_rule_id_and_class(action).first
+  else
+    direct_rule.id
+  end
 end
 
 def permission_rule_card action
-  opcard = rule_card action
+  Card.fetch permission_rule_id_and_class(action).first
+end
 
+def require_permission_rule! rule_id, action
+  return if rule_id
   # RULE missing.  should not be possible.
   # generalize this to handling of all required rules
-  unless opcard
-    errors.add :permission_denied, "No #{action} rule for #{name}"
-    raise Card::PermissionDenied.new(self)
-  end
-
-  rcard = Auth.as_bot do
-    # compound cards can inherit permissions from left parent
-    if ['_left', '[[_left]]'].member?(opcard.db_content) && self.junction?
-      lcard = left_or_new(skip_virtual: true, skip_modules: true)
-      if action == :create && lcard.real? && !lcard.action == :create
-        action = :update
-      end
-      lcard.permission_rule_card(action).first
-    else
-      opcard
-    end
-  end
-  return rcard, opcard.rule_class_name
+  errors.add :permission_denied, "No #{action} rule for #{name}"
+  raise Card::PermissionDenied.new(self)
 end
 
 def rule_class_name
@@ -114,7 +121,7 @@ end
 
 def ok_to_read
   return if Auth.always_ok?
-  @read_rule_id ||= permission_rule_card(:read).first.id.to_i
+  @read_rule_id ||= permission_rule_id_and_class(:read).first
   return if Auth.as_card.read_rules.member? @read_rule_id
   deny_because you_cant 'read this'
 end
@@ -138,24 +145,26 @@ def ok_to_comment
   deny_because 'No comments allowed on structured content' if structure
 end
 
-event :set_read_rule, before: :store do
-  if trash == true
-    self.read_rule_id = self.read_rule_class = nil
-  else
-    # avoid doing this on simple content saves?
-    rcard, rclass = permission_rule_card(:read)
-    self.read_rule_id = rcard.id
-    self.read_rule_class = rclass
-    # find all cards with me as trunk and update their read_rule
-    # (because of *type plus right)
-    # skip if name is updated because will already be resaved
-
-    if !new_card? && type_id_changed?
-      Auth.as_bot do
-        Card.search(left: self.name).each do |plus_card|
-          plus_card = plus_card.refresh.update_read_rule
-        end
-      end
+event :clear_read_rule, before: :store, on: :delete do
+  self.read_rule_id = self.read_rule_class = nil
+end
+
+event :set_read_rule, before: :store, on: :save do
+  # avoid doing this on simple content saves?
+  read_rule_id, read_rule_class = permission_rule_id_and_class(:read)
+  self.read_rule_id = read_rule_id
+  self.read_rule_class = read_rule_class
+end
+
+event :set_field_read_rules,
+      after: :set_read_rule, on: :update, changed: :type_id do
+  # find all cards with me as trunk and update their read_rule
+  # (because of *type plus right)
+  # skip if name is updated because will already be resaved
+
+  Auth.as_bot do
+    fields.each do |field|
+      field.refresh.update_read_rule
     end
   end
 end
@@ -176,9 +185,9 @@ def update_read_rule
   # currently doing a brute force search for every card that may be impacted.
   # may want to optimize(?)
   Auth.as_bot do
-    Card.search(left: name).each do |plus_card|
-      if plus_card.rule(:read) == '_left'
-        plus_card.update_read_rule
+    fields.each do |field|
+      if field.rule(:read) == '_left'
+        field.update_read_rule
       end
     end
   end

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

@@ -143,7 +143,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/mod/01_core/set/all/references.rb

@@ -68,7 +68,7 @@ def update_references rendered_content = nil, refresh = false
               end
             Card::Reference.create!(
               referer_id:  id,
-              referee_id:  Card.where(key: name.key).pluck(:id).first,
+              referee_id:  Card.fetch_id(name),
               referee_key: name.key,
               ref_type:    ref_type,
               present:     1
@@ -108,7 +108,7 @@ end
 protected
 
 
-event :refresh_references, after: :store, on: :save do
+event :refresh_references, after: :store, on: :save, changed: :content do
   self.update_references
   expire_structuree_references
 end

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

@@ -48,7 +48,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={}
@@ -71,21 +71,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
@@ -174,11 +177,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] || []
@@ -187,11 +191,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
@@ -282,15 +289,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
@@ -299,18 +306,4 @@ 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
-
-

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

@@ -36,7 +36,18 @@ def unfilled?
     !subcards.present?
 end
 
-event :reject_empty_subcards, after: :approve, on: :save do
+event :approve_subcards, after: :approve, on: :save do
+  subcards.each do |subcard|
+    if !subcard.valid_subcard?
+      subcard.errors.each do |field, err|
+        err = "#{field} #{err}" unless [:content, :abort].member? field
+        errors.add subcard.relative_name.s, err
+      end
+    end
+  end
+end
+
+event :reject_empty_subcards, before: :approve_subcards do
   subcards.each_with_key do |subcard, key|
     if subcard.new? && subcard.unfilled?
       remove_subcard key
@@ -49,17 +60,6 @@ end
 event :process_subcards, after: :reject_empty_subcards, on: :save do
 end
 
-event :approve_subcards, after: :process_subcards do
-  subcards.each do |subcard|
-    if !subcard.valid_subcard?
-      subcard.errors.each do |field, err|
-        err = "#{field} #{err}" unless [:content, :abort].member? field
-        errors.add subcard.relative_name.s, err
-      end
-    end
-  end
-end
-
 event :store_subcards, after: :store do
   subcards.each do |subcard|
     subcard.save! validate: false if subcard != self # unless @draft

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

@@ -21,7 +21,7 @@ def assign_attributes args={}
 end
 
 def assign_set_specific_attributes
-  return unless @set_specific && @set_specific.present?
+  return unless @set_specific.present?
   @set_specific.each_pair do |name, value|
     send "#{name}=", value
   end

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

@@ -7,7 +7,7 @@ end
 
 def type_card
   return if type_id.nil?
-  Card.fetch type_id.to_i, skip_modules: true
+  Card.quick_fetch type_id.to_i
 end
 
 def type_code
@@ -18,6 +18,10 @@ def type_name
   type_card.try :name
 end
 
+def type_name_or_default
+  type_card.try(:name) || Card.quick_fetch(Card.default_type_id).name
+end
+
 def type_cardname
   type_card.try :cardname
 end
@@ -51,16 +55,12 @@ event :validate_type, before: :approve, changed: :type_id do
 end
 
 event :reset_type_specific_fields, after: :store do
+  wql = { left: { left_id: type_id },
+          right: { codename: 'type_plus_right' }
+        }
+  wql_comment = "sets with a type_plus_right rule for #{name}"
+
   Auth.as_bot do
-    Card.search left: { left_id: type_id },
-                right: { codename: 'type_plus_right' } do |set_card|
-      set_card.reset_set_patterns
-    end
+    Card.search(wql, wql_comment).each &:reset_set_patterns
   end
 end
-
-#    Card.search left_plus: [ type_name, right_plus: {codename:
-#      'type_plus_right'}] do |right_anchor|
-#      Card["#{lef}"]
-#      set_card.reset_set_patterns
-#    end