card-mod-follow 0.11.0

data/set/type/user.rb

@@ -0,0 +1,7 @@
+def follow follow_name, option="*always"
+  return unless (follow_rule = Card.fetch(follow_name)&.follow_rule_card(name, new: {}))
+
+  follow_rule.drop_item "*never"
+  follow_rule.add_item option
+  follow_rule.save!
+end

data/set/type_plus_right/user/follow.rb

@@ -0,0 +1,77 @@
+FOLLOW_TABS = { "Follow" => "follow_tab", "Ignore" => "ignore_tab" }.freeze
+
+# a virtual pointer to the sets that a user is following.
+# (data is stored in preferences: `[Set]+[User]+:follow`)
+
+include_set Abstract::Pointer
+def virtual?
+  new?
+end
+
+# overrides pointer default
+def item_names _args={}
+  if (user = left)
+    Card::Rule.preference_names user.name, "follow"
+  else
+    []
+  end
+end
+
+def suggestions
+  Card[:follow_suggestions]&.item_names || []
+end
+
+def current_user?
+  Auth.signed_in? && Auth.current_id == left.id
+end
+
+format :html do
+  view :one_line_content do
+    ""
+  end
+
+  view :edit do
+    render :open
+  end
+
+  # renders follow tab and ignore tab
+  view :core do
+    tabs FOLLOW_TABS, "follow_tab", load: :lazy do
+      render_follow_tab
+    end
+  end
+
+  view :follow_tab, cache: :never do
+    haml :follow_editor, items_method: :following_rules_and_options
+  end
+
+  view :ignore_tab, cache: :never do
+    haml :follow_editor, items_method: :ignoring_rules_and_options
+  end
+
+  def show_button?
+    card.current_user? || Auth.always_ok?
+  end
+
+  def pointer_items args
+    voo.items[:view] ||= :link
+    super(args)
+  end
+
+  # TODO: research and generalize
+  # this does not look specific to following!
+  view :errors, perms: :none do
+    return unless card.errors.any?
+
+    if card.errors.find { |attrib, _msg| attrib == :permission_denied }
+      Env.save_interrupted_action(request.env["REQUEST_URI"])
+      voo.title = "Problems with #{card.name}"
+      class_up "d0-card-frame", "card card-warning card-inverse"
+      frame do
+        "Please #{link_to_card :signin, 'sign in'}" # " #{to_task}"
+      end
+    else
+      super()
+    end
+  end
+end

data/set/type_plus_right/user/follow/follow_editor.haml

@@ -0,0 +1,8 @@
+.pointer-list-editor
+  %ul.delete-list.list-group
+    - send items_method do |rule_card, option|
+      %li.list-group-item
+        -if rule_card
+          = subformat(rule_card).follow_item option, show_button?
+        -else
+          no entries

data/set/type_plus_right/user/follow/follow_editor_helper.rb

@@ -0,0 +1,121 @@
+# all the following methods are used to construct the Follow and Ignore tabs
+
+# TODO: these object representations are complex enough for their own class
+
+format :html do
+  # constructs hash of rules/options for "Follow" tab
+  def following_rules_and_options &block
+    rule_opt_array = following_rule_options_hash.map do |key, val|
+      [(Card.fetch key, new: {}), val]
+    end
+    rules_and_options_by_set_pattern Hash[rule_opt_array], &block
+  end
+
+  # constructs hash of rules/options for "Ignore" tab
+  def ignoring_rules_and_options &block
+    rule_opts_hash = ignore_rules.each_with_object({}) do |rule, hash|
+      hash[rule] = [:never.cardname]
+    end
+    rules_and_options_by_set_pattern rule_opts_hash, &block
+  end
+
+  private
+
+  # all rules with ignore
+  def ignore_rules
+    never = :never.cardname.key
+    card.item_cards.select do |follow_rule|
+      follow_rule.item_names.select { |n| n.key == never }.any?
+    end
+  end
+
+  # @param rule_opts_hash [Hash] { rule1_card => rule1_follow_options }
+  # for each rule/option variant, yields with rule_card and option params
+  def rules_and_options_by_set_pattern rule_opts_hash
+    pattern_hash = a_set_pattern_hash rule_opts_hash
+    empty = true
+    Card.set_patterns.reverse.map do |pattern|
+      pattern_hash[pattern].each do |rule_card, options|
+        options.each do |option|
+          yield rule_card, option
+          empty = false
+        end
+      end
+    end
+    yield nil if empty
+  end
+
+  def a_set_pattern_hash rule_opts_hash
+    pattern_hash = Hash.new { |h, k| h[k] = [] }
+    rule_opts_hash.each do |rule_card, options|
+      pattern_hash[rule_card.rule_set.subclass_for_set] << [rule_card, options]
+    end
+    pattern_hash
+  end
+
+  # @return Hash # { rule1 => rule1_follow_options }
+  def following_rule_options_hash
+    merge_option_hashes current_following_rule_options_hash,
+                        suggested_following_rule_options_hash
+  end
+
+  # adds suggested follow options to existing rules where applicable
+  def merge_option_hashes current, suggested
+    current.each do |key, current_opt|
+      if (suggested_opt = suggested.delete(key))
+        current[key] = (current_opt + suggested_opt).uniq
+      end
+    end
+    current.merge suggested
+  end
+
+  # @return Hash # { existing_rule1 => rule1_follow_options } (excluding never)
+  # (*never is excluded because this list is for the Follow tab, and *never is
+  # handled under the Ignore tab)
+  def current_following_rule_options_hash
+    never = :never.cardname
+    card.item_cards.each_with_object({}) do |follow_rule, hash|
+      hash[follow_rule.key] = follow_rule.item_names.reject { |item| item == never }
+    end
+  end
+
+  # @return Hash # { suggested_rule1 => rule1_follow_options }
+  def suggested_following_rule_options_hash
+    return {} unless card.current_user?
+
+    card.suggestions.each_with_object({}) do |sug, hash|
+      set_card, opt = a_set_and_option_suggestion(sug) || a_set_only_suggestion(sug)
+      hash[set_card.follow_rule_name(card.trunk).key] = [opt]
+    end
+  end
+
+  # @param sug [String] follow suggestion
+  # @return [Array] set_card and option
+  # suggestion value contains both set and follow option
+  def a_set_and_option_suggestion sug
+    return unless (set_card = valid_set_card(sug.to_name.left))
+
+    [set_card, suggested_follow_option(sug.to_name.right)]
+  end
+
+  def suggested_follow_option name
+    # FIXME: option should be unambiguously name or codename
+    # (if codename use colon or Symbol)
+    option_card = Card.fetch(name) || Card[name.to_sym]
+    option_card&.follow_option? ? option_card.name : :always.cardname
+  end
+
+  # @param sug [String] follow suggestion
+  # @return [Array] set_card and option
+  # suggestion value contains only set (implies *always)
+  def a_set_only_suggestion sug
+    return unless (set_card = valid_set_card(sug))
+
+    yield set_card, :always.cardname
+  end
+
+  def valid_set_card name
+    card = Card.fetch(name)
+    card&.type_code == :set ? card : false
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: card-mod-follow
+version: !ruby/object:Gem::Version
+  version: 0.11.0
+platform: ruby
+authors:
+- Ethan McCutchen
+- Philipp Kühl
+- Gerry Gleason
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-12-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: card
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.101.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.101.0
+- !ruby/object:Gem::Dependency
+  name: card-mod-carrierwave
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+description: ''
+email:
+- info@decko.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/card/follow_option.rb
+- lib/card/follower_stash.rb
+- set/abstract/follow_option.rb
+- set/all/follow.rb
+- set/all/follow/follow_link.rb
+- set/all/follow/follow_link_views.rb
+- set/all/follow/followed_by.rb
+- set/all/follow/follower_ids.rb
+- set/all/follow/start_follow_link.rb
+- set/all/follow/stop_follow_link.rb
+- set/all/notify.rb
+- set/all/notify/base_views.rb
+- set/all/notify/html_views.rb
+- set/right/account.rb
+- set/right/follow.rb
+- set/right/follow/follow_status.haml
+- set/right/follow_fields.rb
+- set/right/followers.rb
+- set/right/following.rb
+- set/self/always.rb
+- set/self/created.rb
+- set/self/edited.rb
+- set/self/follow.rb
+- set/self/follow_defaults.rb
+- set/self/follow_fields.rb
+- set/self/never.rb
+- set/type/cardtype.rb
+- set/type/notification_template.rb
+- set/type/set.rb
+- set/type/user.rb
+- set/type_plus_right/user/follow.rb
+- set/type_plus_right/user/follow/follow_editor.haml
+- set/type_plus_right/user/follow/follow_editor_helper.rb
+homepage: http://decko.org
+licenses:
+- GPL-3.0
+metadata:
+  card-mod: follow
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key:
+specification_version: 4
+summary: follower notifications
+test_files: []