card 1.99.6 → 1.100.0

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

@@ -1,69 +0,0 @@
-# -*- 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/mod002-core/all/erb.rb

@@ -1,18 +0,0 @@
-# -*- 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/mod002-core/all/event.rb

@@ -1,62 +0,0 @@
-# -*- 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/mod002-core/all/export.rb

@@ -1,49 +0,0 @@
-# -*- 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

@@ -1,335 +0,0 @@
-# -*- 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;