card 1.18.6 → 1.19.0

data/tmpsets/set/mod005-04_settings/type/setting.rb

@@ -1,100 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; module Type; module Setting; extend Card::Set
-# ~~~~~~~~~~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/04_settings/set/type/setting.rb ~~~~~~~~~~~
-require_dependency 'json'
-
-def self.member_names
-  @@member_names ||= begin
-    Card.search(
-      { type_id: SettingID, return: 'key' },
-      'all setting cards'
-    ).inject({}) do |hash, card_key|
-      hash[card_key] = true
-      hash
-    end
-  end
-end
-
-view :core do |args|
-
-  klasses = Card.set_patterns.reverse.map do |set_class|
-    wql = { left:  { type: Card::SetID },
-            right: card.id,
-            #sort:  'content',
-
-            sort:  ['content', 'name'],
-            limit: 0
-          }
-    wql[:left][ (set_class.anchorless? ? :id : :right_id )] = set_class.pattern_id
-
-    rules = Card.search wql
-    [ set_class, rules ] unless rules.empty?
-  end.compact
-
-
-
-  %{
-    #{ _render_rule_help args }
-    <table class="setting-rules">
-      <tr><th>Set</th><th>Rule</th></tr>
-      #{
-        klasses.map do |klass, rules|
-          %{
-            <tr class="klass-row anchorless-#{ klass.anchorless? }">
-              <td class="setting-klass">#{ klass.anchorless? ? card_link( klass.pattern ) : klass.pattern }</td>
-              <td class="rule-content-container">
-                <span class="closed-content content">#{ subformat(rules[0])._render_closed_content if klass.anchorless? }</span>
-              </td>
-            </tr>
-            #{
-              unless klass.anchorless?
-                previous_content = nil
-                rules.map do |rule|
-                  current_content = rule.db_content.strip
-                  duplicate = previous_content == current_content
-                  changeover = previous_content && !duplicate
-                  previous_content = current_content
-                  %{
-                    <tr class="#{ 'rule-changeover' if changeover }">
-                    <td class="rule-anchor">#{ card_link rule.cardname.trunk_name, text: rule.cardname.trunk_name.trunk_name }</td>
-
-                      #{
-                        if duplicate
-                          %{ <td></td> }
-                        else
-                          %{
-                            <td class="rule-content-container">
-                              <span class="closed-content content">#{ subformat(rule)._render_closed_content }</span>
-                            </td>
-                          }
-                        end
-                      }
-                    </tr>
-                  }
-
-                end * "\n"
-              end
-
-            }
-          }
-        end * "\n"
-
-      }
-    </table>
-  }
-
-end
-
-view :rule_help do |args|
-  %{<div class="alert alert-info">#{process_content_object "{{+*right+*help|content}}"}</div>}
-end
-
-
-view :closed_content do |args|
-  render_rule_help
-end
-
-
-
-# ~~~~~~~~~~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/04_settings/set/type/setting.rb ~~~~~~~~~~~
-end;end;end;end;

data/tmpsets/set/mod006-05_email/all/email_html.rb

@@ -1,12 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; module All; module EmailHtml; extend Card::Set
-# ~~~~~~~~~~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/05_email/set/all/email_html.rb ~~~~~~~~~~~
-format :email_html do
-  view :missing        do |args| '' end
-  view :closed_missing do |args| '' end
-end
-
-
-
-# ~~~~~~~~~~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/05_email/set/all/email_html.rb ~~~~~~~~~~~
-end;end;end;end;

data/tmpsets/set/mod006-05_email/all/email_text.rb

@@ -1,12 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; module All; module EmailText; extend Card::Set
-# ~~~~~~~~~~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/05_email/set/all/email_text.rb ~~~~~~~~~~~
-
-format :email_text do    
-  view :missing        do |args| '' end
-  view :closed_missing do |args| '' end
-end
-
-
-# ~~~~~~~~~~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/05_email/set/all/email_text.rb ~~~~~~~~~~~
-end;end;end;end;

data/tmpsets/set/mod006-05_email/all/follow.rb

@@ -1,260 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; module All; module Follow; extend Card::Set
-# ~~~~~~~~~~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/05_email/set/all/follow.rb ~~~~~~~~~~~
-card_accessor :followers
-
-FOLLOWER_IDS_CACHE_KEY = 'FOLLOWER_IDS'
-
-# FIXME: this should be in type/set
-event :cache_expired_for_new_set,
-      before: :store, on: :create,
-      when: proc { |c| c.type_id == Card::SetID } do
-  Card.follow_caches_expired
-end
-
-event :cache_expired_for_type_change, before: :store, on: :update,
-                                      changed: :type_id do
-  # FIXME: expire (also?) after save
-  Card.follow_caches_expired
-end
-
-event :cache_expired_for_name_change, before: :store, on: :update,
-                                      changed: :name do
-  Card.follow_caches_expired
-end
-
-event :cache_expired_for_new_user_rule,
-      before: :extend,
-      when: proc { |c| c.follow_rule_card? }  do
-  Card.follow_caches_expired
-end
-
-format do
-  def follow_link_hash args
-    toggle = args[:toggle] || (card.followed? ? :off : :on)
-    hash = { class: "follow-toggle-#{toggle}" }
-    these_emails = "emails about changes to #{card.follow_label}"
-    case toggle
-    when :off
-      hash[:content] = '*never'
-      hash[:title]   = "stop sending #{these_emails}"
-      hash[:verb]    = 'unfollow'
-    when :on
-      hash[:content] = '*always'
-      hash[:title]   = "send #{these_emails}"
-      hash[:verb]    = 'follow'
-    end
-    set_card = card.default_follow_set_card
-    hash[:path] = path(
-      name: set_card.follow_rule_name(Auth.current.name),
-      action: :update,
-      success: { layout: :modal, view: :follow_status },
-      card: { content: "[[#{hash[:content]}]]" }
-    )
-    hash
-  end
-end
-
-format :json do
-  view :follow_status do |args|
-    follow_link_hash args
-  end
-end
-
-format :html do
-  view :follow_link, tags: :unknown_ok, perms: :none do |args|
-    hash = follow_link_hash args
-    text = args[:icon] ? glyphicon('flag') : ''
-    span_attrs = 'follow-verb menu-item-label'
-    text += %[<span class="#{span_attrs}">#{hash[:verb]}</span>].html_safe
-    # follow_rule_card = Card.fetch(
-    #   card.default_follow_set_card.follow_rule_name(Auth.current.name),
-    #   new: {}
-    # )
-    opts = (args[:html_args] || {}).clone
-    opts.merge!(
-      title:           hash[:title],
-      'data-path'      => hash[:path],
-      'data-toggle'    => 'modal',
-      'data-target'    => "#modal-#{card.cardname.safe_key}",
-    )
-    opts[:class] = "follow-link #{opts[:class]}"
-    link_to text, hash[:path], opts
-  end
-end
-
-def follow_label
-  name
-end
-
-def followers
-  follower_ids.map do |id|
-    Card.fetch(id)
-  end
-end
-
-def follower_names
-  followers.map(&:name)
-end
-
-def follow_rule_card?
-  is_user_rule? && rule_setting_name == '*follow'
-end
-
-def follow_option?
-  codename && FollowOption.codenames.include?(codename.to_sym)
-end
-
-# used for the follow menu overwritten in type/set.rb and type/cardtype.rb
-# 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
-  with_follower_candidate_ids do
-    return true if follow_rule_applies? user_id
-    return true if (left_card = left) &&
-                   left_card.followed_field?(self) &&
-                   left_card.followed_by?(user_id)
-    false
-  end
-end
-
-def followed?
-  followed_by? Auth.current_id
-end
-
-def follow_rule_applies? follower_id
-  follow_rule = rule :follow, user_id: follower_id
-  if follow_rule.present?
-    follow_rule.split("\n").each do |value|
-      value_code = value.to_name.code
-      accounted_ids = (
-        @follower_candidate_ids[value_code] ||=
-          if (block = FollowOption.follower_candidate_ids[value_code])
-            block.call self
-          else
-            []
-          end
-      )
-
-      applicable =
-        if (test = FollowOption.test[value_code])
-          test.call follower_id, accounted_ids
-        else
-          accounted_ids.include? follower_id
-        end
-
-      return value.gsub(/[\[\]]/, '') if applicable
-    end
-  end
-  false
-end
-
-def with_follower_candidate_ids
-  @follower_candidate_ids = {}
-  yield
-  @follower_candidate_ids = nil
-end
-
-# the set card to be followed if you want to follow changes of card
-def default_follow_set_card
-  Card.fetch("#{name}+*self")
-end
-
-# returns true if according to the follow_field_rule followers of self also
-# follow changes of field_card
-def followed_field? field_card
-  (follow_field_rule = rule_card(:follow_fields)) ||
-    follow_field_rule.item_names.find do |item|
-     item.to_name.key == field_card.key || (item.to_name.key == Card[:includes].key && included_card_ids.include?(field_card.id) )
-  end
-end
-
-def follower_ids
-  @follower_ids = read_follower_ids_cache || begin
-    result = direct_follower_ids
-    left_card = left
-    while left_card
-      if left_card.followed_field? self
-        result += left_card.direct_follower_ids
-      end
-      left_card = left_card.left
-    end
-    write_follower_ids_cache result
-    result
-  end
-end
-
-def direct_followers
-  direct_follower_ids.map do |id|
-    Card.fetch(id)
-  end
-end
-
-# all ids of users that follow this card because of a follow rule that applies
-# to this card doesn't include users that follow this card because they are
-# following parent cards or other cards that include this card
-def direct_follower_ids _args={}
-  result = ::Set.new
-  with_follower_candidate_ids do
-    set_names.each do |set_name|
-      set_card = Card.fetch(set_name)
-      set_card.all_user_ids_with_rule_for(:follow).each do |user_id|
-        if (!result.include? user_id) && self.follow_rule_applies?(user_id)
-          result << user_id
-        end
-      end
-    end
-  end
-  result
-end
-
-def all_direct_follower_ids_with_reason
-  with_follower_candidate_ids do
-    visited = ::Set.new
-    set_names.each do |set_name|
-      set_card = Card.fetch(set_name)
-      set_card.all_user_ids_with_rule_for(:follow).each do |user_id|
-        if (!visited.include?(user_id)) &&
-           (follow_option = self.follow_rule_applies?(user_id))
-          visited << user_id
-          yield(user_id, set_card: set_card, option: follow_option)
-        end
-      end
-    end
-  end
-end
-
-# ~~~~~ cache methods
-
-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
-
-module ClassMethods
-  def follow_caches_expired
-    Card.clear_follower_ids_cache
-    Card.clear_user_rule_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
-
-
-# ~~~~~~~~~~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/05_email/set/all/follow.rb ~~~~~~~~~~~
-end;end;end;end;

data/tmpsets/set/mod006-05_email/all/notify.rb

@@ -1,262 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; module All; module Notify; extend Card::Set
-# ~~~~~~~~~~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/05_email/set/all/notify.rb ~~~~~~~~~~~
-
-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)
-          if !@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,
-      after: :subsequent, 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 extend phase instead of the
-# subsequent phase
-event :stash_followers, after: :approve, on: :delete do
-  act_card.follower_stash ||= FollowerStash.new
-  act_card.follower_stash.add_affected_card self
-end
-event :notify_followers_after_delete,
-      after: :extend, 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.new_values[:name] && action.old_values[: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.new_values[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.old_values[field]
-      else
-        action.new_values[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
-
-
-# ~~~~~~~~~~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/05_email/set/all/notify.rb ~~~~~~~~~~~
-end;end;end;end;