card-mod-follow 0.11.0

data/set/all/follow/followed_by.rb

@@ -0,0 +1,70 @@
+# used by +:followers overwritten in type/set.rb and type/cardtype.rb
+def followed?
+  followed_by? Auth.current_id
+end
+
+# for sets and cardtypes it doesn't check whether the users is following the
+# card itself instead it checks whether he is following the complete set
+def followed_by? user_id
+  follow_rule_applies?(user_id) || left&.followed_by_as_field?(self, user_id)
+end
+
+def followed_by_as_field? field, user_id
+  followed_field?(field) && followed_by?(user_id)
+end
+
+# returns true if according to the follow_field_rule followers of self also
+# follow changes of field_card
+def followed_field? field_card
+  return unless (follow_field_rule = rule_card(:follow_fields))
+
+  follow_field_rule.item_names(context: self).find do |item|
+    case item.to_name.key
+    when field_card.key         then true
+    when :nests.cardname.key then nested_card?(field_card)
+    end
+  end
+end
+
+def nested_card? card
+  nestee_ids.include? card.id
+end
+
+## the following methods all handle _explicit_ (direct) follow rules (not fields)
+
+def follow_rule_applies? follower_id
+  !follow_rule_option(follower_id).nil?
+end
+
+def follow_rule_option follower_id
+  all_follow_rule_options(follower_id).find do |option|
+    follow_rule_option_applies? follower_id, option
+  end
+end
+
+def all_follow_rule_options follower_id
+  follow_rule = preference :follow, follower_id
+  return [] unless follow_rule.present?
+
+  follow_rule.split("\n")
+end
+
+def follow_rule_option_applies? follower_id, option
+  option_code = option.to_name.code
+  candidate_ids = follower_candidate_ids_for_option option_code
+  follow_rule_option_applies_to_candidates? follower_id, option_code, candidate_ids
+end
+
+def follow_rule_option_applies_to_candidates? follower_id, option_code, candidate_ids
+  if (test = FollowOption.test[option_code])
+    test.call follower_id, candidate_ids
+  else
+    candidate_ids.include? follower_id
+  end
+end
+
+def follower_candidate_ids_for_option option_code
+  return [] unless (block = FollowOption.follower_candidate_ids[option_code])
+
+  block.call self
+end

data/set/all/follow/follower_ids.rb

@@ -0,0 +1,121 @@
+FOLLOWER_IDS_CACHE_KEY = "FOLLOWER_IDS".freeze
+
+card_accessor :followers
+
+event :cache_expired_for_type_change, :store, on: :update, changed: %i[type_id name] do
+  act_card&.schedule_preference_expiration
+  # FIXME: expire (also?) after save
+  Card.follow_caches_expired
+end
+
+def schedule_preference_expiration
+  @expire_preferences_scheduled = true
+end
+
+def expire_preferences?
+  @expire_preferences_scheduled
+end
+
+event :expire_preferences_cache, :finalize, when: :expire_preferences? do
+  Card::Rule.clear_preference_cache
+end
+
+# follow cache methods on Card class
+module ClassMethods
+  def follow_caches_expired
+    Card.clear_follower_ids_cache
+    Card::Rule.clear_preference_cache
+  end
+
+  def follower_ids_cache
+    Card.cache.read(FOLLOWER_IDS_CACHE_KEY) || {}
+  end
+
+  def write_follower_ids_cache hash
+    Card.cache.write FOLLOWER_IDS_CACHE_KEY, hash
+  end
+
+  def clear_follower_ids_cache
+    Card.cache.write FOLLOWER_IDS_CACHE_KEY, nil
+  end
+end
+
+def write_follower_ids_cache user_ids
+  hash = Card.follower_ids_cache
+  hash[id] = user_ids
+  Card.write_follower_ids_cache hash
+end
+
+def read_follower_ids_cache
+  Card.follower_ids_cache[id]
+end
+
+def follower_names
+  followers.map(&:name)
+end
+
+def followers
+  follower_ids.map do |id|
+    Card.fetch(id)
+  end
+end
+
+def follower_ids
+  @follower_ids = read_follower_ids_cache || begin
+    result = direct_follower_ids + indirect_follower_ids
+    write_follower_ids_cache result
+    result
+  end
+end
+
+def followers_count
+  follower_ids.size
+end
+
+def indirect_follower_ids
+  result = ::Set.new
+  left_card = left
+  while left_card
+    result += left_card.direct_follower_ids if left_card.followed_field? self
+    left_card = left_card.left
+  end
+  result
+end
+
+# all users (cards) that "directly" follow this card
+# "direct" means there is a follow rule that applies explicitly to this card.
+# one can also "indirectly" follow cards by  following parent cards or other
+# cards that nest this one.
+def direct_followers
+  direct_follower_ids.map do |id|
+    Card.fetch(id)
+  end
+end
+
+def direct_follower_ids &block
+  ids = ::Set.new
+  set_names.each do |set_name|
+    direct_follower_ids_for_set setcard_from_name(set_name), ids, &block
+  end
+  ids
+end
+
+def setcard_from_name set_name
+  Card.fetch set_name, new: { type_id: SetID }
+end
+
+def direct_follower_ids_for_set set_card, ids
+  set_card.all_user_ids_with_rule_for(:follow).each do |user_id|
+    next if ids.include?(user_id) || !(option = follow_rule_option user_id)
+
+    yield user_id, set_card, option if block_given?
+    ids << user_id
+  end
+end
+
+def each_direct_follower_id_with_reason
+  direct_follower_ids do |user_id, set_card, follow_option|
+    reason = follow_option.gsub(/[\[\]]/, "")
+    yield user_id, set_card: set_card, option: reason
+  end
+end

data/set/all/follow/start_follow_link.rb

@@ -0,0 +1,11 @@
+#! no set module
+
+class StartFollowLink < FollowLink
+  def initialize format
+    @rule_content = "*always"
+    @link_text = "follow"
+    @action = "send"
+    @css_class = ""
+    super
+  end
+end

data/set/all/follow/stop_follow_link.rb

@@ -0,0 +1,12 @@
+#! no set module
+
+class StopFollowLink < FollowLink
+  def initialize format
+    @rule_content = "*never"
+    @link_text = "following"
+    @hover_text = "unfollow"
+    @action = "stop sending"
+    @css_class = "btn-item-delete"
+    super
+  end
+end

data/set/all/notify.rb

@@ -0,0 +1,81 @@
+attr_accessor :follower_stash
+mattr_accessor :force_notifications
+
+event :silence_notifications, :initialize, when: :silence_notifications? do
+  @silent_change = true
+end
+
+def silence_notifications?
+  !(Card::Env[:controller] || force_notifications)
+end
+
+event :notify_followers_after_save,
+      :integrate_with_delay, on: :save, when: :notable_change? do
+  notify_followers
+end
+
+# in the delete case we have to calculate the follower_stash beforehand
+# but we can't pass the follower_stash through the ActiveJob queue.
+# We have to deal with the notifications in the integrate phase instead of the
+# integrate_with_delay phase
+event :stash_followers, :store, on: :delete, when: :notable_change? do
+  act_card.follower_stash ||= FollowerStash.new
+  act_card.follower_stash.check_card self
+end
+
+event :notify_followers_after_delete, :integrate, on: :delete, when: :notable_change? do
+  notify_followers
+end
+
+def notify_followers
+  return unless (act = Card::Director.act)
+
+  act.reload
+  notify_followers_of act
+end
+
+def notable_change?
+  !silent_change? && current_act_card? &&
+    (Card::Auth.current_id != WagnBotID) && followable?
+end
+
+def silent_change?
+  silent_change
+end
+
+private
+
+def notify_followers_of act
+  act_followers(act).each_follower_with_reason do |follower, reason|
+    next if !follower.account || (follower == act.actor)
+
+    notify_follower follower, act, reason
+  end
+end
+
+def notify_follower follower, act, reason
+  follower.account.send_change_notice act, reason[:set_card].name, reason[:option]
+end
+
+def act_followers act
+  @follower_stash ||= FollowerStash.new
+  act.actions(false).each do |a|
+    next if !a.card || a.card.silent_change?
+
+    @follower_stash.check_card a.card
+  end
+  @follower_stash
+end
+
+def silent_change
+  @silent_change || @supercard&.silent_change
+end
+
+def current_act_card?
+  return false unless act_card
+
+  act_card.id.nil? || act_card.id == id
+  # FIXME: currently card_id is nil for deleted acts (at least
+  # in the store phase when it's tested).  The nil test was needed
+  # to make this work.
+end

data/set/all/notify/base_views.rb

@@ -0,0 +1,127 @@
+format do
+  view :list_of_changes, denial: :blank, cache: :never do
+    action = notification_action voo.action_id
+    relevant_fields(action).map do |type|
+      edit_info_for(type, action)
+    end.compact.join
+  end
+
+  view :subedits, perms: :none, cache: :never do
+    return unless notification_act
+
+    wrap_subedits do
+      notification_act.actions_affecting(card).map do |action|
+        next if action.card_id == card.id
+
+        action.card.format(format: @format).render_subedit_notice action_id: action.id
+      end
+    end
+  end
+
+  view :subedit_notice, cache: :never do
+    action = notification_action voo.action_id
+    wrap_subedit_item do
+      %(#{name_before_action action} #{action.action_type}d\n) +
+        render_list_of_changes(action_id: action.id)
+    end
+  end
+
+  view :followed, perms: :none, compact: true do
+    if (set_card = followed_set_card) && (option_card = follow_option_card)
+      option_card.description set_card
+    else
+      "*followed set of cards*"
+    end
+  end
+
+  view :follower, perms: :none, compact: true do
+    active_notice(:follower) || "follower"
+  end
+
+  view :last_action_verb, cache: :never do
+    "#{notification_act&.main_action&.action_type || 'edite'}d"
+  end
+
+  view :unfollow_url, perms: :none, compact: true, cache: :never do
+    return "" unless (rule_name = live_follow_rule_name)
+
+    card_url path(mark: "#{active_notice(:follower)}+#{:follow.cardname}",
+                  action: :update,
+                  card: { subcards: { rule_name => Card[:never].name } })
+  end
+
+  def relevant_fields action
+    case action.action_type
+    when :create then %i[cardtype content]
+    when :update then %i[name cardtype content]
+    when :delete then %i[content]
+    end
+  end
+
+  def name_before_action action
+    (action.value(:name) && action.previous_value(:name)) || card.name
+  end
+
+  def followed_set_card
+    (set_name = active_notice(:followed_set)) && Card.fetch(set_name)
+  end
+
+  def follow_option_card
+    return unless (option_name = active_notice(:follow_option))
+
+    Card.fetch option_name
+  end
+
+  def active_notice key
+    @active_notice ||= inherit :active_notice
+    return unless @active_notice
+
+    @active_notice[key]
+  end
+
+  def live_follow_rule_name
+    return unless (set_card = followed_set_card) && (follower = active_notice(:follower))
+
+    set_card.follow_rule_name follower
+  end
+
+  def edit_info_for field, action
+    return nil unless (value = action.value field)
+    value = action.previous_value if action.action_type == :delete
+    wrap_list_item "  #{notification_action_label action} #{field}: #{value}"
+  end
+
+  def notification_action_label action
+    case action.action_type
+    when :update then "new"
+    when :delete then "deleted"
+    end
+  end
+
+  def wrap_subedits
+    subedits = yield.compact.join
+    return "" if subedits.blank?
+
+    "\nThis update included the following changes:\n#{wrap_list subedits}"
+  end
+
+  def wrap_list list
+    "\n#{list}\n"
+  end
+
+  def wrap_list_item item
+    "#{item}\n"
+  end
+
+  def wrap_subedit_item
+    "\n#{yield}\n"
+  end
+
+  def notification_act act=nil
+    @notification_act ||= act || card.acts.last
+  end
+
+  def notification_action action_id
+    action_id ? Action.fetch(action_id) : card.last_action
+  end
+end

data/set/all/notify/html_views.rb

@@ -0,0 +1,17 @@
+format :html do
+  # view :last_action, perms: :none, cache: :never do
+  #   _render_last_action_verb
+  # end
+
+  def wrap_list list
+    "<ul>#{list}</ul>\n"
+  end
+
+  def wrap_list_item item
+    "<li>#{item}</li>\n"
+  end
+
+  def wrap_subedit_item
+    "<li>#{yield}</li>\n"
+  end
+end

data/set/right/account.rb

@@ -0,0 +1,15 @@
+def send_change_notice act, followed_set, follow_option
+  return unless email.present? && changes_visible?(act)
+
+  notify_of_act act do
+    { follower: left.name, followed_set: followed_set, follow_option: follow_option }
+  end
+end
+
+def notify_of_act act
+  Auth.as(left.id) do
+    Card[:follower_notification_email].deliver(
+      act.card, { to: email }, auth: left, active_notice: yield
+    )
+  end
+end