card 1.99.4 → 1.99.5

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

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

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

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

@@ -1,162 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (FetchHelper)
-#
-module FetchHelper;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/fetch_helper.rb"; end
-module ClassMethods
-  # a fetch method to support the needs of the card controller.
-  # should be in Decko?
-  def controller_fetch args
-    card_opts = controller_fetch_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 card_opts
-    else
-      standard_controller_fetch args, card_opts
-    end
-  end
-
-  def safe_param param
-    if param.respond_to? :to_unsafe_h
-      # clone doesn't work for Parameters
-      param.to_unsafe_h
-    else
-      # clone so that original params remain unaltered.  need deeper clone?
-      (param || {}).clone
-    end
-  end
-
-  private
-
-  def standard_controller_fetch args, card_opts
-    mark = args[:mark] || card_opts[:name]
-    card = Card.fetch mark, look_in_trash: args[:look_in_trash], new: card_opts
-    card.assign_attributes card_opts if args[:assign] && card&.real?
-    card
-  end
-
-  def controller_fetch_opts args
-    opts = safe_param args[:card]
-    opts[:type] ||= args[:type] if args[:type]
-    # for /new/:type shortcut.  we should handle in routing and deprecate this
-    opts[:name] ||= Card::Name.url_key_to_standard(args[:mark])
-    opts
-  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 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 retrieve_or_new mark, opts
-    card, needs_caching = retrieve_existing mark, opts
-    if (new_card = new_for_cache card, mark, opts)
-      [new_card, true]
-    else
-      [card, needs_caching]
-    end
-  end
-
-  # look in cache.  if that doesn't work, look in database
-  # @return [{Card}, {True/False}] Card object and "needs_caching" ruling
-  def retrieve_existing mark, opts
-    return [nil, false] unless mark.present?
-    mark_type, mark_key = retrievable_mark_type_and_value mark
-    if (card = retrieve_from_cache_by_mark mark_type, mark_key, opts)
-      # we have an acceptable card in the cache
-      # (and don't need to cache it again!)
-      [card, false]
-    else
-      # try to find the card in the database
-      card = retrieve_from_db mark_type, mark_key, opts[:look_in_trash]
-      [card, !(card.nil? || card.trash)]
-    end
-  end
-
-  def retrieve_from_cache_by_mark mark_type, mark_key, opts
-    card = send "retrieve_from_cache_by_#{mark_type}", mark_key, opts[:local_only]
-    return_cached_card?(card, opts[:look_in_trash]) ? card : nil
-  end
-
-  # In both the cache and the db, ids and keys are used to retrieve card data.
-  # This method identifies the kind of mark to use and its value
-  # @return [Array] first item is :id or :key, second is corresponding value
-  def retrievable_mark_type_and_value mark
-    # return mark_type and mark_value
-    if mark.is_a? Integer
-      [:id, mark]
-    else
-      [:key, mark.key]
-    end
-  end
-
-  def return_cached_card? card, look_in_trash
-    return false unless card
-    card.real? || !look_in_trash
-  end
-
-  # @return [Card, nil] Card object
-  def retrieve_from_db mark_type, mark_key, look_in_trash=false
-    query = { mark_type => mark_key }
-    query[:trash] = false unless look_in_trash
-    Card.where(query).take
-  end
-
-  def standard_fetch_results card, mark, opts
-    if card.new_card?
-      new_card_fetch_results card, mark, opts
-    else
-      finalize_fetch_results card, opts
-    end
-  end
-
-  def new_card_fetch_results card, mark, opts
-    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.assign_name_from_fetched_mark! mark, opts
-    finalize_fetch_results card, opts
-    card if opts[:new] || card.known?
-  end
-
-  def finalize_fetch_results card, opts
-    card.include_set_modules unless opts[:skip_modules]
-    card
-  end
-
-  def normalize_fetch_args args
-    opts = args.last.is_a?(Hash) ? args.pop : {}
-    mark = id_or_name args
-    mark = absolutize_fetch_mark mark, opts.dig(:new, :supercard)
-    [mark, opts]
-  end
-
-  def absolutize_fetch_mark mark, supercard
-    return mark unless mark.name? && supercard
-    mark.to_name.absolute_name supercard.name
-  end
-end
-
-public
-
-def assign_name_from_fetched_mark! mark, opts
-  return if opts[:local_only]
-  return unless mark && mark.to_s != name
-  self.name = mark.to_s
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/fetch_helper.rb ~~

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

@@ -1,84 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Haml)
-#
-module Haml;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/haml.rb"; end
-module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
-  include Card::Set::Format::HamlPaths
-
-  define_method :the_scope do
-    set_scope
-  end
-
-  define_method :haml_scope do
-    set_scope
-  end
-
-  # Renders haml templates. The haml template can be passed as string or
-  # block or a symbol that refers to a view template.
-  # @param args [Hash, String, Symbol]
-  #   If a symbol is given then a template is expected in the corresponding view
-  #   directory.
-  # @return [String] rendered haml as HTML
-  # @example render a view template
-  #   # view/type/basic/my_template.haml:
-  #   %p
-  #     Hi
-  #     = name
-  #
-  #   # set/type/basic.rb:
-  #   view :my_view do
-  #     haml :my_template, name: "Joe:  # => "<p>Hi Joe<p/>"
-  #   end
-  # @example use a block to pass haml
-  #   haml name: "Joe" do
-  #     <<-HAML.strip_heredoc
-  #       %p
-  #         Hi
-  #         = name
-  #     HAML
-  #   # => <p>Hi Joe</p>
-  # @example create a slot in haml code
-  #   - haml_wrap do
-  #     %p
-  #       some haml
-
-  def haml *args, &block
-    if args.first.is_a? Symbol
-      process_haml_template(*args)
-    else
-      process_haml(*args, &block)
-    end
-  end
-
-  def haml_partial partial, locals={}
-    locals[:template_path] ||= @template_path
-    process_haml_template "_#{partial}".to_sym, locals
-  end
-
-  private
-
-  def process_haml *args
-    args.unshift yield if block_given?
-    haml_to_html(*args)
-  end
-
-  def process_haml_template template_name, *args
-    locals = args.first || {}
-    path = identify_template_path template_name, locals
-    with_template_path path do
-      haml_to_html ::File.read(path), *args
-    end
-    # rescue => e
-    #   raise Card::Error, "HAML error #{template_name}: #{e.message}\n#{e.backtrace}"
-  end
-
-  def identify_template_path view, locals={}
-    base_path = locals.delete(:template_path) || caller_locations[2].path
-    haml_template_path view, base_path
-  end
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/haml.rb ~~