card 1.18.6 → 1.19.0

data/tmpsets/set/mod001-core/all/content.rb

@@ -0,0 +1,69 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Content; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/content.rb ~~
+::Card.error_codes[:conflict] = [:conflict, 409]
+
+def content
+  db_content || (new_card? && template.db_content)
+end
+
+def content= value
+  self.db_content = value
+end
+
+def raw_content
+  structure ? template.db_content : content
+end
+
+format do
+  def chunk_list # override to customize by set
+    :default
+  end
+end
+
+def label
+  name
+end
+
+def creator
+  Card[creator_id]
+end
+
+def updater
+  Card[updater_id]
+end
+
+def clean_html?
+  true
+end
+
+def save_content_draft _content
+  clear_drafts
+end
+
+def clear_drafts
+  drafts.created_by(Card::Auth.current_id).each(&:delete)
+end
+
+def last_draft_content
+  drafts.last.card_changes.last.value
+end
+
+event :save_draft, :store,
+      on: :update, when: proc { Env.params["draft"] == "true" } do
+  save_content_draft content
+  abort :success
+end
+
+event :set_default_content, :prepare_to_validate,
+      on: :create, when: proc { |c| c.use_default_content? } do
+  self.db_content = template.db_content
+end
+
+def use_default_content?
+  !db_content_changed? && template && template.db_content.present?
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/content.rb ~~
+end;end;end;end;

data/tmpsets/set/mod001-core/all/erb.rb

@@ -0,0 +1,18 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Erb; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/erb.rb ~~
+format do
+  def render_erb locals={}, template=nil, a_binding=nil, &block
+    template ||= yield
+    a_binding ||= binding
+    locals.each do |k, v|
+      # a_binding.local_variable_set(k, v) # needs ruby 2.1
+      instance_variable_set("@#{k}", v)
+    end
+    ERB.new(template, nil, "-").result(binding)
+  end
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/erb.rb ~~
+end;end;end;end;

data/tmpsets/set/mod001-core/all/event.rb

@@ -0,0 +1,62 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Event; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/event.rb ~~
+EVENT_CONDITIONS = [:set, :on, :changed, :when].freeze
+
+def event_applies? opts
+  EVENT_CONDITIONS.all? do |key|
+    send "#{key}_condition_applies?", opts[key]
+  end
+end
+
+private
+
+def set_condition_applies? set_module
+  singleton_class.include?(set_module)
+end
+
+def on_condition_applies? actions
+  actions = Array(actions).compact
+  return true if actions.empty?
+  actions.include? @action
+end
+
+def changed_condition_applies? db_columns
+  db_columns = Array(db_columns).compact
+  return true if db_columns.empty?
+  db_columns.any? { |col| single_changed_condition_applies? col }
+end
+
+def when_condition_applies? block
+  return true unless block
+  block.call(self)
+end
+
+def single_changed_condition_applies? db_column
+  return true unless db_column
+  db_column =
+    case db_column.to_sym
+    when :content then "db_content"
+    when :type    then "type_id"
+    else db_column.to_s
+    end
+  @action != :delete && changes[db_column]
+end
+
+def wrong_stage opts
+  return false if director.stage_ok? opts
+  if !stage
+    "phase method #{method} called outside of event phases"
+  else
+    "#{opts.inspect} method #{method} called in stage #{stage}"
+  end
+end
+
+def wrong_action action
+  return false if on_condition_applies? action
+  "on: #{action} method #{method} called on #{@action}"
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/event.rb ~~
+end;end;end;end;

data/tmpsets/set/mod001-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/mod001-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;