card 1.99.1 → 1.99.6

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

@@ -1,100 +0,0 @@
-# -*- 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

@@ -1,90 +0,0 @@
-# -*- 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(trait: 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[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

@@ -1,65 +0,0 @@
-# -*- 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

@@ -1,42 +0,0 @@
-# -*- 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

@@ -1,69 +0,0 @@
-# -*- 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

@@ -1,38 +0,0 @@
-# -*- 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

@@ -1,80 +0,0 @@
-# -*- 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 :includes.cardname.key then nested_card?(field_card)
-    end
-  end
-end
-
-def nested_card? card
-  @nested_ids ||= includee_ids
-  @nested_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 ~~