card 1.91 → 1.92

data/tmpsets/set/mod002-core/all/export.rb

@@ -0,0 +1,49 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Export; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/export.rb ~~
+format :json do
+  def default_export_args args
+    args[:count] ||= 0
+    args[:count] += 1
+    args[:processed_keys] ||= ::Set.new
+  end
+
+  # export the card itself and all nested content (up to 10 levels deep)
+  view :export do |args|
+    # avoid loops
+    return [] if args[:count] > 10 || args[:processed_keys].include?(card.key)
+    args[:processed_keys] << card.key
+
+    Array.wrap(render_atom(args)).concat(
+      render_export_items(count: args[:count])
+    )
+  end
+
+  def default_export_items_args args
+    args[:processed_keys] ||= ::Set.new
+  end
+
+  # export all nested content (up to 10 levels deep)
+  view :export_items do |args|
+    result = []
+    each_nested_chunk do |chunk|
+      next if main_nest? 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)
+      result << r_card
+    end
+    result.uniq!
+    result.map! { |ca| subformat(ca).render_export(args) }
+    result.flatten.reject(&:blank?)
+  end
+
+  def main_nest? chunk
+    chunk.respond_to?(:options) && chunk.options && chunk.options[:inc_name] &&
+      chunk.options[:inc_name] == "_main"
+  end
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/export.rb ~~
+end;end;end;end;

data/tmpsets/set/mod002-core/all/fetch.rb

@@ -0,0 +1,335 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Fetch; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/fetch.rb ~~
+# = Card#fetch
+#
+# A multipurpose retrieval operator that integrates caching, database lookups,
+# and "virtual" card construction
+module ClassMethods
+  # Look for cards in
+  # * cache
+  # * database
+  # * virtual cards
+  #
+  # @param mark [Integer, String, Card::Name, Symbol, Array]
+  #    one of three unique identifiers
+  #    1. a numeric id (Integer)
+  #    2. a name/key (String or Card::Name)
+  #    3. a codename (Symbol)
+  #    or any combination of those. If you pass more then one mark they get
+  #    joined with a '+'
+  # @param options [Hash]
+  #   Options:
+  #     :skip_virtual               Real cards only
+  #     :skip_modules               Don't load Set modules
+  #     :look_in_trash              Return trashed card objects
+  #     :local_only                 Use only local cache for lookup and storing
+  #     new: { opts for Card#new }  Return a new card when not found
+  #
+  # @return [Card]
+  def fetch *args
+    mark, opts = normalize_fetch_args args
+    validate_fetch_opts! opts
+    card, needs_caching = fetch_existing mark, opts
+
+    if (new_card = new_for_cache card, mark, opts)
+      card = new_card
+      needs_caching = true
+    end
+
+    return if card.nil?
+    write_to_cache card, opts if needs_caching
+    standard_fetch_results card, mark, opts
+  end
+
+  # #fetch converts String to Card::Name. That can break in some cases.
+  # For example if you fetch "Siemens" by its key "siemen", you won't get
+  # "Siemens" because "siemen".to_name.key == "sieman"
+  # If you have a key of a real card use this method.
+  def fetch_real_by_key key, opts={}
+    raise Card::Error, "fetch_real_by_key called with new args" if opts[:new]
+
+    # look in cache
+    card = fetch_from_cache_by_key key, opts[:local_only]
+    # look in db if needed
+    if retrieve_from_db?(card, opts)
+      card = fetch_from_db :key, key, opts
+      write_to_cache card, opts if !card.nil? && !card.trash
+    end
+    return if card.nil?
+    card.include_set_modules unless opts[:skip_modules]
+    card
+  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.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_soft mark, opts={}
+    fetch mark, opts.merge(local_only: true)
+  end
+
+  def fetch_id *args
+    mark, _opts = normalize_fetch_args args
+    if mark.is_a?(Integer)
+      mark
+    else
+      card = quick_fetch mark.to_s
+      card && card.id
+    end
+  end
+
+  def quick_fetch mark
+    fetch mark, skip_virtual: true, skip_modules: true
+  end
+
+  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
+    else
+      Card.new attributes.merge(name: name)
+    end
+  end
+
+  def [] *marks
+    fetch(*marks, skip_virtual: true)
+  end
+
+  def exists? mark
+    card = quick_fetch mark
+    card.present?
+  end
+
+  def known? mark
+    card = fetch mark, skip_modules: true
+    card.present?
+  end
+
+  def validate_fetch_opts! opts
+    return unless opts[:new] && opts[:skip_virtual]
+    raise Card::Error, "fetch called with new args and skip_virtual"
+  end
+
+  def fetch_from_cache cache_key, local_only=false
+    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_existing mark, opts
+    return [nil, false] unless mark.present?
+    mark_type, mark_key = parse_mark! mark
+    needs_caching = false # until proven true :)
+
+    # 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, needs_caching]
+  end
+
+  def retrieve_from_db? card, opts
+    card.nil? || (opts[:look_in_trash] && card.new_card? && !card.trash)
+  end
+
+  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 mark_type, mark_key, opts
+    query = { mark_type => mark_key }
+    query[:trash] = false unless opts[:look_in_trash]
+    card = Card.where(query).take
+    card
+  end
+
+  def deep_fetch args
+    opts = deep_opts args
+    if args[:action] == "create"
+      # FIXME: we currently need a "new" card to catch duplicates
+      # (otherwise save will just act like a normal update)
+      # We may need a "#create" instance method to handle this checking?
+      Card.new opts
+    else
+      mark = args[:id] || opts[:name]
+      Card.fetch mark, new: opts
+    end
+  end
+
+  def deep_opts args
+    opts = (args[:card] || {}).clone
+    # clone so that original params remain unaltered.  need deeper clone?
+    opts[:type] ||= args[:type] if args[:type]
+    # for /new/:type shortcut.  we should fix and deprecate this.
+    opts[:name] ||= args[:id].to_s.tr("_", " ")
+    # move handling to Card::Name?
+    opts
+  end
+
+  def new_for_cache card, name, opts
+    return if name.is_a? Integer
+    return if name.blank? && !opts[:new]
+    return if card && (card.type_known? || skip_type_lookup?(opts))
+    new name: name,
+        skip_modules: true,
+        skip_type_lookup: skip_type_lookup?(opts)
+  end
+
+  def skip_type_lookup? opts
+    # if opts[:new] is not empty then we are initializing a variant that is
+    # 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_type_lookup]
+  end
+
+  def compose_mark parts, opts
+    return normalize_mark(parts.first, opts) if parts.size == 1
+    parts.map do |p|
+      normalized = normalize_mark p, {}
+      normalized.is_a?(Integer) ? quick_fetch(normalized).name : normalized.to_s
+    end.join("+").to_name
+  end
+
+  def normalize_fetch_args args
+    opts = args.last.is_a?(Hash) ? args.pop : {}
+    [compose_mark(args, opts), opts]
+  end
+
+  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
+      # 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 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
+    end
+  end
+end
+
+# ~~~~~~~~~~ Instance ~~~~~~~~~~~~~
+
+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={}
+  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
+  end
+end
+
+def expire_hard
+  return unless Card.cache.hard
+  Card.cache.hard.delete key
+  Card.cache.hard.delete "~#{id}" if id
+end
+
+def expire_soft
+  Card.cache.soft.delete key
+  Card.cache.soft.delete "~#{id}" if id
+end
+
+def expire
+  expire_hard
+  expire_soft
+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
+end
+
+def eager_renew? opts
+  opts[:skip_virtual] && new_card? && opts[:new].present?
+end
+
+def type_known?
+  type_id.present?
+end
+
+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/core/set/all/fetch.rb ~~
+end;end;end;end;

data/tmpsets/set/mod002-core/all/haml.rb

@@ -0,0 +1,14 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Haml; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/haml.rb ~~
+format do
+  def render_haml locals={}, template=nil, a_binding=nil, &block
+    template ||= yield
+    a_binding ||= binding
+    ::Haml::Engine.new(template).render(a_binding, locals)
+  end
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/haml.rb ~~
+end;end;end;end;

data/tmpsets/set/mod002-core/all/initialize.rb

@@ -0,0 +1,42 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Initialize; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/initialize.rb ~~
+JUNK_INIT_ARGS = %w(missing skip_virtual id).freeze
+
+module ClassMethods
+  def new args={}, _options={}
+    args = (args || {}).stringify_keys
+    JUNK_INIT_ARGS.each { |a| args.delete(a) }
+    %w(type type_code).each { |k| args.delete(k) if args[k].blank? }
+    args.delete("content") if args["attach"] # should not be handled here!
+    super args
+  end
+end
+
+def initialize args={}
+  args["name"] = args["name"].to_s
+  args["db_content"] = args.delete("content") if args["content"]
+  @supercard = args.delete "supercard" # must come before name =
+  skip_modules = args.delete "skip_modules"
+  skip_type_lookup = args["skip_type_lookup"]
+
+  super args # ActiveRecord #initialize
+  self.type_id = get_type_id_from_structure if !type_id && !skip_type_lookup
+  include_set_modules unless skip_modules
+  self
+end
+
+def include_set_modules
+  unless @set_mods_loaded
+    set_modules.each do |m|
+      singleton_class.send :include, m
+    end
+    assign_set_specific_attributes
+    @set_mods_loaded = true
+  end
+  self
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/initialize.rb ~~
+end;end;end;end;

data/tmpsets/set/mod002-core/all/location_history.rb

@@ -0,0 +1,15 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module LocationHistory; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/location_history.rb ~~
+event :discard_deleted_locations, in: :finalize, on: :delete do
+  Env.discard_locations_for self
+  success.target = :previous if success.target == self
+end
+
+event :save_current_location, before: :show_page, on: :read do
+  Env.save_location self
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/location_history.rb ~~
+end;end;end;end;