card 1.97.0.1 → 1.98.0

data/tmpsets/set/mod008-pointer/abstract/02_pointer/events.rb

@@ -0,0 +1,59 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Abstract; module Pointer;
+# Set: Abstract (Pointer, Events)
+#
+module Events;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/pointer/set/abstract/02_pointer/events.rb"; end
+event :add_and_drop_items, :prepare_to_validate, on: :save do
+  adds = Env.params["add_item"]
+  drops = Env.params["drop_item"]
+  Array.wrap(adds).each { |i| add_item i } if adds
+  Array.wrap(drops).each { |i| drop_item i } if drops
+end
+
+event :insert_item_event, :prepare_to_validate, on: :save, when: :item_to_insert do
+  index = Env.params["item_index"] || 0
+  insert_item index.to_i, item_to_insert
+end
+
+def item_to_insert
+  Env.params["insert_item"]
+end
+
+# If a card's type and content are updated in the same action, the new module
+# will override the old module's events and functions. But this event is only
+# on pointers -- other type cards do not have this event,
+# Therefore if something is changed from a pointer and its content is changed
+# in the same action, this event will be run and will treat the content like
+# it' still pointer content.  The "when" clause helps with that (but is a hack)
+event :standardize_items, :prepare_to_validate,
+      on: :save, changed: :content, when: :still_pointer? do
+  self.content = item_names(context: :raw).map do |name|
+    "[[#{name}]]"
+  end.join "\n"
+end
+
+def still_pointer?
+  type_id == Card::PointerID
+end
+
+stage_method :changed_item_names do
+  dropped_item_names + added_item_names
+end
+
+stage_method :dropped_item_names do
+  old_items = item_names content: db_content_before_act
+  old_items - item_names
+end
+
+stage_method :added_item_names do
+  old_items = item_names content: db_content_before_act
+  item_names - old_items
+end
+
+stage_method :changed_item_cards do
+  item_cards content: changed_item_names
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/pointer/set/abstract/02_pointer/events.rb ~~

data/tmpsets/set/mod008-pointer/abstract/02_pointer/html_views.rb

@@ -0,0 +1,117 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Abstract; module Pointer;
+# Set: Abstract (Pointer, HtmlViews)
+#
+module HtmlViews;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/pointer/set/abstract/02_pointer/html_views.rb"; end
+include_set Abstract::BsBadge
+
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  view :core, cache: :never do
+    standard_pointer_core
+  end
+
+  view :item_cores, cache: :never do
+    card.known_item_cards.map do |item|
+      nest item, view: :core
+    end.join "\n"
+  end
+
+  def standard_pointer_core
+    with_paging do |paging_args|
+      wrap_with :div, standard_pointer_items(paging_args), class: "pointer-list"
+    end
+  end
+
+  def standard_pointer_items paging_args
+    pointer_items paging_args.extract!(:limit, :offset)
+  end
+
+  view :closed_content do
+    item_view = implicit_item_view
+    item_view = item_view == "name" ? "name" : "link"
+    wrap_with :div, class: "pointer-list" do
+      # limit to first 10 items to optimize
+      pointer_items(view: item_view, limit: 10, offset: 0).join ", "
+    end
+  end
+
+  def wrap_item rendered, item_view
+    %(<div class="pointer-item item-#{item_view}">#{rendered}</div>)
+  end
+
+  view :editor do
+    _render_hidden_content_field + super()
+  end
+
+  def default_editor
+    :list
+  end
+
+  view :list, cache: :never do
+    list_input
+  end
+
+  def list_input args={}
+    items = items_for_input args[:item_list]
+    extra_class = "pointer-list-ul"
+    ul_classes = classy "pointer-list-editor", extra_class
+    haml :list_input, items: items, ul_classes: ul_classes
+  end
+
+  %i[autocomplete checkbox radio select multiselect].each do |editor_view|
+    view(editor_view) { send "#{editor_view}_input" }
+  end
+
+  def autocomplete_input
+    items = items_for_input
+    haml :autocomplete_input, item: items.first, options_card: options_card_name
+  end
+
+  def checkbox_input
+    haml :checkbox_input
+  end
+
+  def radio_input
+    haml :radio_input
+  end
+
+  def select_input
+    options = { "-- Select --" => "" }.merge card.options_hash
+    select_tag("pointer_select-#{unique_id}",
+               options_for_select(options, card.item_name),
+               class: "pointer-select form-control")
+  end
+
+  def multiselect_input
+    select_tag "pointer_multiselect-#{unique_id}",
+               options_for_select(card.options_hash, card.item_names),
+               multiple: true, class: "pointer-multiselect form-control"
+  end
+
+  def add_item_modal_link
+    modal_link "Add Item",
+               size: :large,
+               class: "btn btn-sm btn-primary _add-item-link",
+               path: { view: :filter_items_modal,
+                       item: implicit_item_view,
+                       filter_card: filter_card.name,
+                       slot_selector: filtered_list_slot_class,
+                       item_selector: "_filtered-list-item",
+                       slot: { hide: [:modal_footer] },
+                       filter: { not_ids: card.item_ids.map(&:to_s).join(",") } }
+  end
+
+  def add_item_overlay_link; end
+
+  private
+
+  # currently only used by :list and :autocomplete. could be generalized?
+  def items_for_input items=nil
+    items ||= card.item_names context: :raw
+    items.empty? ? [""] : items
+  end
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/pointer/set/abstract/02_pointer/html_views.rb ~~

data/tmpsets/set/mod008-pointer/abstract/02_pointer/html_views/filter.rb

@@ -0,0 +1,73 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Abstract; module Pointer;; module HtmlViews;
+# Set: Abstract (Pointer, HtmlViews, Filter)
+#
+module Filter;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/pointer/set/abstract/02_pointer/html_views/filter.rb"; end
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  view :filtered_list, unknown: true do
+    filtered_list_input
+  end
+
+  view :filter_items_modal, unknown: true, wrap: :modal do
+    render_filter_items
+  end
+
+  view :filter_items, unknown: true, wrap: :slot  do
+    haml :filter_items
+  end
+
+  def filtered_list_input
+    with_nest_mode :normal do
+      class_up "card-slot", filtered_list_slot_class
+      with_class_up "card-slot", filtered_list_slot_class do
+        wrap do
+          haml :filtered_list_input
+        end
+      end
+    end
+  end
+
+  # NOCACHE because params alter view
+  view :add_selected_link, cache: :never, unknown: true do
+    link_to "Add Selected",
+            path: { filter_card: params[:filter_card] },
+            class: "_add-selected slotter _close-modal btn btn-primary disabled",
+            data: { "slot-selector": ".#{params[:slot_selector]}",
+                    "item-selector": ".#{params[:item_selector]}",
+                    remote: true }
+  end
+
+  def filtered_list_item item_card
+    nest_item item_card do |rendered, item_view|
+      wrap_item rendered, item_view
+    end
+  end
+
+  # for override
+  # @return [Card] search card on which filtering is based
+  def filter_card
+    filter_card_from_params || default_filter_card
+  end
+
+  def default_filter_card
+    fcard = card.options_rule_card || Card[:all]
+    return fcard if fcard.respond_to? :wql_hash
+
+    fcard.fetch trait: :referred_to_by, new: {}
+  end
+
+  def filter_card_from_params
+    return unless params[:filter_card]
+    Card.fetch params[:filter_card], new: {}
+  end
+
+  # currently actually used as a class
+  # (because we don't have api to override slot's id)
+  def filtered_list_slot_class
+    @filtered_list_slot_class ||= "filtered-list-#{unique_id}"
+  end
+end
+end;end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/pointer/set/abstract/02_pointer/html_views/filter.rb ~~

data/tmpsets/set/mod008-pointer/abstract/02_pointer/item_api.rb

@@ -0,0 +1,181 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Abstract; module Pointer;
+# Set: Abstract (Pointer, ItemApi)
+#
+# ~~~~~~~~~~~~ READING ITEMS ~~~~~~~~~~~~
+
+module ItemApi;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/pointer/set/abstract/02_pointer/item_api.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={}
+  raw_item_strings(args[:content], args[:limit], args[:offset]).map do |item|
+    clean_item_name item, args[:context]
+  end.compact
+end
+
+# @return [Array] list of integers (card ids of items)
+# @param args [Hash] see #item_names
+def item_ids args={}
+  item_names(args).map { |name| Card.fetch_id name }.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
+
+# ~~~~~~~~~~~~ ALTERING ITEMS ~~~~~~~~~~~~
+
+# set card content based on array and save card
+# @param array [Array] list of strings/names (Cardish)
+def items= array
+  self.content = ""
+  array.each { |i| self << i }
+  save!
+end
+
+# append item to list (does not save)
+# @param item [Cardish]
+def << item
+  add_item Card::Name[item]
+end
+
+# append item to list (does not save)
+# @param name [String, Card::Name] item name
+# @param allow_duplicates [True/False] permit duplicate items (default is False)
+def add_item name, allow_duplicates=false
+  return if !allow_duplicates && include_item?(name)
+  self.content = "[[#{(item_names << name).reject(&:blank?) * "]]\n[["}]]"
+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 name [String, Card::Name] item name
+def drop_item name
+  return unless include_item? name
+  key = name.to_name.key
+  new_names = item_names.reject { |n| n.to_name.key == key }
+  self.content = new_names.empty? ? "" : "[[#{new_names * "]]\n[["}]]"
+end
+
+# remove item from list and save card
+# @param name [String, Card::Name] item name
+def drop_item! name
+  drop_item name
+  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
+  self.content = new_names.map { |new_name| "[[#{new_name}]]" }.join "\n"
+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={}
+  item_names(args).map do |name|
+    Card.fetch name, new: new_unknown_item_args(args)
+  end
+end
+
+def new_unknown_item_args args
+  itype = args[:type] || item_type
+  itype ? { type: itype } : {}
+end
+
+# TODO: support type_code and type_id. (currently type)
+# uses name, because its most common use is from WQL
+def item_type
+  opt = options_rule_card
+  # FIXME: need better recursion prevention
+  return if !opt || opt == self
+  opt.item_type
+end
+
+# #item_names helpers
+
+def raw_item_strings content, limit, offset
+  items = all_raw_item_strings content
+  limit = limit.to_i
+  offset = offset.to_i
+  return items unless limit.positive? || offset.positive?
+  items[offset, (limit.zero? ? items.size : limit)] || []
+end
+
+def all_raw_item_strings content=nil
+  (content || self.content).to_s.split(/\n+/)
+end
+
+private
+
+def clean_item_name item, context
+  item = strip_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;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/pointer/set/abstract/02_pointer/item_api.rb ~~

data/tmpsets/set/mod008-pointer/abstract/02_pointer/options_api.rb

@@ -0,0 +1,93 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Abstract; module Pointer;
+# Set: Abstract (Pointer, OptionsApi)
+#
+# TODO: some of this should be moved to right/options!!
+module OptionsApi;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/pointer/set/abstract/02_pointer/options_api.rb"; end
+
+def options_hash
+  json_options? ? options_card.parse_content : option_hash_from_names
+end
+
+def json_options?
+  options_card&.type_id == Card::JsonID
+end
+
+def option_hash_from_names
+  option_names.each_with_object({}) do |name, hash|
+    hash[name] = name
+  end
+end
+
+def option_names
+  if (selected_options = item_names)
+    (standard_option_names + selected_options).uniq
+  else
+    standard_option_names
+  end
+end
+
+def option_cards
+  option_names.map do |name|
+    Card.fetch name, new: {}
+  end
+end
+
+def options_rule_card
+  rule_card :options
+end
+
+def standard_option_names
+  if json_options?
+    options_hash.values.map(&:to_name)
+  else
+    option_names_from_items
+  end
+end
+
+def option_names_from_items
+  o_card = options_card
+  limit = o_card.try(:default_limit).to_i
+  o_card.item_names context: name, limit: limit
+end
+
+def options_card
+  options_rule_card || Card[:all]
+end
+
+def options_card_name
+  options_rule_card&.name&.url_key || ":all"
+end
+
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  def options_card_name
+    card.options_card_name
+  end
+end
+
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  def option_label option_name, id
+    %(<label for="#{id}">#{option_label_text option_name}</label>)
+  end
+
+  def option_label_text option_name
+    Card.fetch(option_name)&.label || option_name
+  end
+
+  # @param option_type [String] "checkbox" or "radio"
+  def option_description option_type, option_name
+    return "" unless (description = option_description_core(option_name))
+    %(<div class="#{option_type}-option-description">#{description}</div>)
+  end
+
+  def option_description_core option
+    # DISCUSS: "options label" is an obscure rule. still support?
+    desc_name = card.rule(:options_label) || "description"
+    return unless (desc_card = Card[option, desc_name])
+    nest desc_card, { view: :core }, nest_mode: :normal
+  end
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/pointer/set/abstract/02_pointer/options_api.rb ~~