card 1.99.6 → 1.100.0

data/tmpsets/set/mod016-email/type/email_template.rb

@@ -0,0 +1,100 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Type
+# Set: All "EmailTemplate" cards
+#
+module EmailTemplate;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/email/set/type/email_template.rb"; end
+
+def clean_html?
+  false
+end
+
+def deliver context=nil, fields={}, opts={}
+  mail = format.mail context, fields, opts
+  mail.deliver
+rescue Net::SMTPError => exception
+  errors.add :exception, exception.message
+end
+
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  def mail context=nil, fields={}, opts={}
+    config = card.email_config context, fields, opts
+    fmt = self # self is <Mail::Message> within the new_mail block
+    Card::Mailer.new_mail config do
+      fmt.message_body self, config
+      fmt.add_attachments self, config.delete(:attach)
+    end
+  end
+
+  def message_body mail, config
+    config[:html_message] &&= config[:html_message].call mail
+    method, args = body_method_and_args config[:html_message].present?,
+                                        config[:text_message].present?
+    args = Array.wrap(args).map { |arg| config[arg] }
+    send method, mail, *args
+  end
+
+  def body_method_and_args html, text
+    if html && text
+      [:text_and_html_message, %i[text_message html_message attach]]
+    elsif html
+      %i[html_body html_message]
+    else
+      %i[text_body text_message]
+    end
+  end
+
+  def text_and_html_message mail, text_message, html_message, attachment_list=nil
+    fmt = self
+    if attachment_list&.any?
+      mail.multipart_mixed text_message, html_message
+    else
+      mail.text_part { body text_message }
+      mail.html_part { fmt.html_body self, html_message }
+    end
+  end
+
+  def multipart_mixed mail, text_message, html_message
+    mail.content_type "multipart/mixed"
+    mail.part content_type: "multipart/alternative" do |copy|
+      copy.part content_type: "text/plain" do |plain|
+        plain.body = text_message
+      end
+      copy.part content_type: "text/html" do |html|
+        html.body = html_message
+      end
+    end
+  end
+
+  def html_body mail, message
+    mail.content_type "text/html; charset=UTF-8"
+    mail.body message
+  end
+
+  def text_body mail, message
+    mail.content_type "text/plain; charset=UTF-8"
+    mail.text_part { body message }
+  end
+
+  def add_attachments mail, list
+    return unless list.present?
+    each_valid_attachment list do |file, index|
+      mail.add_file filename: attachment_name(file, index),
+                    content: File.read(file.path)
+    end
+  end
+
+  def each_valid_attachment list
+    list.each_with_index do |cardname, index|
+      next unless (file = Card[cardname]&.try(:attachment))
+      yield file, index
+    end
+  end
+
+  def attachment_name file, number
+    "attachment-#{number + 1}.#{file.extension}"
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/email/set/type/email_template.rb ~~

data/tmpsets/set/mod016-email/type/email_template/email_config.rb

@@ -0,0 +1,90 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Type; module EmailTemplate;
+# Set: All "EmailTemplate+EmailConfig" cards (EmailConfig)
+#
+module EmailConfig;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/email/set/type/email_template/email_config.rb"; end
+EMAIL_FIELDS =
+  %i[to from cc bcc attach subject text_message html_message].freeze
+
+EMAIL_FIELD_METHODS =
+  { subject: :contextual_content,
+    text_message: :contextual_content,
+    attach: :extended_item_contents }.freeze
+
+# @param [Card] context  the card in whose context all email fields will be interpreted
+# @param [Hash] fields override any templated field configurations with hash values
+# @param [Hash] opts options for rendering. unknown options become format options
+# @option opts [Card, String, Integer] :auth user identifier. render as this user
+def email_config context, fields={}, opts={}
+  @active_email_context = context || self
+  auth = opts.delete :auth
+  config = EMAIL_FIELDS.each_with_object({}) do |field, conf|
+    conf[field] = fields[field] || email_field_from_card(field, auth, opts)
+  end
+  safe_from_and_reply_to! config
+  config.select { |_k, v| v.present? }
+end
+
+def email_field_from_card field, auth, format_opts
+  return unless (field_card = fetch(field))
+  auth ||= field_card.updater
+  special_email_field_method(field, field_card, auth, format_opts) ||
+    standard_email_field(field, field_card, auth, format_opts)
+end
+
+def special_email_field_method field, field_card, auth, format_opts
+  method = "email_#{field}_field"
+  return unless respond_to? method
+  send method, field_card, auth, format_opts
+end
+
+def standard_email_field field, field_card, auth, format_opts
+  method = EMAIL_FIELD_METHODS[field] || :email_addresses
+  format_opts = format_opts.merge format: :email_text
+  Auth.as auth do
+    field_card.format(format_opts).send method, @active_email_context
+  end
+end
+
+# html messages return procs because image attachments can't be properly rendered
+# without a mail object. (which isn't available at initial config time)
+def email_html_message_field message_card, auth, format_opts
+  proc do |mail|
+    Auth.as auth do
+      format_opts = format_opts.merge format: :email_html, active_mail: mail
+      message_card.format(format_opts).email_content @active_email_context
+    end
+  end
+end
+
+# whenever a default "from" field is configured in Card::Mailer, emails are always
+# actually "from" that address
+def safe_from_and_reply_to! config
+  conf_name, conf_email = configured_from_name_and_email config[:from]
+  actual_email = Card::Mailer.default[:from] || conf_email
+  config[:from] = email_from_field_value conf_name, conf_email, actual_email
+  config[:reply_to] ||= actual_email
+end
+
+def email_from_field_value conf_name, conf_email, actual_email
+  conf_text = conf_name || conf_email
+  if conf_text != actual_email
+    %("#{conf_text}" <#{actual_email}>)
+  elsif actual_email.present?
+    actual_email
+  else
+    Card[WagnBotID].account.email
+  end
+end
+
+def configured_from_name_and_email raw_string
+  if raw_string =~ /(.*)\<(.*)>/
+    [Regexp.last_match(1).strip, Regexp.last_match(2)]
+  else
+    [nil, raw_string]
+  end
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/email/set/type/email_template/email_config.rb ~~

data/tmpsets/set/mod017-follow/abstract/follow_option.rb

@@ -0,0 +1,65 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Abstract
+# Set: Abstract (FollowOption)
+#
+module FollowOption;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/follow/set/abstract/follow_option.rb"; end
+def restrictive_option?
+  Card::FollowOption.restrictive_options.include? codename
+end
+
+def description set_card
+  set_card.follow_label
+end
+
+# follow option methods on the Card class
+# FIXME: there's not a great reason to have these on the Card class
+module ClassMethods
+  # args:
+  # position: <Fixnum> (starting at 1, default: add to end)
+  def restrictive_follow_opts args
+    add_option args, :restrictive
+  end
+
+  # args:
+  # position: <Fixnum> (starting at 1, default: add to end)
+  def follow_opts args
+    add_option args, :main
+  end
+
+  def follow_test opts={}, &block
+    Card::FollowOption.test[get_codename(opts)] = block
+  end
+
+  def follower_candidate_ids opts={}, &block
+    Card::FollowOption.follower_candidate_ids[get_codename(opts)] = block
+  end
+
+  private
+
+  def insert_option pos, item, type
+    list = Card::FollowOption.codenames(type)
+    list[pos] ? list.insert(pos, item) : (list[pos] = item)
+    # If pos > codenames.size in a previous insert then we have a bunch
+    # of preceding nils in the array.
+    # Hence, we have to overwrite a nil value if we encounter one and
+    # can't use insert.
+  end
+
+  def add_option opts, type, &_block
+    codename = get_codename opts
+    if opts[:position]
+      insert_option opts[:position] - 1, codename, type
+    else
+      Card::FollowOption.codenames(type) << codename
+    end
+    Card::FollowOption.codenames(:all) << codename
+  end
+
+  def get_codename opts
+    opts[:codename] || name.match(/::(\w+)$/)[1].underscore.to_sym
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/follow/set/abstract/follow_option.rb ~~

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

@@ -0,0 +1,42 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Follow)
+#
+# for override
+module Follow;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/follow/set/all/follow.rb"; end
+def followable?
+  true
+end
+
+def follow_label
+  name
+end
+
+def list_direct_followers?
+  false
+end
+
+def follow_option?
+  codename && FollowOption.codenames.include?(codename)
+end
+
+# the set card to be followed if you want to follow changes of card
+def follow_set_card
+  Card.fetch name, :self
+end
+
+def follow_rule_name user=nil
+  follow_set_card&.follow_rule_name user
+end
+
+def follow_rule_card user=nil, args={}
+  Card.fetch follow_rule_name(user), args
+end
+
+def follow_rule? user=nil
+  Card.exists? follow_rule_name(user)
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/follow/set/all/follow.rb ~~

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

@@ -0,0 +1,69 @@
+# -*- 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/follow_link.rb"; end
+class FollowLink
+  attr_reader :format, :rule_content, :link_text, :action, :css_class, :hover_text
+
+  delegate :link_to, to: :format
+
+  def initialize format
+    @format = format
+    @card = format.card
+  end
+
+  def modal_link icon=false
+    opts = link_opts.merge(
+      "data-path": link_opts[:path],
+      "data-toggle": "modal",
+      "data-target": "#modal-#{card.name.safe_key}",
+      class: css_classes("follow-link", link_opts[:class])
+    )
+    link_to render_link_text(icon), opts
+  end
+
+  def button
+    opts = link_opts(:follow_section).merge(
+      remote: true,
+      class: @format.css_classes("follow-link", link_opts[:class],
+                                 "slotter btn btn-sm btn-primary")
+    )
+    opts["data-update-foreign-slot"] = ".d0-card-body > .card-slot.RIGHT-Xfollower.content-view"
+    opts["data-hover-text"] = hover_text if hover_text
+    link_to render_link_text, opts
+  end
+
+  def link_opts success_view=:follow_status
+    { title: title,
+      path: path(success_view),
+      class: css_class }
+  end
+
+  def render_link_text icon=false
+    verb = %(<span class="follow-verb">#{link_text}</span>)
+    icon = icon ? icon_tag(:flag) : ""
+    [icon, verb].compact.join.html_safe
+  end
+
+  private
+
+  def mark
+    @card.follow_set_card.follow_rule_name Auth.current.name
+  end
+
+  def path view=:follow_status
+    @format.path mark: mark,
+                 action: :update,
+                 success: { id: @card.name, view: view },
+                 card: { content: "[[#{rule_content}]]" }
+  end
+
+  def title
+    "#{action} emails about changes to #{@card.follow_label}"
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/follow/set/all/follow/follow_link.rb ~~

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

@@ -0,0 +1,38 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Follow;
+# Set: All cards (Follow, FollowLinkViews)
+#
+module FollowLinkViews;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/follow/set/all/follow/follow_link_views.rb"; end
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  def follow_link_class
+    card.followed? ? StopFollowLink : StartFollowLink
+  end
+
+  def show_follow?
+    Auth.signed_in? && !card.new_card? && card.followable?
+  end
+end
+
+module JsonFormat; parent.send :register_set_format, Card::Format::JsonFormat, self; extend Card::Set::AbstractFormat
+  view :follow_status do
+    follow_link_class.link_opts
+  end
+end
+
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  def follow_button
+    follow_link_class.new(self).button
+  end
+
+  def follow_modal_link
+    follow_link_class.new(self).modal_link
+  end
+
+  view :follow_button, cache: :never do
+    follow_button
+  end
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/follow/set/all/follow/follow_link_views.rb ~~

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

@@ -0,0 +1,79 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Follow;
+# Set: All cards (Follow, FollowedBy)
+#
+# used by +:followers overwritten in type/set.rb and type/cardtype.rb
+module FollowedBy;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/follow/set/all/follow/followed_by.rb"; end
+def followed?
+  followed_by? Auth.current_id
+end
+
+# 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
+  follow_rule_applies?(user_id) || left&.followed_by_as_field?(self, user_id)
+end
+
+def followed_by_as_field? field, user_id
+  followed_field?(field) && followed_by?(user_id)
+end
+
+# returns true if according to the follow_field_rule followers of self also
+# follow changes of field_card
+def followed_field? field_card
+  return unless (follow_field_rule = rule_card(:follow_fields))
+
+  follow_field_rule.item_names(context: self).find do |item|
+    case item.to_name.key
+    when field_card.key         then true
+    when :nests.cardname.key then nested_card?(field_card)
+    end
+  end
+end
+
+def nested_card? card
+  nestee_ids.include? card.id
+end
+
+## the following methods all handle _explicit_ (direct) follow rules (not fields)
+
+def follow_rule_applies? follower_id
+  !follow_rule_option(follower_id).nil?
+end
+
+def follow_rule_option follower_id
+  all_follow_rule_options(follower_id).find do |option|
+    follow_rule_option_applies? follower_id, option
+  end
+end
+
+def all_follow_rule_options follower_id
+  follow_rule = rule :follow, user_id: follower_id
+  return [] unless follow_rule.present?
+
+  follow_rule.split("\n")
+end
+
+def follow_rule_option_applies? follower_id, option
+  option_code = option.to_name.code
+  candidate_ids = follower_candidate_ids_for_option option_code
+  follow_rule_option_applies_to_candidates? follower_id, option_code, candidate_ids
+end
+
+def follow_rule_option_applies_to_candidates? follower_id, option_code, candidate_ids
+  if (test = FollowOption.test[option_code])
+    test.call follower_id, candidate_ids
+  else
+    candidate_ids.include? follower_id
+  end
+end
+
+def follower_candidate_ids_for_option option_code
+  return [] unless (block = FollowOption.follower_candidate_ids[option_code])
+
+  block.call self
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/follow/set/all/follow/followed_by.rb ~~