card-mod-follow 0.11.0

data/set/right/follow.rb

@@ -0,0 +1,118 @@
+# The Right::Follow set configures follow preferences (`[Set]+[User]+:follow`)
+# While the user follow dashboard ([User]+:follow`) is also in this Set, its
+# 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
+
+format :html do
+  # 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

data/set/right/follow/follow_status.haml

@@ -0,0 +1,9 @@
+%h4
+  Get notified about changes
+%ul.delete-list.list-group
+  - card.item_names.each do |option|
+    %li.list-group-item
+      = follow_item(option == "*never" ? "*always" : option)
+= link_to_view :rule_form, "more options",
+               class: "btn update-follow-link slotter",
+               "data-card_key": card.set_prototype.key

data/set/right/follow_fields.rb

@@ -0,0 +1,3 @@
+event :follow_fields_changed, :integrate do
+  Card.follow_caches_expired
+end

data/set/right/followers.rb

@@ -0,0 +1,23 @@
+# -*- encoding : utf-8 -*-
+
+# X+*followers provides a list of all users following X.
+
+include_set Abstract::Pointer
+
+format :html do
+  view :core, cache: :never do
+    super()
+  end
+end
+
+def content
+  left ? item_names.to_pointer_content : ""
+end
+
+def item_names _args={}
+  left ? left.follow_set_card.prototype.follower_names : []
+end
+
+def virtual?
+  new?
+end

data/set/right/following.rb

@@ -0,0 +1,50 @@
+def virtual?
+  new?
+end
+
+format :html do
+  view :core do
+    if card.left && Auth.signed_in?
+      render_rule_editor
+    else
+      nest Card.fetch(card.name.left, :followers), view: :titled, items: { view: :link }
+    end
+  end
+
+  view :status do
+    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 :one_line_content do
+    ""
+  end
+
+  view :rule_editor, cache: :never do
+    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).rule_form :open, rule_context, :modal
+    end
+  end
+
+  def preference_name
+    set_name = card.left.follow_set_card.name
+    Card::Name[set_name, Auth.current.name, :follow]
+  end
+
+  def edit_rule_success
+    { view: "status", id: card.name.url_key }
+  end
+
+  def current_follow_rule_card
+    card.left.preference :follow
+  end
+end

data/set/self/always.rb

@@ -0,0 +1,13 @@
+include_set Abstract::FollowOption
+
+follow_opts position: 2
+
+follow_test { |_follower_id, _accounted_ids| true }
+
+def title
+  "Following"
+end
+
+def label
+  "follow"
+end

data/set/self/created.rb

@@ -0,0 +1,19 @@
+include_set Abstract::FollowOption
+
+restrictive_follow_opts position: 1
+
+follower_candidate_ids do |card|
+  [card.creator_id]
+end
+
+def title
+  "Following content you created"
+end
+
+def label
+  "follow if I created"
+end
+
+def description set_card
+  "#{set_card.follow_label} I created"
+end

data/set/self/edited.rb

@@ -0,0 +1,20 @@
+include_set Abstract::FollowOption
+
+restrictive_follow_opts position: 2
+
+follower_candidate_ids do |card|
+  # FIXME? - could optimize by not using cards table...
+  card.id ? Card.search(editor_of: card.id, return: :id) : []
+end
+
+def title
+  "Following content you edited"
+end
+
+def label
+  "follow if I edited"
+end
+
+def description set_card
+  "#{set_card.follow_label} I edited"
+end

data/set/self/follow.rb

@@ -0,0 +1 @@
+setting_opts group: :other, position: 7, rule_type_editable: false, preference: true

data/set/self/follow_defaults.rb

@@ -0,0 +1,88 @@
+# DEPRECATED
+#
+# Despite its name (*follow defaults)card does not influence defaults for *follow rules.
+# What it does is provide a mechanism (with interface) for updating all users so that
+# they follow the items that are its content.
+#
+# PLAN:
+# - actual defaults should be handled as much as possible with something like
+#   the *defaults rule
+# - on the *admin page, we can have a link so sharks can update all the pristine cards
+#   to use whatever the actual defaults representation is (see previous point)
+# - if you truly want to override existing follow rules, that may be monkey territory?
+# - we will delete "*follow defaults" after the above are completed
+
+event :update_follow_rules, :finalize, on: :save, when: :update_all_users do
+  Auth.as_bot do
+    Card.search(type: "user").each do |user|
+      follow_defaults.each do |set_card, option|
+        follow_rule = Card.fetch(set_card.follow_rule_name(user.name), new: {})
+        next unless follow_rule
+
+        follow_rule.drop_item "*never"
+        follow_rule.drop_item "*always"
+        follow_rule.add_item option
+        follow_rule.save!
+      end
+    end
+  end
+  Card.follow_caches_expired
+end
+
+def follow_defaults
+  item_names.map do |item|
+    if (set_card = Card.fetch item.to_name.left)&.type_code == :set
+      [set_card, follow_option(item)]
+    end
+  end.compact
+end
+
+def follow_option item
+  option_card =
+    Card.fetch(item.to_name.right) || Card[item.to_name.right.to_sym]
+  option_card.follow_option? ? option_card.name : "*always"
+end
+
+format :html do
+  view :edit, perms: :update, unknown: true do
+    frame_and_form :update, hidden: { success: "_self",
+                                      card: { update_all_users: false } } do
+      [
+        _render_content_formgroups,
+        _render_confirm_update_all,
+        _render_edit_buttons
+      ]
+    end
+  end
+
+  view :edit_buttons do
+    button_formgroup do
+      [submit_and_update_button, simple_submit_button, cancel_to_edit_button]
+    end
+  end
+
+  def submit_and_update_button
+    submit_button text: "Submit and update all users",
+                  disable_with: "Updating", class: "follow-updater"
+  end
+
+  def simple_submit_button
+    button_tag "Submit", class: "follow"
+  end
+
+  def cancel_to_edit_button
+    cancel_button href: path(view: :edit, id: card.id)
+  end
+
+  view :confirm_update_all do
+    wrap do
+      alert "info" do
+        %(
+          <h1>Are you sure you want to change the default follow rules?</h1>
+          <p>You may choose to update all existing users.
+             This may take a while. </p>
+        )
+      end
+    end
+  end
+end

data/set/self/follow_fields.rb

@@ -0,0 +1 @@
+setting_opts group: :other, position: 5, rule_type_editable: false

data/set/self/never.rb

@@ -0,0 +1,13 @@
+include_set Abstract::FollowOption
+
+follow_opts position: 3
+
+follow_test { |_follower_id, _accounted_ids| false }
+
+def title
+  "Ignoring"
+end
+
+def label
+  "ignore"
+end

data/set/type/cardtype.rb

@@ -0,0 +1,21 @@
+def follow_label
+  follow_set_card.follow_label
+end
+
+def followed_by? user_id=nil
+  follow_set_card.all_members_followed_by? user_id
+end
+
+def follow_set_card
+  Card.fetch name, :type
+end
+
+def list_direct_followers?
+  true
+end
+
+format :html do
+  def related_by_type_items
+    super.unshift ["#{card.name} cards", [card, :type, :by_name], mark: :absolute]
+  end
+end

data/set/type/notification_template.rb

@@ -0,0 +1,33 @@
+card_reader :contextual_class
+card_reader :disappear
+card_reader :message
+
+def deliver context
+  success.flash alert_message(context)
+end
+
+def alert_message context
+  mcard = message.present? ? message_card : self
+  format(:html).alert_message context, mcard
+end
+
+format :html do
+  def alert_message context, message_card
+    mformat = subformat message_card
+    alert card.alert_class, true, card.disappear? do
+      mformat.contextual_content context, view: alert_view(mformat)
+    end
+  end
+
+  def alert_view format
+    format.respond_to?(:notify) ? format.notify : :core
+  end
+end
+
+def disappear?
+  disappear.present? ? disappear_card.checked? : true
+end
+
+def alert_class
+  contextual_class.present? ? contextual_class_card.item_name : :success
+end

data/set/type/set.rb

@@ -0,0 +1,53 @@
+event :cache_expired_for_new_set, :store, on: :create do
+  Card.follow_caches_expired
+end
+
+def list_direct_followers?
+  true
+end
+
+def follow_label
+  if (klass = subclass_for_set)
+    klass.short_label name.left_name
+  else
+    ""
+  end
+end
+
+def follow_rule_name user=nil
+  Card::Name[[name, user, :follow].compact]
+end
+
+def followed_by? user_id=nil
+  all_members_followed_by? user_id
+end
+
+def follow_set_card
+  self
+end
+
+def all_members_followed?
+  all_members_followed_by? Auth.current_id
+end
+
+def all_members_followed_by? user_id=nil
+  return false unless prototype.followed_by?(user_id)
+
+  directly_followed_by?(user_id) || broader_set_followed_by?(user_id)
+end
+
+def broader_set_followed_by? user_id
+  broader_sets.find do |set_name|
+    Card.fetch(set_name)&.directly_followed_by? user_id
+  end
+end
+
+def directly_followed?
+  directly_followed_by? Auth.current_id
+end
+
+def directly_followed_by? user_id=nil
+  return true if user_id && follow_rule?(user_id)
+
+  follow_rule?
+end