card 1.99.4 → 1.99.5

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

@@ -1,118 +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
-  # 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

@@ -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/mod017-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/mod017-follow/all/notify.rb

@@ -1,93 +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
-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

@@ -1,139 +0,0 @@
-# -*- 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 ~~

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

@@ -1,26 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All; module Notify;
-# Set: All cards (Notify, HtmlViews)
-#
-module HtmlViews;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/follow/set/all/notify/html_views.rb"; end
-module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
-  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
-end;end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/follow/set/all/notify/html_views.rb ~~

data/tmpsets/set/mod017-follow/right/account.rb

@@ -1,22 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Right
-# Set: All "+Account" cards
-#
-module Account;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/follow/set/right/account.rb"; end
-def send_change_notice act, followed_set, follow_option
-  return unless changes_visible?(act)
-
-  Auth.as(left.id) do
-    Card[:follower_notification_email].deliver(
-      act.card, { to: email },
-      auth: left,
-      active_notice: { follower: left.name,
-                       followed_set: followed_set,
-                       follow_option: follow_option }
-    )
-  end
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/follow/set/right/account.rb ~~

data/tmpsets/set/mod017-follow/right/follow.rb

@@ -1,127 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Right
-# Set: All "+Follow" cards
-#
-# The Right::Follow set configures follow preferences (`[Set]+[User]+:follow`)
-# While the user follow dashboard ([User]+:follow`) is also in this Set, its
-module Follow;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/follow/set/right/follow.rb"; end
-# customizations are handled in TypePlusRight::User::Follow
-
-event :cache_expired_for_new_preference, :integrate, when: :is_preference? do
-  Card.follow_caches_expired
-end
-
-def option_cards
-  Card::FollowOption.cards.compact
-end
-
-def options_rule_card
-  Card.new(
-    name: "follow_options_card",
-    type_code: :pointer,
-    content: option_cards.map { |oc| "[[#{oc.name}]]" }.join("\n")
-  )
-end
-
-def add_follow_item? condition
-  new_card? || !include_item?(condition)
-end
-
-def ok_to_update
-  permit :update
-end
-
-def ok_to_create
-  permit :create
-end
-
-def ok_to_delete
-  permit :delete
-end
-
-def permit action, verb=nil
-  if %i[create delete update].include?(action) && allowed_to_change_follow_status?
-    true
-  else
-    super action, verb
-  end
-end
-
-def allowed_to_change_follow_status?
-  Auth.signed_in? &&
-    ((user = rule_user) && Auth.current_id == user.id) || Auth.always_ok?
-end
-
-module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
-  # shows a follow item link for each of the current follow options
-  view :follow_status, cache: :never do
-    wrap { haml :follow_status }
-  end
-
-  # interface to view/alter a specific rule option
-  view :follow_item, cache: :never do
-    follow_item Env.params[:condition]
-  end
-
-  def follow_item condition, button=true
-    condition ||= "*always"
-    wrap do
-      card_form action: :update, success: { view: :follow_item } do
-        [
-          follow_item_hidden_tags(condition),
-          (follow_item_button(condition) if button),
-          follow_item_link(condition)
-        ].compact
-      end
-    end
-  end
-
-  def rule_form_args
-    super.merge "data-update-foreign-slot": ".card-slot.follow_section-view"
-  end
-
-  private
-
-  def follow_item_hidden_tags condition
-    condkey = card.add_follow_item?(condition) ? :add_item : :drop_item
-    hidden_tags condition: condition, condkey => condition
-  end
-
-  def follow_item_button condition
-    action = card.add_follow_item?(condition) ? :add : :delete
-    button_tag type: :submit, "aria-label": "Left Align",
-               class: "btn-sm btn-item #{follow_item_button_class action}" do
-      follow_item_icon action
-    end
-  end
-
-  def follow_item_button_class action
-    action == :add ? "btn-item-add" : "btn-item-delete btn-primary"
-  end
-
-  def follow_item_icon action
-    icon_tag(action == :add ? :add : :check)
-  end
-
-  def follow_item_link condition
-    link_to_card follow_item_link_target, follow_item_link_text(condition)
-  end
-
-  def follow_item_link_target
-    set = card.rule_set
-    setname = set.name
-    set.tag.codename == :self ? setname.left : setname.field("by name")
-  end
-
-  def follow_item_link_text condition
-    if (option_card = Card.fetch condition)
-      option_card.description card.rule_set
-    else
-      card.rule_set.follow_label
-    end
-  end
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/follow/set/right/follow.rb ~~