card 1.97.0.1 → 1.98.0

data/tmpsets/set/mod017-follow/all/follow/follow_link.rb

@@ -0,0 +1,69 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Follow)
+#
+#! no set module
+module Follow;
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/follow/set/all/follow/follow_link.rb"; end
+class FollowLink
+  attr_reader :format, :rule_content, :link_text, :action, :css_class, :hover_text
+
+  delegate :link_to, to: :format
+
+  def initialize format
+    @format = format
+    @card = format.card
+  end
+
+  def modal_link icon=false
+    opts = link_opts.merge(
+      "data-path": link_opts[:path],
+      "data-toggle": "modal",
+      "data-target": "#modal-#{card.name.safe_key}",
+      class: css_classes("follow-link", link_opts[:class])
+    )
+    link_to render_link_text(icon), opts
+  end
+
+  def button
+    opts = link_opts(:follow_section).merge(
+      remote: true,
+      class: @format.css_classes("follow-link", link_opts[:class],
+                                 "slotter btn btn-sm btn-primary")
+    )
+    opts["data-update-foreign-slot"] = ".d0-card-body > .card-slot.RIGHT-Xfollower.content-view"
+    opts["data-hover-text"] = hover_text if hover_text
+    link_to render_link_text, opts
+  end
+
+  def link_opts success_view=:follow_status
+    { title: title,
+      path: path(success_view),
+      class: css_class }
+  end
+
+  def render_link_text icon=false
+    verb = %(<span class="follow-verb">#{link_text}</span>)
+    icon = icon ? icon_tag(:flag) : ""
+    [icon, verb].compact.join.html_safe
+  end
+
+  private
+
+  def mark
+    @card.follow_set_card.follow_rule_name Auth.current.name
+  end
+
+  def path view=:follow_status
+    @format.path mark: mark,
+                 action: :update,
+                 success: { id: @card.name, view: view },
+                 card: { content: "[[#{rule_content}]]" }
+  end
+
+  def title
+    "#{action} emails about changes to #{@card.follow_label}"
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/follow/set/all/follow/follow_link.rb ~~

data/tmpsets/set/mod017-follow/all/follow/follow_link_views.rb

@@ -0,0 +1,38 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Follow;
+# Set: All cards (Follow, FollowLinkViews)
+#
+module FollowLinkViews;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/follow/set/all/follow/follow_link_views.rb"; end
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  def follow_link_class
+    card.followed? ? StopFollowLink : StartFollowLink
+  end
+
+  def show_follow?
+    Auth.signed_in? && !card.new_card? && card.followable?
+  end
+end
+
+module JsonFormat; parent.send :register_set_format, Card::Format::JsonFormat, self; extend Card::Set::AbstractFormat
+  view :follow_status do
+    follow_link_class.link_opts
+  end
+end
+
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  def follow_button
+    follow_link_class.new(self).button
+  end
+
+  def follow_modal_link
+    follow_link_class.new(self).modal_link
+  end
+
+  view :follow_button, cache: :never do
+    follow_button
+  end
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/follow/set/all/follow/follow_link_views.rb ~~

data/tmpsets/set/mod017-follow/all/follow/followed_by.rb

@@ -0,0 +1,80 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Follow;
+# Set: All cards (Follow, FollowedBy)
+#
+# used by +:followers overwritten in type/set.rb and type/cardtype.rb
+module FollowedBy;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/follow/set/all/follow/followed_by.rb"; end
+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 :includes.cardname.key then nested_card?(field_card)
+    end
+  end
+end
+
+def nested_card? card
+  @nested_ids ||= includee_ids
+  @nested_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 = rule :follow, user_id: 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
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/follow/set/all/follow/followed_by.rb ~~

data/tmpsets/set/mod017-follow/all/follow/follower_ids.rb

@@ -0,0 +1,118 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Follow;
+# Set: All cards (Follow, FollowerIds)
+#
+module FollowerIds;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/follow/set/all/follow/follower_ids.rb"; end
+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
+  # FIXME: expire (also?) after save
+  Card.follow_caches_expired
+end
+
+# follow cache methods on Card class
+module ClassMethods
+  def follow_caches_expired
+    Card.clear_follower_ids_cache
+    Card.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: Card::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
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/follow/set/all/follow/follower_ids.rb ~~

data/tmpsets/set/mod017-follow/all/follow/start_follow_link.rb

@@ -0,0 +1,19 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Follow)
+#
+#! no set module
+module Follow;
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/follow/set/all/follow/start_follow_link.rb"; end
+
+class StartFollowLink < FollowLink
+  def initialize format
+    @rule_content = "*always"
+    @link_text = "follow"
+    @action = "send"
+    @css_class = ""
+    super
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/follow/set/all/follow/start_follow_link.rb ~~

data/tmpsets/set/mod017-follow/all/follow/stop_follow_link.rb

@@ -0,0 +1,20 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Follow)
+#
+#! no set module
+module Follow;
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/follow/set/all/follow/stop_follow_link.rb"; end
+
+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
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/follow/set/all/follow/stop_follow_link.rb ~~

data/tmpsets/set/mod017-follow/all/notify.rb

@@ -0,0 +1,93 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Notify)
+#
+module Notify;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/follow/set/all/notify.rb"; end
+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 = ActManager.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 = ActManager.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
+
+def act_card
+  @supercard || self
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/follow/set/all/notify.rb ~~

data/tmpsets/set/mod017-follow/all/notify/base_views.rb

@@ -0,0 +1,139 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Notify;
+# Set: All cards (Notify, BaseViews)
+#
+module BaseViews;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/follow/set/all/notify/base_views.rb"; end
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  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, closed: 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, closed: true do
+    active_notice(:follower) || "follower"
+  end
+
+  view :last_action_verb, cache: :never do
+    return unless notification_act
+
+    "#{notification_act.main_action.action_type}d"
+  end
+
+  view :unfollow_url, perms: :none, closed: true, cache: :never do
+    return "" unless (rule_name = live_follow_rule_name)
+
+    card_url path(mark: "#{active_notice(:follower)}+#{Card[:follow].name}",
+                  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
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/follow/set/all/notify/base_views.rb ~~