card 1.101.7 → 1.103.2

data/tmpsets/set/mod026-card-mod-follow/all/follow.rb

@@ -1,42 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Follow)
-#
-# for override
-module Follow;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card-mod-follow/set/all/follow.rb"; end
-def followable?
-  true
-end
-
-def follow_label
-  name
-end
-
-def list_direct_followers?
-  false
-end
-
-def follow_option?
-  codename && FollowOption.codenames.include?(codename)
-end
-
-# the set card to be followed if you want to follow changes of card
-def follow_set_card
-  Card.fetch name, :self
-end
-
-def follow_rule_name user=nil
-  follow_set_card&.follow_rule_name user
-end
-
-def follow_rule_card user=nil, args={}
-  Card.fetch follow_rule_name(user), args
-end
-
-def follow_rule? user=nil
-  Card.exists? follow_rule_name(user)
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card-mod-follow/set/all/follow.rb ~~

data/tmpsets/set/mod026-card-mod-follow/all/follow/follow_link.rb

@@ -1,70 +0,0 @@
-# -*- 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: { mark: @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/mod026-card-mod-follow/all/follow/follow_link_views.rb

@@ -1,38 +0,0 @@
-# -*- 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; module_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; module_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; module_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/mod026-card-mod-follow/all/follow/followed_by.rb

@@ -1,79 +0,0 @@
-# -*- 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 :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
-end;end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card-mod-follow/set/all/follow/followed_by.rb ~~

data/tmpsets/set/mod026-card-mod-follow/all/follow/follower_ids.rb

@@ -1,130 +0,0 @@
-# -*- 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
-  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
-end;end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card-mod-follow/set/all/follow/follower_ids.rb ~~

data/tmpsets/set/mod026-card-mod-follow/all/follow/start_follow_link.rb

@@ -1,19 +0,0 @@
-# -*- 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/mod026-card-mod-follow/all/follow/stop_follow_link.rb

@@ -1,20 +0,0 @@
-# -*- 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/mod026-card-mod-follow/all/notify.rb

@@ -1,91 +0,0 @@
-# -*- 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
-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
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card-mod-follow/set/all/notify.rb ~~