card 1.19.6 → 1.20.0

data/mod/core/set/all/collection.rb

@@ -1,4 +1,4 @@
-
+# shared methods for card collections (Pointers, Searches, Sets, etc.)
 module ClassMethods
   def search spec, comment=nil
     results = ::Card::Query.run(spec, comment)
@@ -124,129 +124,137 @@ def contextual_content context_card, format_args={}, view_args={}
   )
 end
 
+def each_chunk opts={}
+  content = opts[:content] || raw_content
+  chunk_type = opts[:chunk_type] || Card::Content::Chunk
+  Card::Content.new(content, self).find_chunks(chunk_type).each do |chunk|
+    next unless chunk.referee_name # filter commented nests
+    yield chunk
+  end
+end
+
+def each_reference_chunk content=nil
+  reference_chunk_type = Card::Content::Chunk::Reference
+  each_chunk content: content, chunk_type: reference_chunk_type do |chunk|
+    yield chunk
+  end
+end
+
+def each_nested_chunk content=nil
+  nest_chunk_type = Card::Content::Chunk::Nest
+  each_chunk content: content, chunk_type: nest_chunk_type do |chunk|
+    yield chunk
+  end
+end
+
+def each_item_name_with_options content=nil
+  each_reference_chunk content do |chunk|
+    options = chunk.respond_to?(:options) ? chunk.options : {}
+    yield chunk.referee_name, options
+  end
+end
+
 format do
   def item_links _args={}
     raw(render_core).split(/[,\n]/)
   end
 
-  def item_view args
-    args[:item] ||
-      (@nest_opts && @nest_opts[:view]) ||
-      default_item_view
+  def nest_item cardish, options={}, &block
+    options = item_view_options options
+    options[:nest_name] = Card::Name.cardish(cardish).s
+    nest cardish, options, &block
   end
 
-  def item_args args
-    i_args = { view: item_view(args) }
-    if (type = card.item_type)
-      i_args[:type] = type
-    end
-    i_args
+  def implicit_item_view
+    view = voo_items_view || default_item_view
+    Card::View.canonicalize view
   end
 
-  def search_params
-    @search_params ||= begin
-      p = default_search_params.clone
+  def voo_items_view
+    return unless (voo && items = voo.items)
+    items[:view]
+  end
 
-      if focal?
-        p[:offset] = params[:offset] if params[:offset]
-        p[:limit]  = params[:limit]  if params[:limit]
-        p.merge! params[:wql]        if params[:wql]
-      end
-      p
-    end
+  def default_item_view
+    :name
   end
 
-  def default_search_params # wahh?
-    set_default_search_params
+  def item_view_options new_options={}
+    options = (voo.items || {}).clone
+    options = options.merge new_options
+    options[:view] ||= implicit_item_view
+    determine_item_view_options_type options
+    options
   end
 
-  def set_default_search_params overrides={}
-    @default_search_params ||= begin
-      p = { default_limit: 100 }.merge overrides
-      set_search_params_variables! p
-      p
-    end
+  def determine_item_view_options_type options
+    return if options[:type]
+    type_from_rule = card.item_type
+    options[:type] = type_from_rule if type_from_rule
   end
 
-  def set_search_params_variables! hash
-    hash[:vars] = params[:vars] || {}
-    params.each do |key, val|
-      case key.to_s
-      when "_wql"      then hash.merge! val
-      when /^\_(\w+)$/ then hash[:vars][Regexp.last_match(1).to_sym] = val
-      end
+  def nested_fields content=nil
+    result = []
+    each_nested_field(content) do |chunk|
+      result << [chunk.referee_name, chunk.options]
     end
+    result
   end
 
-  def each_reference_with_args args={}
-    content_object = Card::Content.new _render_raw(args), card
-    content_object.find_chunks(Card::Content::Chunk::Reference).each do |chunk|
-      yield chunk.referee_name.to_s, nest_args(args, chunk)
+  def nested_fields_for_edit
+    return normalized_edit_fields if edit_fields.present?
+    result = []
+    each_nested_field do |chunk|
+      result << [chunk.options[:nest_name], chunk.options]
     end
+    result
   end
 
-  def each_nested_chunk args={}
-    content_object = Card::Content.new(_render_raw(args), card)
-    content_object.find_chunks(Card::Content::Chunk::Include).each do |chunk|
-      yield(chunk) if chunk.referee_name # filter commented nests
-    end
+  def edit_fields
+    voo.edit_structure || []
   end
 
-  def nested_fields args={}
-    result = []
-    each_nested_field(args) do |chunk|
-      result << chunk
+  def normalized_edit_fields
+    edit_fields.map do |name, options|
+      options ||= Card.quick_fetch(name).name
+      options = { title: options } if options.is_a?(String)
+      [card.cardname.field(name), options]
     end
-    result
   end
 
-  def unique_chunks chunk, processed_set, &_block
-    return if processed_set.include? chunk.referee_name.key
-    processed_set << chunk.referee_name.key
-    yield(chunk)
+  def process_field chunk, processed, &_block
+    return unless process_unique_field? chunk, processed
+    yield chunk
   end
 
-  def each_nested_field args, &block
-    processed_chunk_keys = ::Set.new([card.key])
-
-    each_nested_chunk(args) do |chunk|
-      # TODO: handle structures that are non-virtual
+  def each_nested_field content=nil, &block
+    processed = ::Set.new [card.key]
+    content ||= _render_raw
+    card.each_nested_chunk content do |chunk|
       next unless chunk.referee_name.to_name.field_of? card.name
-      if chunk.referee_card &&
-         chunk.referee_card.virtual? &&
-         !processed_chunk_keys.include?(chunk.referee_name.key)
-
-        processed_chunk_keys << chunk.referee_name.key
-        subformat(chunk.referee_card).each_nested_field(args) do |sub_chunk|
-          unique_chunks sub_chunk, processed_chunk_keys, &block
-        end
-      else
-        unique_chunks chunk, processed_chunk_keys, &block
-      end
+      process_nested_chunk chunk, processed, &block
     end
   end
 
-  def map_references_with_args args={}, &_block
-    result = []
-    each_reference_with_args args do |name, n_args|
-      result << yield(name, n_args)
-    end
-    result
+  def process_nested_chunk chunk, processed, &block
+    virtual = chunk.referee_card && chunk.referee_card.virtual?
+    # TODO: handle structures that are non-virtual
+    method = virtual ? :process_virtual_field : :process_field
+    send method, chunk, processed, &block
   end
 
-  # process args for links and nests
-  def nest_args args, chunk=nil
-    r_args = item_args(args)
-    r_args.merge! @nest_opts.clone if @nest_opts
-
-    case chunk
-    when Card::Content::Chunk::Include
-      r_args.merge!(chunk.options)
-    when Card::Content::Chunk::Link
-      r_args.reverse_merge!(view: :link)
-      r_args.reverse_merge!(title: chunk.link_text) if chunk.link_text
+  def process_virtual_field chunk, processed, &block
+    return unless process_unique_field? chunk, processed
+    subformat(chunk.referee_card).each_nested_field do |sub_chunk|
+      process_field sub_chunk, processed, &block
     end
-    r_args
+  end
+
+  def process_unique_field? chunk, processed
+    key = chunk.referee_name.key
+    return false if processed.include? key
+    processed << key
+    true
   end
 end
 
@@ -255,52 +263,58 @@ format :html do
     card.item_names(args).size
   end
 
-  view :tabs do |args|
-    active_name = nil
-    active_content = nil
-    tabs = {}
-    each_reference_with_args(item: :content) do |name, nest_args|
-      tab_name = nest_args[:title] || name
-      tabs[tab_name] = nest_path(name, nest_args).html_safe
+  view :tabs do
+    construct_tabs "tabs"
+  end
 
-      active_name ||= tab_name
-      # warning: nest changes nest_args
-      active_content ||= nest(Card.fetch(name, new: {}), nest_args)
+  def construct_tabs tab_type
+    tabs = { active: {}, paths: {} }
+    voo.items[:view] ||= :content
+    card.each_item_name_with_options(_render_raw) do |name, options|
+      construct_tab tabs, name, options
     end
-    lazy_loading_tabs tabs, active_name, active_content,
-                      type: args[:tab_type]
+    lazy_loading_tabs tabs[:paths], tabs[:active][:name],
+                      tabs[:active][:content], type: tab_type
+  end
+
+  def construct_tab tabs, name, explicit_options
+    tab_options = item_view_options explicit_options
+    title = tab_title tab_options[:title], name
+    tabs[:paths][title] = { title: title,
+                            path: nest_path(name, tab_options).html_safe }
+    return unless tabs[:active].empty?
+    tabs[:active] = { name: title, content: nest(name, tab_options) }
   end
-  def default_tabs_args args
-    args[:tab_type] ||= "tabs"
+
+  def tab_title title, name
+    return name unless title
+    name.to_name.title title, @context_names
   end
 
   # create a path for a nest with respect ot the nest options
-  def nest_path name, nest_args
-    path_args = {}
-    path_args[:view] = nest_args[:view]
-    path_args[:slot] = nest_args.clone
-    path_args[:slot].delete(:view)
-    page_path(name, path_args)
+  def nest_path name, nest_opts={}
+    path_opts = { slot: nest_opts.clone }
+    path_opts[:view] = path_opts[:slot].delete :view
+    page_path name, path_opts
   end
 
-  view :pills, view: :tabs
-  def default_pills_args args
-    args[:tab_type] ||= "pills"
+  view :pills do
+    construct_tabs "pills"
   end
 
-  view :tabs_static do |args|
-    tabs = {}
-    card.item_cards.each do |item|
-      tabs[item.name] = nest item, item_args(args)
-    end
-    static_tabs tabs, args[:tab_type]
+  view :tabs_static do
+    construct_static_tabs "tabs"
   end
-  def default_tabs_static_args args
-    args[:tab_type] ||= "tabs"
+
+  view :pills_static do
+    construct_static_tabs "pills"
   end
 
-  view :pills_static, view: :tabs_static
-  def default_tabs_static_args args
-    args[:tab_type] ||= "pills"
+  def construct_static_tabs tab_type
+    tabs = {}
+    card.item_cards.each do |item|
+      tabs[item.name] = nest item, item_view_options(args)
+    end
+    static_tabs tabs, tab_type
   end
 end

data/mod/core/set/all/content.rb

@@ -46,6 +46,14 @@ def last_draft_content
   drafts.last.card_changes.last.value
 end
 
+event :set_content, :store, on: :save do
+  self.db_content = content || "" # necessary?
+  self.db_content = Card::Content.clean!(db_content) if clean_html?
+  @selected_action_id = @selected_content = nil
+  clear_drafts
+  reset_patterns_if_rule true
+end
+
 event :save_draft, :store,
       on: :update, when: proc { Env.params["draft"] == "true" } do
   save_content_draft content

data/mod/core/set/all/event.rb

@@ -25,8 +25,11 @@ def changed_condition_applies? db_columns
 end
 
 def when_condition_applies? block
-  return true unless block
-  block.call(self)
+  case block
+  when Proc then block.call(self)
+  when Symbol then send block
+  else true
+  end
 end
 
 def single_changed_condition_applies? db_column

data/mod/core/set/all/export.rb

@@ -6,7 +6,7 @@ format :json do
   end
 
   # export the card itself and all nested content (up to 10 levels deep)
-  view :export do |args|
+  view :export, cache: :never do |args|
     # avoid loops
     return [] if args[:count] > 10 || args[:processed_keys].include?(card.key)
     args[:processed_keys] << card.key
@@ -21,10 +21,10 @@ format :json do
   end
 
   # export all nested content (up to 10 levels deep)
-  view :export_items do |args|
+  view :export_items, cache: :never do |args|
     result = []
-    each_nested_chunk do |chunk|
-      next if main_nest? chunk
+    card.each_nested_chunk do |chunk|
+      next if nest_name_main? chunk
       next unless (r_card = chunk.referee_card)
       next if r_card.new? || r_card == card
       next if args[:processed_keys].include?(r_card.key)
@@ -35,8 +35,8 @@ format :json do
     result.flatten.reject(&:blank?)
   end
 
-  def main_nest? chunk
-    chunk.respond_to?(:options) && chunk.options && chunk.options[:inc_name] &&
-      chunk.options[:inc_name] == "_main"
+  def nest_name_main? chunk
+    chunk.respond_to?(:options) && chunk.options && chunk.options[:nest_name] &&
+      chunk.options[:nest_name] == "_main"
   end
 end

data/mod/core/set/all/fetch.rb

@@ -83,6 +83,14 @@ module ClassMethods
     end
   end
 
+  def fetch_name mark
+    if (card = quick_fetch(mark))
+      card.name
+    elsif block_given?
+      yield
+    end
+  end
+
   def quick_fetch mark
     fetch mark, skip_virtual: true, skip_modules: true
   end
@@ -183,6 +191,19 @@ module ClassMethods
     end
   end
 
+  def fetch_from_cast cast
+    fetch_args = cast[:id] ? [cast[:id].to_i] : [cast[:name], { new: cast }]
+    Card.fetch(*fetch_args)
+  end
+
+  def cardish cardish
+    if cardish.is_a? Card
+      cardish
+    else
+      fetch cardish, new: {}
+    end
+  end
+
   def deep_opts args
     opts = (args[:card] || {}).clone
     # clone so that original params remain unaltered.  need deeper clone?
@@ -209,7 +230,8 @@ module ClassMethods
     opts[:skip_virtual] || opts[:new].present? || opts[:skip_type_lookup]
   end
 
-  def compose_mark parts, opts
+  def compose_mark parts, opts={}
+    parts.flatten!
     return normalize_mark(parts.first, opts) if parts.size == 1
     parts.map do |p|
       normalized = normalize_mark p, {}
@@ -224,21 +246,33 @@ module ClassMethods
 
   def normalize_mark mark, opts
     case mark
-    when Symbol  then Card::Codename[mark]
-    when Integer then mark.to_i
-    when Card    then mark.cardname
-    when String, SmartName
+    when Symbol            then require_id_for_codename mark
+    when Integer           then mark.to_i
+    when Card              then mark.cardname
+    when String, SmartName then normalize_stringy_mark mark, opts
       # there are some situations where this breaks if we use Card::Name
       # rather than SmartName, which would seem more correct.
       # very hard to reproduce, not captured in a spec :(
-      case mark.to_s
-      when /^\~(\d+)$/ then $1.to_i                   # id
-      when /^\:(\w+)$/ then Card::Codename[$1.to_sym] # codename
-      else fullname_from_mark mark, opts[:new]        # name
-      end
     end
   end
 
+  def normalize_stringy_mark mark, opts
+    case mark.to_s
+    when /^\~(\d+)$/  # id, eg "~75"
+      Regexp.last_match[1].to_i
+    when /^\:(\w+)$/  # codename, eg ":options"
+      require_id_for_codename(Regexp.last_match[1].to_sym)
+    else
+      fullname_from_mark mark, opts[:new]
+    end
+  end
+
+  def require_id_for_codename mark
+    id = Card::Codename[mark]
+    raise Card::Error::NotFound, "missing card with codename: #{mark}" unless id
+    id
+  end
+
   def fullname_from_mark name, new_opts={}
     if new_opts && (supercard = new_opts[:supercard])
       name.to_name.to_absolute_name supercard.name
@@ -283,30 +317,60 @@ def expire_pieces
   end
 end
 
-def expire_hard
+def expire cache_type=nil
+  return unless (cache_class = cache_class_from_type cache_type)
+  expire_views
+  expire_names cache_class
+  expire_id cache_class
+end
+
+def cache_class_from_type cache_type
+  cache_type ? Card.cache.send(cache_type) : Card.cache
+end
+
+def register_view_cache_key cache_key
+  @view_cache_keys ||= []
+  @view_cache_keys << cache_key
+  @view_cache_keys.uniq!
+  hard_write_view_cache_keys
+end
+
+def hard_write_view_cache_keys
   return unless Card.cache.hard
-  Card.cache.hard.delete key
-  Card.cache.hard.delete "~#{id}" if id
+  Card.cache.hard.write_attribute key, :view_cache_keys, @view_cache_keys
 end
 
-def expire_soft
-  Card.cache.soft.delete key
-  Card.cache.soft.delete "~#{id}" if id
+def expire_views
+  return unless @view_cache_keys
+  Array.wrap(@view_cache_keys).each do |view_cache_key|
+    Card::View.cache.delete view_cache_key
+  end
+  @view_cache_keys = nil
+end
+
+def expire_names cache
+  [name, name_was].each do |name_version|
+    expire_name name_version, cache
+  end
 end
 
-def expire
-  expire_hard
-  expire_soft
+def expire_name name_version, cache
+  return unless name_version.present?
+  key_version = name_version.to_name.key
+  return unless key_version.present?
+  cache.delete key_version
+end
+
+def expire_id cache
+  return unless id.present?
+  cache.delete "~#{id}"
 end
 
 def refresh force=false
-  if force || frozen? || readonly?
-    fresh_card = self.class.find id
-    fresh_card.include_set_modules
-    fresh_card
-  else
-    self
-  end
+  return self unless force || frozen? || readonly?
+  fresh_card = self.class.find id
+  fresh_card.include_set_modules
+  fresh_card
 end
 
 def eager_renew? opts