card 1.102.0 → 1.103.3

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

@@ -1,101 +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/ezl5238/dev/decko/gem/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 => e
-  errors.add :exception, e.message
-end
-
-module Format; module_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/ezl5238/dev/decko/gem/mod/email/set/type/email_template.rb ~~

data/tmpsets/set/mod005-collection/abstract/items.rb

@@ -1,215 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Abstract
-# Set: Abstract (Items)
-#
-# ~~~~~~~~~~~~ READING ITEMS ~~~~~~~~~~~~
-
-module Items;
-extend Card::Set
-def self.source_location; "/Users/ezl5238/dev/decko/gem/mod/collection/set/abstract/items.rb"; end
-# While each of the three main methods for returning lists of items can handle arguments,
-# they are most commonly used without them.
-
-# @return [Array] list of Card::Name objects
-# @param args [Hash]
-# @option args [String] :content override card content
-# @option args [String, Card::Name, Symbol] :context name in whose context relative items
-#         will be interpreted. For example. +A in context of B is interpreted as B+A
-#         context defaults to pointer card's name. If value is `:raw`, then name is not
-#         contextualized
-# @option args [String, Integer] :limit max number of cards to return
-# @option args [String, Integer] :offset begin after the offset-th item
-def item_names args={}
-  context = args[:context]
-  item_strings(args).map do |item|
-    clean_item_name item, context
-  end.compact
-end
-
-def first_name args={}
-  item_names(args).first
-end
-
-def first_card args={}
-  return unless (name = first_name)
-
-  fetch_item_card name, args
-end
-
-def first_code
-  first_card&.codename
-end
-
-def first_id
-  first_card&.id
-end
-
-# @return [Array] list of integers (card ids of items)
-# @param args [Hash] see #item_names
-def item_ids args={}
-  item_names(args).map(&:card_id).compact
-end
-
-# @return [Array] list of Card objects
-# @param args [Hash] see #item_names for additional options
-# @option args [String] :complete keyword to use in searching among items
-# @option args [True/False] :known_only if true, return only known cards
-# @option args [String] :type name of type to be used for unknown cards
-def item_cards args={}
-  return item_cards_search(args) if args[:complete]
-  return known_item_cards(args) if args[:known_only]
-
-  all_item_cards args
-end
-
-# #item_name, #item_id, and #item_card each return a single item, rather than an array.
-%i[name id card].each do |obj|
-  define_method "item_#{obj}" do |args={}|
-    send("item_#{obj}s", args.merge(limit: 1)).first
-  end
-end
-
-# for override, eg by json
-def item_value item_name
-  item_name
-end
-
-# ~~~~~~~~~~~~ ALTERING ITEMS ~~~~~~~~~~~~
-
-# set card content based on array and save card
-# @param array [Array] list of strings/names (Cardish)
-def items= array
-  items_to_content array
-  save!
-end
-
-# append item to list (does not save)
-# @param cardish [Cardish]
-def << cardish
-  add_item cardish
-end
-
-# append item to list (does not save)
-# @param cardish [String, Card::Name] item name
-# @param allow_duplicates [True/False] permit duplicate items (default is False)
-def add_item cardish, allow_duplicates=false
-  return if !allow_duplicates && include_item?(cardish)
-
-  items = item_strings << cardish
-  items_to_content items
-end
-
-# append item to list and save card
-# @param name [String, Card::Name] item name
-def add_item! name
-  add_item(name) && save!
-end
-
-# remove item from list
-# @param cardish [String, Card::Name] item to drop
-def drop_item cardish
-  drop_item_name = Card::Name[cardish]
-  items_to_content(item_names.reject { |item_name| item_name == drop_item_name })
-end
-
-# remove item from list and save card
-# @param cardish [String, Card::Name] item to drop
-def drop_item! cardish
-  drop_item cardish
-  save!
-end
-
-# insert item into list at specified location
-# @param index [Integer] Array index in which to insert item (0 is first)
-# @param name [String, Card::Name] item name
-def insert_item index, name
-  new_names = item_names
-  new_names.delete name
-  new_names.insert index, name
-  items_to_content new_names
-end
-
-# insert item into list at specified location and save
-# @param index [Integer] Array index in which to insert item (0 is first)
-# @param name [String, Card::Name] item name
-def insert_item! index, name
-  insert_item index, name
-  save!
-end
-
-# ~~~~~~~~~~~~ READING ITEM HELPERS ~~~~~~~~~~~~
-
-# Warning: the following methods, while available for use, may be subject to change
-
-# #item_cards helpers
-
-def item_cards_search query
-  Card::Query.run query.reverse_merge(referred_to_by: name, limit: 0)
-end
-
-def known_item_cards args={}
-  item_names(args).map { |name| Card.fetch name }.compact
-end
-
-def all_item_cards args={}
-  names = args[:item_names] || item_names(args)
-  names.map { |name| fetch_item_card name, args }
-end
-
-# TODO: support type_code and type_id. (currently type)
-# uses name, because its most common use is from CQL
-def item_type
-  opt = options_rule_card
-  # FIXME: need better recursion prevention
-  return if !opt || opt == self
-
-  opt.item_type
-end
-
-def item_strings args={}
-  items = raw_item_strings(args[:content] || content)
-  return items unless args.present?
-
-  filtered_items items, limit: args[:limit], offset: args[:offset]
-end
-
-def raw_item_strings content
-  content.to_s.split(/\n+/).map { |i| strip_item i }
-end
-
-private
-
-def filtered_items items, limit: 0, offset: 0
-  limit = limit.to_i
-  offset = offset.to_i
-  return items unless limit.positive? || offset.positive?
-
-  items[offset, (limit.zero? ? items.size : limit)] || []
-end
-
-def fetch_item_card name, args={}
-  Card.fetch name, new: new_unknown_item_args(args)
-end
-
-def new_unknown_item_args args
-  itype = args[:type] || item_type
-  itype ? { type: itype } : {}
-end
-
-def clean_item_name item, context
-  item = item.to_name
-  return item if context == :raw
-
-  context ||= context_card.name
-  item.absolute_name context
-rescue Card::Error::NotFound
-  # eg for invalid ids or codenames
-  # "Invalid Item: #{item}".to_name
-  nil
-end
-
-def strip_item item
-  item.gsub(/\[\[|\]\]/, "").strip
-end
-end;end;end;end;
-# ~~ generated from /Users/ezl5238/dev/decko/gem/mod/collection/set/abstract/items.rb ~~

data/tmpsets/set/mod005-collection/abstract/paging/paging_links.rb

@@ -1,99 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Abstract
-# Set: Abstract (Paging)
-#
-#! no set module
-
-module Paging;
-def self.source_location; "/Users/ezl5238/dev/decko/gem/mod/collection/set/abstract/paging/paging_links.rb"; end
-# render paging links
-class PagingLinks
-  def initialize total_pages, current_page
-    @total = total_pages
-    @current = current_page
-  end
-
-  # @param window [integer] number of page links shown left and right
-  #   of the current page
-  # @example: current page = 5, window = 2
-  #   |<<|1|...|3|4|[5]|6|7|...|10|>>|
-  # @yield [text, page, status, options] block to build single paging link
-  # @yieldparam status [Symbol] :active (for current page) or :disabled
-  # @yieldparam page [Integer] page number, first page is 0
-  # @return [Array<String>]
-  def build window=2, &block
-    @render_item = block
-    links window
-  end
-
-  private
-
-  def links window
-    @window_start = [@current - window, 0].max
-    @window_end = [@current + window, @total].min
-    left_part + window_part + right_part
-  end
-
-  # the links around the current page
-  def window_part
-    (@window_start..@window_end).map do |page|
-      direct_page_link page
-    end.compact
-  end
-
-  def left_part
-    [
-      previous_page_link,
-      (direct_page_link 0 if @window_start.positive?),
-      (ellipse if @window_start > 1)
-    ].compact
-  end
-
-  def right_part
-    [
-      (ellipse if @total > @window_end + 1),
-      (direct_page_link @total if @total > @window_end),
-      next_page_link
-    ].compact
-  end
-
-  def previous_page_link
-    paging_item '<span aria-hidden="true">&laquo;</span>', previous_page,
-                "aria-label" => "Previous", status: :previous
-  end
-
-  def next_page_link
-    paging_item '<span aria-hidden="true">&raquo;</span>', next_page,
-                "aria-label" => "Next", status: :next
-  end
-
-  def direct_page_link page
-    return unless page >= 0 && page <= @total
-
-    paging_item page + 1, page
-  end
-
-  def ellipse
-    paging_item "<span>...</span>", nil, status: :ellipses
-  end
-
-  def paging_item text, page, options={}
-    status =
-      if page == @current
-        :current
-      else
-        options.delete :status
-      end
-    @render_item.call text, page, status, options
-  end
-
-  def previous_page
-    @current.positive? ? @current - 1 : false
-  end
-
-  def next_page
-    @current < @total ? @current + 1 : false
-  end
-end
-end;end;end;end;
-# ~~ generated from /Users/ezl5238/dev/decko/gem/mod/collection/set/abstract/paging/paging_links.rb ~~

data/tmpsets/set/mod005-collection/abstract/paging/paging_views.rb

@@ -1,121 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Abstract; module Paging;
-# Set: Abstract (Paging, PagingViews)
-#
-module PagingViews;
-extend Card::Set
-def self.source_location; "/Users/ezl5238/dev/decko/gem/mod/collection/set/abstract/paging/paging_views.rb"; end
-module HtmlFormat; module_parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
-  PAGE_LI_CLASS = { ellipses: "disabled", current: "active" }.freeze
-
-  def with_paging path_args={}
-    with_paging_path_args path_args do
-      output [yield(@paging_path_args), _render_paging]
-    end
-  end
-
-  view :paging, cache: :never do
-    return "" unless paging_needed?
-
-    <<-HTML
-      <nav>
-        <ul class="pagination paging">
-          #{paging_links.join}
-        </ul>
-      </nav>
-    HTML
-  end
-
-  def paging_links
-    PagingLinks.new(total_pages, current_page).build do |text, page, status, options|
-      page_link_li text, page, status, options
-    end
-  end
-
-  # First page is 0 (not 1)
-  def page_link_li text, page, status, options={}
-    wrap_with :li, class: page_link_li_class(status) do
-      page_link text, page, options
-    end
-  end
-
-  def page_link_li_class status
-    ["page-item", PAGE_LI_CLASS[status]].compact.join " "
-  end
-
-  def page_link text, page, options
-    return content_tag(:div, text.html_safe, class: "page-link") unless page
-
-    options.merge! class: "card-paging-link slotter page-link",
-                   remote: true,
-                   path: page_link_path_args(page)
-    link_to raw(text), options
-  end
-
-  def with_paging_path_args args
-    tmp = @paging_path_args
-    @paging_path_args = paging_path_args args
-    yield
-  ensure
-    @paging_path_args = tmp
-  end
-
-  def paging_path_args local_args={}
-    @paging_path_args ||= {}
-    @paging_path_args.reverse_merge!(limit: limit, offset: offset)
-    @paging_path_args.merge! extra_paging_path_args
-    @paging_path_args.merge local_args
-  end
-
-  def page_link_path_args page
-    paging_path_args.merge offset: page * limit
-  end
-
-  def paging_needed?
-    return false if limit < 1
-    return false if fewer_results_than_limit? # avoid extra count search
-
-    # count search result instead
-    limit < count_with_params
-  end
-
-  # clear we don't need paging even before running count query
-  def fewer_results_than_limit?
-    return false unless offset.zero?
-
-    limit > offset + search_with_params.length
-  end
-end
-
-module JsonFormat; module_parent.send :register_set_format, Card::Format::JsonFormat, self; extend Card::Set::AbstractFormat
-  def page_link_path_args page
-    {
-      limit: limit,
-      offset: page * limit,
-      item: default_item_view, # hack. need standard voo handling
-      format: :json
-    }.merge extra_paging_path_args
-  end
-
-  view :paging_urls, cache: :never do
-    return {} unless total_pages > 1
-
-    { paging: paging_urls_hash }
-  end
-
-  def paging_urls_hash
-    hash = {}
-    PagingLinks.new(total_pages, current_page).build do |_text, page, status, _options|
-      add_paging_url hash, page, status
-    end
-    hash
-  end
-
-  def add_paging_url hash, page, status
-    return unless page && status.in?(%i[next previous])
-
-    hash[status] = path page_link_path_args(page)
-  end
-end
-end;end;end;end;end;
-# ~~ generated from /Users/ezl5238/dev/decko/gem/mod/collection/set/abstract/paging/paging_views.rb ~~

data/tmpsets/set/mod005-collection/abstract/paging.rb

@@ -1,74 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Abstract
-# Set: Abstract (Paging)
-#
-module Paging;
-extend Card::Set
-def self.source_location; "/Users/ezl5238/dev/decko/gem/mod/collection/set/abstract/paging.rb"; end
-MAX_ANONYMOUS_SEARCH_PARAM = 1000
-
-module Format; module_parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
-  def limit
-    @limit ||= contextual_param(:limit) || default_limit
-  end
-
-  def offset
-    @offset ||= contextual_param(:offset) || 0
-  end
-
-  def search_with_params
-    @search_with_params ||= card.item_names
-  end
-
-  def count_with_params
-    @count_with_params ||= card.item_names.count
-  end
-
-  def total_pages
-    return 1 if limit.zero?
-
-    ((count_with_params - 1) / limit).to_i
-  end
-
-  def current_page
-    (offset / limit).to_i
-  end
-
-  # for override
-  def extra_paging_path_args
-    {}
-  end
-
-  private
-
-  def contextual_param param
-    env_search_param(param) || voo_search_param(param)
-  end
-
-  def env_search_param param
-    enforcing_legal_limit param do
-      val = Env.params[param]
-      val.to_i if focal? && val.present?
-    end
-  end
-
-  def enforcing_legal_limit param
-    yield.tap do |val|
-      enforce_legal_limit! val if param == :limit
-    end
-  end
-
-  def enforce_legal_limit! val
-    return if Card::Auth.signed_in? || !val || val <= MAX_ANONYMOUS_SEARCH_PARAM
-
-    raise Card::Error::PermissionDenied,
-          "limit parameter exceeds maximum for anonymous users " \
-          "(#{MAX_ANONYMOUS_SEARCH_PARAM})"
-  end
-
-  def voo_search_param param
-    voo&.cql&.dig(param)&.to_i
-  end
-end
-end;end;end;end;
-# ~~ generated from /Users/ezl5238/dev/decko/gem/mod/collection/set/abstract/paging.rb ~~

data/tmpsets/set/mod005-collection/all/extended.rb

@@ -1,59 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Extended)
-#
-module Extended;
-extend Card::Set
-def self.source_location; "/Users/ezl5238/dev/decko/gem/mod/collection/set/all/extended.rb"; end
-def extended_item_cards context=nil
-  items = item_cards limit: "", context: (context || self).name
-  list = []
-  book = ::Set.new # avoid loops
-  extend_item_list items, list, book until items.empty?
-  list
-end
-
-def extended_item_contents context=nil
-  extended_item_cards(context).map(&:item_names).flatten
-end
-
-module Format; module_parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
-  delegate :extended_item_contents, to: :card
-end
-
-private
-
-def extend_item_list items, list, book
-  item = items.shift
-  return if already_extended? item, book
-
-  if item.collection?
-    # keep items in order
-    items.unshift(*item.item_cards)
-  else  # no further level of items
-    list << item
-  end
-end
-
-def already_extended? item, book
-  return true if book.include? item
-
-  book << item
-  false
-end
-
-# def extended_list context=nil
-#   context = (context ? context.name : name)
-#   args = { limit: "" }
-#   item_cards(args.merge(context: context)).map do |x|
-#     x.item_cards(args)
-#   end.flatten.map do |x|
-#     x.item_cards(args)
-#   end.flatten.map do |y|
-#     y.item_names(args)
-#   end.flatten
-#   # this could go on and on.  more elegant to recurse until you don't have
-#   # a collection
-# end
-end;end;end;end;
-# ~~ generated from /Users/ezl5238/dev/decko/gem/mod/collection/set/all/extended.rb ~~