card 1.18.6 → 1.19.0

data/mod/05_email/set/all/notify.rb

@@ -1,255 +0,0 @@
-
-class FollowerStash
-  def initialize card=nil
-    @followed_affected_cards = Hash.new { |h, v| h[v] = [] }
-    @visited = ::Set.new
-    add_affected_card(card) if card
-  end
-
-  def add_affected_card card
-    return if @visited.include? card.key
-    Auth.as_bot do
-      @visited.add card.key
-      notify_direct_followers card
-      return if !(left_card = card.left) || @visited.include?(left_card.key) ||
-                !(follow_field_rule = left_card.rule_card(:follow_fields))
-      follow_field_rule.item_names(context: left_card.cardname).each do |item|
-        if @visited.include? item.to_name.key
-          add_affected_card left_card
-          break
-        elsif item.to_name.key == Card[:includes].key
-          includee_set = Card.search(
-            { included_by: left_card.name },
-            "follow cards included by #{left_card.name}"
-          ).map(&:key)
-          unless @visited.intersection(includee_set).empty?
-            add_affected_card left_card
-            break
-          end
-        end
-      end
-    end
-  end
-
-  def followers
-    @followed_affected_cards.keys
-  end
-
-  def each_follower_with_reason
-    # "follower"(=user) is a card object, "followed"(=reasons) a card name
-    @followed_affected_cards.each do |user, reasons|
-      yield(user, reasons.first)
-    end
-  end
-
-  private
-
-  def notify_direct_followers card
-    card.all_direct_follower_ids_with_reason do |user_id, reason|
-      notify Card.fetch(user_id), of: reason
-    end
-  end
-
-  def notify follower, because
-    @followed_affected_cards[follower] << because[:of]
-  end
-end
-
-def act_card
-  @supercard || self
-end
-
-def followable?
-  true
-end
-
-def silent_change?
-  silent_change.nil? ? !Card::Env[:controller] : silent_change
-end
-
-def notable_change?
-  !silent_change? && !supercard && current_act &&
-    Card::Auth.current_id != WagnBotID && followable?
-end
-
-event :notify_followers_after_save, :integrate,
-      on: :save, when: proc { |ca| ca.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 do
-  act_card.follower_stash ||= FollowerStash.new
-  act_card.follower_stash.add_affected_card self
-end
-event :notify_followers_after_delete, :integrate,
-      on: :delete, when: proc { |ca| ca.notable_change? } do
-  notify_followers
-end
-
-def notify_followers
-  @current_act.reload
-  @follower_stash ||= FollowerStash.new
-  @current_act.actions.each do |a|
-    @follower_stash.add_affected_card a.card if a.card
-  end
-  @follower_stash.each_follower_with_reason do |follower, reason|
-    if follower.account && follower != @current_act.actor
-      follower.account.send_change_notice @current_act, reason[:set_card].name,
-                                          reason[:option]
-    end
-  end
-# this error handling should apply to all extend callback exceptions
-rescue => e
-  Rails.logger.info "\nController exception: #{e.message}"
-  Card::Error.current = e
-  notable_exception_raised
-end
-
-format do
-  view :list_of_changes, denial: :blank do |args|
-    action = get_action(args)
-
-    relevant_fields =
-      case action.action_type
-      when :create then [:cardtype, :content]
-      when :update then [:name, :cardtype, :content]
-      when :delete then [:content]
-      end
-
-    relevant_fields.map do |type|
-      edit_info_for(type, action)
-    end.compact.join
-  end
-
-  view :subedits, perms: :none do |args|
-    subedits =
-      get_act(args).relevant_actions_for(card).map do |action|
-        if action.card_id != card.id
-          action.card.format(format: @format)
-                .render_subedit_notice(action: action)
-        end
-      end.compact.join
-
-    if subedits.present?
-      wrap_subedits subedits
-    else
-      ''
-    end
-  end
-
-  view :subedit_notice, denial: :blank do |args|
-    action = get_action(args)
-    name_before_action =
-      (action.value(:name) && action.previous_value(:name)) || card.name
-
-    wrap_subedit_item %(#{name_before_action} #{action.action_type}d
-#{render_list_of_changes(args)})
-  end
-
-  view :followed, perms: :none, closed: true do |args|
-    if args[:followed_set] &&
-       (set_card = Card.fetch(args[:followed_set])) &&
-       args[:follow_option] &&
-       (option_card = Card.fetch(args[:follow_option]))
-      option_card.description set_card
-    else
-      'followed card'
-    end
-  end
-
-  view :follower, perms: :none, closed: true do |args|
-    args[:follower] || 'follower'
-  end
-
-  view :unfollow_url, perms: :none, closed: true do |args|
-    if args[:followed_set] && (set_card = Card.fetch(args[:followed_set])) &&
-       args[:follow_option] && args[:follower]
-      rule_name = set_card.follow_rule_name args[:follower]
-      target_name = "#{args[:follower]}+#{Card[:follow].name}"
-      update_path = page_path target_name,
-                              action: :update,
-                              card: { subcards: {
-                                rule_name => Card[:never].name
-                              } }
-      card_url update_path # absolutize path
-    end
-  end
-
-  def edit_info_for field, action
-    return nil unless action.value field
-
-    item_title =
-      case action.action_type
-      when :update then 'new '
-      when :delete then 'deleted '
-      else ''
-      end
-    item_title += "#{field}: "
-
-    item_value =
-      if action.action_type == :delete
-        action.previous_value field
-      else
-        action.value field
-      end
-
-    wrap_list_item "#{item_title}#{item_value}"
-  end
-
-  def get_act args
-    @notification_act ||= args[:act] ||
-                          (args[:act_id] && Act.find(args[:act_id])) ||
-                          card.acts.last
-  end
-
-  def get_action args
-    args[:action] || (args[:action_id] && Action.fetch(args[:action_id])) ||
-      card.last_action
-  end
-
-  def wrap_subedits subedits
-    "\nThis update included the following changes:#{wrap_list subedits}"
-  end
-
-  def wrap_list list
-    "\n#{list}\n"
-  end
-
-  def wrap_list_item item
-    "   #{item}\n"
-  end
-
-  def wrap_subedit_item text
-    "\n#{text}\n"
-  end
-end
-
-format :email_text do
-  view :last_action, perms: :none do |args|
-    act = get_act(args)
-    "#{act.main_action.action_type}d"
-  end
-end
-
-format :email_html do
-  view :last_action, perms: :none do |args|
-    act = get_act(args)
-    "#{act.main_action.action_type}d"
-  end
-
-  def wrap_list list
-    "<ul>#{list}</ul>\n"
-  end
-
-  def wrap_list_item item
-    "<li>#{item}</li>\n"
-  end
-
-  def wrap_subedit_item text
-    "<li>#{text}</li>\n"
-  end
-end

data/mod/05_email/set/right/bcc.rb

@@ -1,40 +0,0 @@
-
-def process_email_addresses context_card, format_args, args
-  format(format_args).render_email_addresses(args.merge(context: context_card))
-end
-
-format do
-  def chunk_list  # turn off autodetection of uri's
-    :references
-  end
-end
-
-format :html do
-  view :pointer_items do |args|
-    card.item_names(context: :raw).map do |iname|
-      wrap_item iname, args
-    end.join ', '
-  end
-end
-
-format :email_text do
-  view :email_addresses do |args|
-    context = args[:context] || self
-    card.item_names(context: context.cardname).map do |item_name|
-      # note that context is processed twice here because pointers absolutize item_names by default
-      # while other types can return relative names.  That's poor default behavior and should be fixed!
-      item_name = item_name.to_name.to_absolute(context).to_s
-      if item_name =~ /.+\@.+\..+/
-        item_name
-      elsif item_card = Card.fetch(item_name)
-        if item_card.account
-          item_card.account.email
-        else
-          item_card.contextual_content(context, format: :email_text).split(/[,\n]/)
-        end
-      end
-    end.flatten.compact.join(', ')
-  end
-end
-
-# _user, info@mail.com, Ethan, Pointer -> ..., _left+email, my email address -> info@mail.com

data/mod/05_email/set/right/follow.rb

@@ -1,99 +0,0 @@
-include All::Permissions::Follow
-
-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
-
-format :html do
-  def default_follow_item_args args
-    args[:condition] ||= Env.params[:condition] || '*always'
-  end
-
-  view :follow_item, tags: :unknown_ok do |args|
-    if card.new_card? || !card.include_item?(args[:condition])
-      button_view = :add_follow_rule_button
-      form_opts = { add_item: args[:condition] }
-    else
-      button_view = :delete_follow_rule_button
-      form_opts = { drop_item: args[:condition] }
-    end
-
-    text = if (option_card = Card.fetch args[:condition])
-             option_card.description(card.rule_set)
-           else
-             card.rule_set.follow_label
-           end
-    link_target = if card.rule_set.tag.codename == 'self'
-                    card.rule_set_name.left
-                  else
-                    "#{card.rule_set_name}+by name"
-                  end
-    wrap do
-      card_form(
-        { action: :update, name: card.name, success: { view: :follow_item } },
-        hidden: { condition: args[:condition] }.merge(form_opts)
-      ) do
-        output [
-          _optional_render(button_view, args),
-          card_link(link_target, text: text)
-        ]
-      end
-    end
-  end
-
-  def default_follow_status_args args
-    args[:card_key] ||= card.set_prototype.key
-  end
-
-  view :follow_status do |args|
-    delete_options =
-      wrap_with(:ul, class: 'delete-list list-group') do
-        card.item_names.map do |option|
-          content_tag :li, class: 'list-group-item' do
-            condition = option == '*never' ? '*always' : option
-            subformat(card).render_follow_item condition: condition
-          end
-        end.join "\n"
-      end
-
-    follow_link =
-      card_link args[:card_key],
-                text: 'more options',
-                path_opts: {
-                  view: :related,
-                  related: { name: card.name, view: :edit_single_rule }
-                },
-                class: 'btn update-follow-link',
-                'data-card_key' => args[:card_key]
-
-    header = '<h4>Get notified about changes</h4>'
-
-    [header, delete_options, follow_link].join "\n\n"
-  end
-
-  view :delete_follow_rule_button do |_args|
-    button_tag(
-      type: :submit,
-      class: 'btn-xs btn-item-delete btn-primary', 'aria-label' => 'Left Align'
-    ) do
-      tag :span, class: 'glyphicon glyphicon-ok', 'aria-hidden' => 'true'
-    end
-  end
-
-  view :add_follow_rule_button do |_args|
-    button_tag(
-      type: :submit,
-      class: 'btn-xs btn-item-add', 'aria-label' => 'Left Align'
-    ) do
-      tag :span, class: 'glyphicon glyphicon-plus', 'aria-hidden' => 'true'
-    end
-  end
-end

data/mod/05_email/set/right/followers.rb

@@ -1,34 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-include Card::Set::Type::Pointer
-
-def raw_content
-  if left
-    items =
-      if (left.type_id == SetID) || (left.type_id == CardtypeID)
-        set_card = left.default_follow_set_card
-        set_card.all_user_ids_with_rule_for(:follow).map do |user_id|
-          if left.followed_by?(user_id) && (user = Card.find(user_id))
-            user.name
-          end
-        end.compact
-      else
-        left.follower_names
-      end
-    items.map { |item| "[[#{item}]]" }.join "\n"
-  else
-    ''
-  end
-end
-
-def virtual?
-  !real?
-end
-
-format do
-  include Card::Set::Type::Pointer::Format
-end
-
-format :html do
-  include Card::Set::Type::Pointer::HtmlFormat
-end

data/mod/05_email/set/right/following.rb

@@ -1,58 +0,0 @@
-
-def virtual?
-  !real?
-end
-
-format :html do
-  view :core do |args|
-    if card.left && Auth.signed_in?
-      render_rule_editor args
-    else
-      fname = "#{card.cardname.left}+#{Card[:followers].name}"
-      fcard = Card.fetch fname
-      nest fcard, view: :titled, item: :link
-    end
-  end
-
-  view :status do |_args|
-    if (rcard = current_follow_rule_card)
-      rcard.item_cards.map do |item|
-        %(<div class="alert alert-success" role="alert">
-          <strong>#{rcard.rule_set.follow_label}</strong>: #{item.title}
-         </div>)
-      end.join
-    else
-      'No following preference'
-    end
-  end
-
-  view :closed_content do |_args|
-    ''
-  end
-
-  #    view :editor do |args|
-  #      hidden_field( :content, class: 'card-content', 'no-autosave'=>true) +
-  #         (args.delete(:select_list) ? raw(render_rule_editor(args)) : super(args) )
-  #    end
-
-  view :rule_editor do |_args|
-    preference_name = [
-      card.left.default_follow_set_card.name,
-      Auth.current.name,
-      Card[:follow].name
-    ].join('+')
-    rule_context = Card.fetch preference_name, new: { type_id: PointerID }
-
-    wrap_with :div, class: 'edit-rule' do
-      follow_context = current_follow_rule_card || rule_context
-      subformat(follow_context).render_edit_rule(
-        rule_context: rule_context,
-        success: { view: 'status', id: card.name }
-      )
-    end
-  end
-
-  def current_follow_rule_card
-    card.left.rule_card :follow, user: Auth.current
-  end
-end