card 1.16.15 → 1.17.0

data/tmpsets/set/mod001-01_core/all/content.rb

@@ -4,10 +4,10 @@ class Card; module Set; module All; module Content; extend Card::Set
 ::Card.error_codes[:conflict] = [:conflict, 409]
 
 def content
-  db_content or (new_card? && template.db_content)
+  db_content || (new_card? && template.db_content)
 end
 
-def content=(value)
+def content= value
   self.db_content = value
 end
 
@@ -16,7 +16,7 @@ def raw_content
 end
 
 format do
-  def chunk_list #override to customize by set
+  def chunk_list # override to customize by set
     :default
   end
 end
@@ -26,37 +26,36 @@ def label
 end
 
 def creator
-  Card[ creator_id ]
+  Card[creator_id]
 end
 
 def updater
-  Card[ updater_id ]
+  Card[updater_id]
 end
 
 def clean_html?
   true
 end
 
-def history?
-  false
-end
-
-def save_content_draft content
+def save_content_draft _content
   clear_drafts
 end
 
 def clear_drafts
-  drafts.created_by(Card::Auth.current_id).each do |draft|
-    draft.delete
-  end
+  drafts.created_by(Card::Auth.current_id).each(&:delete)
 end
 
-event :save_draft, before: :store, on: :update, when: proc{ |c| Env.params['draft'] == 'true' } do
+def last_draft_content
+  drafts.last.card_changes.last.value
+end
+
+event :save_draft,
+      before: :store, on: :update,
+      when: proc { Env.params['draft'] == 'true' } do
   save_content_draft content
   abort :success
 end
 
-
 event :set_default_content, on: :create, before: :approve do
   if !db_content_changed? && template && template.db_content.present?
     self.db_content = template.db_content
@@ -64,6 +63,5 @@ event :set_default_content, on: :create, before: :approve do
 end
 
 
-
 # ~~~~~~~~~~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/content.rb ~~~~~~~~~~~
 end;end;end;end;

data/tmpsets/set/mod001-01_core/all/fetch.rb

@@ -3,10 +3,9 @@ class Card; module Set; module All; module Fetch; extend Card::Set
 # ~~~~~~~~~~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/fetch.rb ~~~~~~~~~~~
 # = Card#fetch
 #
-# A multipurpose retrieval operator that incorporates caching, "virtual" card retrieval
-
+# A multipurpose retrieval operator that integrates caching, database lookups,
+# and "virtual" card construction
 module ClassMethods
-
   # === fetch
   #
   # looks for cards in
@@ -26,49 +25,44 @@ module ClassMethods
   #     :local_only                 Use only local cache for lookup and storing
   #     new: {  card opts }      Return a new card when not found
   #
-  def fetch mark, opts = {}
+  def fetch mark, opts={}
     validate_fetch_opts! opts
-    mark = normalize_mark mark
+    mark = normalize_mark mark, opts
 
-    if mark.present?
-      card, mark, needs_caching = fetch_from_cache_or_db mark, opts
-    else
-      return unless opts[:new]
-    end
+    card, needs_caching = fetch_existing mark, opts
 
-    if mark.is_a?(Integer)
-      return if card.nil?
-    elsif card && card.new_card? && opts[:new].present?
-      return card.renew(opts)
-    elsif !card || (card.type_unknown? && !skip_type_lookup?(opts))
+    if (new_card = new_for_cache card, mark, opts)
+      card = new_card
       needs_caching = true
-      card = new_for_cache mark, opts # new (or improved) card for cache
     end
 
+    return if card.nil?
     write_to_cache card, opts if needs_caching
+    standard_fetch_results card, mark, opts
+  end
 
+  def standard_fetch_results card, mark, opts
     if card.new_card?
       case
       when opts[:new].present? then return card.renew(opts)
       when opts[:new] # noop for empty hash
       when opts[:skip_virtual] then return nil
       end
-      card.rename_from_mark mark unless opts[:local_only]
+      card.name_from_mark! mark, opts
     end
     # need to load modules here to call the right virtual? method
     card.include_set_modules unless opts[:skip_modules]
     card if opts[:new] || card.known?
   end
 
-  def fetch_local mark, opts = {}
-    fetch mark, opts.merge(:local_only=>true)
+  def fetch_soft mark, opts={}
+    fetch mark, opts.merge(local_only: true)
   end
 
-  def fetch_id mark
+  def fetch_id mark, opts={}
+    mark = normalize_mark mark, opts
     if mark.is_a?(Integer)
       mark
-    elsif mark.is_a?(Symbol) && Card::Codename[mark]
-      Card::Codename[mark]
     else
       card = quick_fetch mark.to_s
       card && card.id
@@ -79,7 +73,7 @@ module ClassMethods
     fetch mark, skip_virtual: true, skip_modules: true
   end
 
-  def assign_or_initialize_by name, attributes, fetch_opts = {}
+  def assign_or_initialize_by name, attributes, fetch_opts={}
     if (known_card = Card.fetch(name, fetch_opts))
       known_card.refresh.assign_attributes attributes
       known_card
@@ -102,24 +96,31 @@ module ClassMethods
     card.present?
   end
 
-  def expire name, subcards = false
+  def expire_hard name
+    return unless Card.cache.hard
+    key = name.to_name.key
+    Card.cache.hard.delete key
+    Card.cache.hard.delete "~#{card.id}" if card.id
+  end
+
+  def expire name, subcards=false
     # note: calling instance method breaks on dirty names
     key = name.to_name.key
-    if card = Card.cache.read(key)
-      if subcards
-        card.expire_subcards
-      else
-        card.preserve_subcards
-      end
-      Card.cache.delete key
-      Card.cache.delete "~#{card.id}" if card.id
+    return unless (card = Card.cache.read key)
+    if subcards
+      card.expire_subcards
+    else
+      card.preserve_subcards
     end
-    # Rails.logger.warn "expiring #{name}, #{card.inspect}"
+    Card.cache.delete key
+    Card.cache.delete "~#{card.id}" if card.id
   end
 
   # set_names reverse map (cached)
-  def members key
-    (v=Card.cache.read "$#{key}").nil? ? [] : v.keys
+  # FIXME: move to set handling
+  def cached_set_members key
+    set_cache_list = Card.cache.read "$#{key}"
+    set_cache_list.nil? ? [] : set_cache_list.keys
   end
 
   def set_members set_names, key
@@ -138,9 +139,8 @@ module ClassMethods
   end
 
   def validate_fetch_opts! opts
-    if opts[:new] && opts[:skip_virtual]
-      fail Card::Error, 'fetch called with new args and skip_virtual'
-    end
+    return unless opts[:new] && opts[:skip_virtual]
+    fail Card::Error, 'fetch called with new args and skip_virtual'
   end
 
   def cache
@@ -148,48 +148,65 @@ module ClassMethods
   end
 
   def fetch_from_cache cache_key, local_only=false
-    if Card.cache
-      if local_only
-        Card.cache.read_local cache_key
-      else
-        Card.cache.read cache_key
-      end
+    return unless Card.cache
+    if local_only
+      Card.cache.soft.read cache_key
+    else
+      Card.cache.read cache_key
+    end
+  end
+
+  def parse_mark! mark
+    # return mark_type, mark_value, and absolutized mark
+    if mark.is_a? Integer
+      [:id, mark]
+    else
+      [:key, mark.key]
     end
   end
 
-  def fetch_from_cache_or_db mark, opts
-    needs_caching = false
-    mark_type = mark.is_a?(Integer) ? :id : :key
-    expanded_mark = expand_mark mark, opts
-    card = send("fetch_from_cache_by_#{mark_type}",
-                expanded_mark, opts[:local_only])
+  def fetch_existing mark, opts
+    return [nil, false] unless mark.present?
+    mark_type, mark_key = parse_mark! mark
+    needs_caching = false # until proven true :)
 
-    if card.nil? || (opts[:look_in_trash] && card.new_card? && !card.trash)
-      query = { mark_type => expanded_mark }
-      query[:trash] = false unless opts[:look_in_trash]
-      card = fetch_from_db query
-      needs_caching = card && !card.trash
-      card.restore_subcards if card
+    # look in cache
+    card = send "fetch_from_cache_by_#{mark_type}", mark_key, opts[:local_only]
+
+    if retrieve_from_db?(card, opts)
+      # look in db if needed
+      card = fetch_from_db mark_type, mark_key, opts
+      needs_caching = !card.nil? && !card.trash
     end
 
-    [card, mark, needs_caching]
+    [card, needs_caching]
   end
 
-  def fetch_from_cache_by_id id, local_only = false
-    if name = fetch_from_cache("~#{id}", local_only)
-      fetch_from_cache name, local_only
-    end
+  def retrieve_from_db? card, opts
+    card.nil? || (opts[:look_in_trash] && card.new_card? && !card.trash)
   end
 
-  def fetch_from_cache_by_key key, local_only = false
+  def fetch_from_cache_by_id id, local_only=false
+    name = fetch_from_cache "~#{id}", local_only
+    fetch_from_cache name, local_only if name
+  end
+
+  def fetch_from_cache_by_key key, local_only=false
     fetch_from_cache key, local_only
   end
 
-  def fetch_from_db query
-    Card.where(query).take
+  def fetch_from_db mark_type, mark_key, opts
+    query = { mark_type => mark_key }
+    query[:trash] = false unless opts[:look_in_trash]
+    card = Card.where(query).take
+    card.restore_subcards if card
+    card
   end
 
-  def new_for_cache name, opts
+  def new_for_cache card, name, opts
+    return if name.is_a? Integer
+    return if !name.present? && !opts[:new]
+    return unless !card || (card.type_unknown? && !skip_type_lookup?(opts))
     new name: name,
         skip_modules: true,
         skip_type_lookup: skip_type_lookup?(opts)
@@ -200,53 +217,42 @@ module ClassMethods
     # different from the cached variant
     # and can postpone type lookup for the cached variant
     # if skipping virtual no need to look for actual type
-    opts[:skip_virtual] || opts[:new].present?
+    opts[:skip_virtual] || opts[:new].present? || opts[:skip_type_lookup]
   end
 
   def write_to_cache card, opts
     if opts[:local_only]
-      write_to_local_cache card
+      write_to_soft_cache card
     elsif Card.cache
       Card.cache.write card.key, card
       Card.cache.write "~#{card.id}", card.key if card.id && card.id != 0
     end
   end
 
-  def write_to_local_cache card
-    if Card.cache
-      Card.cache.write_local card.key, card
-      Card.cache.write_local "~#{card.id}", card.key if card.id && card.id != 0
-    end
-  end
-
-  def expand_mark mark, opts
-    if mark.is_a?(Integer)
-      mark
-    else
-      fullname_from_name(mark, opts[:new]).key
-    end
+  def write_to_soft_cache card
+    return unless Card.cache
+    Card.cache.soft.write card.key, card
+    Card.cache.soft.write "~#{card.id}", card.key if card.id && card.id != 0
   end
 
-  def normalize_mark mark
+  def normalize_mark mark, opts
     case mark
-    when String
-      case mark
-      when /^\~(\d+)$/ # get by id
-        $1.to_i
-      when /^\:(\w+)$/ # get by codename
-        Card::Codename[$1.to_sym]
-      else
-        mark
+    when Symbol        then Card::Codename[mark]
+    when Integer       then mark.to_i
+    when String, SmartName
+      # 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
-    when Symbol
-      Card::Codename[mark] # id from codename
-    else
-      mark
     end
   end
 
-  def fullname_from_name name, new_opts = {}
-    if new_opts && supercard = new_opts[:supercard]
+  def fullname_from_mark name, new_opts={}
+    if new_opts && (supercard = new_opts[:supercard])
       name.to_name.to_absolute_name supercard.name
     else
       name.to_name
@@ -256,41 +262,62 @@ end
 
 # ~~~~~~~~~~ Instance ~~~~~~~~~~~~~
 
-def fetch opts = {}
-  if traits = opts.delete(:trait)
-    traits = Array.wrap traits
-    traits.inject(self) do |card, trait|
-      Card.fetch card.cardname.trait(trait), opts
-    end
+def fetch opts={}
+  traits = opts.delete(:trait)
+  return unless traits
+  # should this fail as an incorrect api call?
+  traits = Array.wrap traits
+  traits.inject(self) do |card, trait|
+    Card.fetch card.cardname.trait(trait), opts
   end
 end
 
-def renew args = {}
+def renew args={}
   opts = args[:new].clone
+  handle_default_content opts
   opts[:name] ||= cardname
   opts[:skip_modules] = args[:skip_modules]
   Card.new opts
 end
 
+def handle_default_content opts
+  if (default_content = opts.delete(:default_content)) && db_content.blank?
+    opts[:content] ||= default_content
+  elsif db_content.present? && !opts[:content]
+    # don't overwrite existing content
+    opts[:content] = db_content
+  end
+end
+
 def expire_pieces
   cardname.piece_names.each do |piece|
     Card.expire piece, !cardname.field_of?(piece)
   end
 end
 
-def expire subcards = false
-  # Rails.logger.warn "expiring i:#{id}, #{inspect}"
+def expire_hard
+  return unless Card.cache.hard
+  Card.cache.hard.delete key
+  Card.cache.hard.delete "~#{id}" if id
+end
+
+def expire_soft subcards=false
   if subcards
     expire_subcards
   else
     preserve_subcards
   end
-  Card.cache.delete key
-  Card.cache.delete "~#{id}" if id
+  Card.cache.soft.delete key
+  Card.cache.soft.delete "~#{id}" if id
 end
 
-def refresh force = false
-  if force || self.frozen? || self.readonly?
+def expire subcards=false
+  expire_hard
+  expire_soft subcards
+end
+
+def refresh force=false
+  if force || frozen? || readonly?
     fresh_card = self.class.find id
     fresh_card.include_set_modules
     fresh_card
@@ -307,12 +334,12 @@ def type_unknown?
   type_id.nil?
 end
 
-def rename_from_mark mark
+def name_from_mark! mark, opts
+  return if opts[:local_only]
   return unless mark && mark.to_s != name
   self.name = mark.to_s
 end
 
 
-
 # ~~~~~~~~~~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/fetch.rb ~~~~~~~~~~~
 end;end;end;end;