card 1.97.0.1 → 1.98.0

data/tmpsets/set/mod003-core/all/contextual_content.rb

@@ -0,0 +1,37 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (ContextualContent)
+#
+module ContextualContent;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/contextual_content.rb"; end
+def context_card
+  @context_card || self
+end
+
+def with_context context_card
+  old_context = @context_card
+  @context_card = context_card if context_card
+  yield
+ensure
+  @context_card = old_context
+end
+
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  def context_card
+    card.context_card
+  end
+
+  def with_context context_card
+    card.with_context context_card do
+      yield
+    end
+  end
+
+  def contextual_content context_card, options={}
+    view = options.delete(:view) || :core
+    with_context(context_card) { render! view, options }
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/contextual_content.rb ~~

data/tmpsets/set/{mod002-core → mod003-core}/all/debug.rb

@@ -1,6 +1,10 @@
 # -*- encoding : utf-8 -*-
-class Card; module Set; class All; module Debug; extend Card::Set
-# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/debug.rb ~~
+class Card; module Set; class All
+# Set: All cards (Debug)
+#
+module Debug;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/debug.rb"; end
 def to_s
   "#<#{self.class.name}[#{debug_type}]#{attributes['name']}>"
 end
@@ -24,7 +28,5 @@ private
 def debug_type
   "#{type_code || ''}:#{type_id}"
 end
-
-
-# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/debug.rb ~~
 end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/debug.rb ~~

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

@@ -0,0 +1,20 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Erb)
+#
+module Erb;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/erb.rb"; end
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  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
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/erb.rb ~~

data/tmpsets/set/mod003-core/all/event_conditions.rb

@@ -0,0 +1,142 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (EventConditions)
+#
+module EventConditions;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/event_conditions.rb"; end
+def event_applies? event
+  return unless set_condition_applies? event.set_module, event.opts.key?(:changing)
+
+  Card::Set::Event::CONDITIONS.all? do |key|
+    send "#{key}_condition_applies?", event, event.opts[key]
+  end
+end
+
+private
+
+# existing card is being changed in a way that alters its sets
+def updating_sets?
+  @action == :update && real? && (type_id_is_changing? || name_is_changing?)
+end
+
+def set_condition_applies? set_module, old_sets
+  return true if set_module == Card
+  set_condition_card(old_sets).singleton_class.include? set_module
+end
+
+def on_condition_applies? _event, actions
+  actions = Array(actions).compact
+  return true if actions.empty?
+  actions.include? @action
+end
+
+# if changing name/type, the old card has no-longer-applicable set modules, so we create
+# a new card to determine whether events apply.
+# (note: cached condition card would ideally be cleared after all
+# conditions are reviewed)
+# @param old_sets [True/False] whether to use the old_sets
+def set_condition_card old_sets
+  return self if old_sets || no_current_action?
+  @set_condition_card ||=
+    updating_sets? ? set_condition_card_with_new_set_modules : self
+end
+
+# prevents locking in set_condition_card
+def no_current_action?
+  return false if @current_action
+
+  @set_condition_card = nil
+  true
+end
+
+def set_condition_card_with_new_set_modules
+  cc = Card.find id
+  cc.name = name
+  cc.type_id = type_id
+  cc.include_set_modules
+end
+
+def changed_condition_applies? _event, db_columns
+  return true unless @action == :update
+  db_columns = Array(db_columns).compact
+  return true if db_columns.empty?
+  db_columns.any? { |col| single_changed_condition_applies? col }
+end
+alias_method :changing_condition_applies?, :changed_condition_applies?
+
+def when_condition_applies? _event, block
+  case block
+  when Proc then block.call(self)
+  when Symbol then send block
+  else true
+  end
+end
+
+def skip_condition_applies? event, allowed
+  return true if skip_events.empty?
+  event = event.name.to_s
+  !(standard_skip_event?(event, allowed) || force_skip_event?(event))
+end
+
+def trigger_condition_applies? event, required
+  return true unless required == :required
+  trigger_event? event
+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
+  attribute_is_changing?(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?(nil, action)
+  "on: #{action} method #{method} called on #{@action}"
+end
+
+def standard_skip_event? event, allowed
+  return false unless allowed == :allowed
+  skip_events.include? event
+end
+
+def force_skip_event? event
+  forced_skip_events.include? event
+end
+
+def forced_skip_events
+  @forced_skip_events ||= ::Set.new(skip_events.find_all { |e| e.last == "!" })
+end
+
+def skip_events
+  @skip_events ||= begin
+    events = Array.wrap(skip_event_in_action) + Array.wrap(act_card.skip_event)
+    ::Set.new events.map(&:to_s)
+  end
+end
+
+def trigger_event? event
+  @names_of_triggered_events ||= triggered_events
+  @names_of_triggered_events.include? event.name
+end
+
+def triggered_events
+  events = Array.wrap(trigger_event_in_action) + Array.wrap(act_card.trigger_event)
+  ::Set.new events.map(&:to_sym)
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/event_conditions.rb ~~

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

@@ -0,0 +1,77 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Export)
+#
+module Export;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/export.rb"; end
+module JsonFormat; parent.send :register_set_format, Card::Format::JsonFormat, self; extend Card::Set::AbstractFormat
+  # returns an array of Hashes (each in export_item view)
+  view :export, cache: :never do
+    exporting_uniques do
+      Array.wrap(render_export_item).concat(export_items_in_view(:export)).flatten
+    end
+  end
+
+  def max_export_depth
+    Env.params[:max_export_depth].present? ? Env.params[:max_export_depth].to_i : 2
+  end
+
+  # returns an array of Hashes (each in export_item view)
+  view :export_items, cache: :never do
+    exporting_uniques do
+      export_items_in_view(:export).flatten
+    end
+  end
+
+  # returns Hash with the essentials needed to import a card into a new database
+  view :export_item do
+    item = { name: card.name, type: card.type_name, content: card.content }
+    item[:codename] = card.codename if card.codename
+    track_exporting card
+    item
+  end
+
+  def export_items_in_view view
+    within_max_depth do
+      valid_items_for_export.map do |item|
+        nest item, view: view
+      end
+    end
+  end
+
+  def track_exporting card
+    return unless @exported_keys
+    @exported_keys << card.key
+  end
+
+  def exporting_uniques
+    @exported_keys ||= inherit(:exported_keys) || ::Set.new
+    yield
+  end
+
+  # prevent recursion
+  def within_max_depth
+    @export_depth ||= inherit(:export_depth).to_i + 1
+    @export_depth > max_export_depth ? [] : yield
+  end
+
+  def items_for_export
+    nest_chunks.map do |chunk|
+      next if chunk.try :main?
+      chunk.referee_card
+    end.compact
+  end
+
+  def valid_items_for_export
+    items_for_export.flatten.reject(&:blank?).uniq.find_all do |card|
+      valid_export_card? card
+    end
+  end
+
+  def valid_export_card? ecard
+    ecard.real? && !@exported_keys.include?(ecard.key)
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/export.rb ~~

data/tmpsets/set/mod003-core/all/extended.rb

@@ -0,0 +1,58 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Extended)
+#
+module Extended;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/extended.rb"; end
+
+def extended_item_cards context=nil
+  items = item_cards limit: "", context: (context || self).name
+  list = []
+  book = ::Set.new # avoid loops
+  extend_item_list items, list, book until items.empty?
+  list
+end
+
+def extended_item_contents context=nil
+  extended_item_cards(context).map(&:item_names).flatten
+end
+
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  delegate :extended_item_contents, to: :card
+end
+
+private
+
+def extend_item_list items, list, book
+  item = items.shift
+  return if already_extended? item, book
+  if item.collection?
+    # keep items in order
+    items.unshift(*item.item_cards)
+  else  # no further level of items
+    list << item
+  end
+end
+
+def already_extended? item, book
+  return true if book.include? item
+  book << item
+  false
+end
+
+# def extended_list context=nil
+#   context = (context ? context.name : name)
+#   args = { limit: "" }
+#   item_cards(args.merge(context: context)).map do |x|
+#     x.item_cards(args)
+#   end.flatten.map do |x|
+#     x.item_cards(args)
+#   end.flatten.map do |y|
+#     y.item_names(args)
+#   end.flatten
+#   # this could go on and on.  more elegant to recurse until you don't have
+#   # a collection
+# end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/extended.rb ~~

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

@@ -0,0 +1,159 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Fetch)
+#
+# = Card#fetch
+#
+module Fetch;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/fetch.rb"; end
+# A multipurpose retrieval operator that integrates caching, database lookups,
+# and "virtual" card construction
+module ClassMethods
+  # Look for cards in
+  # * cache
+  # * database
+  # * virtual cards
+  #
+  # @param args [Integer, String, Card::Name, Symbol, Array]
+  #    one or more of the three unique identifiers
+  #      1. a numeric id (Integer)
+  #      2. a name/key (String or Card::Name)
+  #      3. a codename (Symbol)
+  #    If you pass more then one mark or an array of marks they get joined with a '+'.
+  #    The final argument can be a hash to set the following 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 = retrieve_or_new mark, opts
+
+    return if card.nil?
+    write_to_cache card, opts[:local_only] if needs_caching
+    standard_fetch_results card, mark, opts
+  rescue ActiveModel::RangeError => _e
+    return Card.new name: "card id out of range: #{mark}"
+  end
+
+  # fetch only real (no virtual) cards
+  #
+  # @param mark - see #fetch
+  # @return [Card]
+  def [] *mark
+    fetch(*mark, skip_virtual: true)
+  end
+
+  # fetch real cards without set modules loaded. Should only be used for simple attributes
+  # @example
+  #   quick_fetch "A", :self, :structure
+  #
+  # @param mark - see #fetch
+  # @return [Card]
+  def quick_fetch *mark
+    fetch mark, skip_virtual: true, skip_modules: true
+  end
+
+  # fetch only from the soft cache
+  #
+  # @param args - see #fetch
+  # @return [Card]
+  def fetch_soft *args
+    mark, opts = normalize_fetch_args args
+    fetch mark, opts.merge(local_only: true)
+  end
+
+  # @return [Card]
+  def fetch_from_cast cast
+    fetch_args = cast[:id] ? [cast[:id].to_i] : [cast[:name], { new: cast }]
+    fetch *fetch_args
+  end
+
+  #----------------------------------------------------------------------
+  # ATTRIBUTE FETCHING
+  # The following methods optimize fetching of specific attributes
+
+  def id cardish
+    case cardish
+    when Integer then cardish
+    when Card then cardish.id
+    when Symbol then Card::Codename.id cardish
+    else fetch_id cardish
+    end
+  end
+
+  # @param mark - see #fetch
+  # @return [Integer]
+  def fetch_id *mark
+    mark, _opts = normalize_fetch_args mark
+    return mark if mark.is_a? Integer
+    card = quick_fetch mark.to_s
+    card && card.id
+  end
+
+  # @param mark - see #fetch
+  # @return [Card::Name]
+  def fetch_name *mark
+    if (card = quick_fetch(mark))
+      card.name
+    elsif block_given?
+      yield.to_name
+    end
+  rescue ActiveModel::RangeError => _e
+    block_given? ? yield.to_name : nil
+  rescue Card::Error::CodenameNotFound => e
+    block_given? ? yield.to_name : raise(e)
+  end
+
+  # @param mark - see #fetch
+  # @return [Integer]
+  def fetch_type_id *mark
+    (card = quick_fetch(mark)) && card.type_id
+  end
+end
+
+#----------------------------------------------------------------------
+# INSTANCE METHODS
+# fetching from the context of a card
+
+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.name.trait(trait), opts
+  end
+end
+
+def renew args={}
+  opts = args[:new].clone
+  handle_default_content opts
+  opts[:name] ||= name
+  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 refresh force=false
+  return self unless force || frozen? || readonly?
+  return unless id
+  fresh_card = self.class.find id
+  fresh_card.include_set_modules
+  fresh_card
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/fetch.rb ~~