card 1.99.6 → 1.100.0

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

@@ -0,0 +1,71 @@
+# -*- 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, template: :haml
+
+  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 :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,202 @@
+# -*- 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={}
+  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
+
+# @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
+  items_to_content array
+  save!
+end
+
+# append item to list (does not save)
+# @param item [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 name [String, Card::Name] item name
+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 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
+  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 WQL
+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, args.slice(:limit, :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;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,86 @@
+# -*- 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 == 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 :content_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_view
+    @option_view ||= card.rule(:content_option_view) || :smart_label
+  end
+
+  def option_label_text option_name
+    return option_name unless (option_card = Card.fetch option_name)
+
+    nest option_card, view: option_view
+  end
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/pointer/set/abstract/02_pointer/options_api.rb ~~

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

@@ -0,0 +1,111 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Abstract; module Pointer;
+# Set: Abstract (Pointer, OtherViews)
+#
+# BASE views
+module OtherViews;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/pointer/set/abstract/02_pointer/other_views.rb"; end
+
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  def default_limit
+    20
+  end
+
+  def item_links args={}
+    card.item_cards(args).map do |item_card|
+      subformat(item_card).render_link
+    end
+  end
+
+  def nest_item_array
+    card.item_cards.map do |item|
+      nest_item item
+    end
+  end
+
+  view :core do
+    pointer_items.join ", "
+  end
+
+  def pointer_items args={}
+    page_args = args.extract! :limit, :offset
+    listing card.item_cards(page_args), args
+  end
+end
+
+# JavaScript views
+
+module JsFormat; parent.send :register_set_format, Card::Format::JsFormat, self; extend Card::Set::AbstractFormat
+  view :core do
+    nest_item_array.join "\n\n"
+  end
+end
+
+# Data views
+
+module DataFormat; parent.send :register_set_format, Card::Format::DataFormat, self; extend Card::Set::AbstractFormat
+  view :core do
+    nest_item_array
+  end
+end
+
+# JSON views
+
+module JsonFormat; parent.send :register_set_format, Card::Format::JsonFormat, self; extend Card::Set::AbstractFormat
+  view :content do
+    card.item_names
+  end
+
+  def item_cards
+    card.item_cards
+  end
+
+  def max_depth
+    params[:max_depth] || 1
+  end
+
+  def items_for_export
+    card.item_cards
+  end
+
+  def essentials
+    return {} if depth > max_depth
+    card.item_cards.map do |item|
+      nest item, view: :essentials
+    end
+  end
+
+  view :links do
+    []
+  end
+end
+
+# CSS views
+
+module CssFormat; parent.send :register_set_format, Card::Format::CssFormat, self; extend Card::Set::AbstractFormat
+  # generalize to all collections?
+  def default_item_view
+    :content
+  end
+
+  view :titled do
+    %(#{major_comment "STYLE GROUP: \"#{card.name}\"", '='}#{_render_core})
+  end
+
+  view :core do
+    nest_item_array.join "\n\n"
+  end
+
+  view :content, :core
+end
+
+# RSS views
+
+module RssFormat; parent.send :register_set_format, Card::Format::RssFormat, self; extend Card::Set::AbstractFormat
+  def raw_feed_items
+    @raw_feed_items ||= card.item_cards(limit: limit, offset: offset)
+  end
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/pointer/set/abstract/02_pointer/other_views.rb ~~