card 1.101.1 → 1.101.6

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

@@ -1,131 +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
-    Card::Fetch.new(*args)&.retrieve_or_new
-  rescue ActiveModel::RangeError => _e
-    return Card.new name: "card id out of range: #{f.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
-
-  # @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_parts - see #fetch
-  # @return [Integer]
-  def fetch_id *mark_parts
-    mark = Card::Fetch.new(*mark_parts)&.mark
-    mark.is_a?(Integer) ? mark : quick_fetch(mark.to_s)&.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
-    quick_fetch(mark)&.type_id
-  end
-end
-
-#----------------------------------------------------------------------
-# INSTANCE METHODS
-# fetching from the context of a card
-
-def fetch traits, opts={}
-  opts[:new][:supercard] = self if opts[:new]
-  Array.wrap(traits).inject(self) do |card, trait|
-    Card.fetch card.name.trait(trait), opts
-  end
-end
-
-def newish opts
-  reset_patterns
-  Card.with_normalized_new_args opts do |norm_opts|
-    handle_type norm_opts do
-      assign_attributes norm_opts
-      self.name = name # trigger superize_name
-    end
-  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/mod002-core/all/fetch_helper.rb

@@ -1,44 +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
-
-  private
-
-  def standard_controller_fetch args, card_opts
-    mark = args[:mark] || card_opts[:name]
-    card = Card.fetch mark, skip_modules: true,
-                            look_in_trash: args[:look_in_trash],
-                            new: card_opts
-    card.assign_attributes card_opts if args[:assign] && card&.real?
-    card&.include_set_modules
-    card
-  end
-
-  def controller_fetch_opts args
-    opts = Env.hash 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
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/fetch_helper.rb ~~

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

@@ -1,20 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (I18n)
-#
-module I18n;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/i18n.rb"; end
-def tr key, args={}
-  args[:scope] ||= Card::Set.scope(caller)
-  ::I18n.t key, args
-end
-
-module Format; module_parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
-  def tr key, args={}
-    args[:scope] ||= Card::Set.scope(caller)
-    ::I18n.t key, args
-  end
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/i18n.rb ~~

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

@@ -1,238 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Name)
-#
-module Name;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/name.rb"; end
-require "uuid"
-
-module ClassMethods
-  def uniquify_name name, rename=:new
-    return name unless Card.exists? name
-    uniq_name = generate_alternative_name name
-    return uniq_name unless rename == :old
-    rename!(name, uniq_name)
-    name
-  end
-
-  def generate_alternative_name name
-    uniq_name = "#{name} 1"
-    uniq_name.next! while Card.exists?(uniq_name)
-    uniq_name
-  end
-
-  def rename! oldname, newname
-    Card[oldname].update! name: newname, update_referers: true
-  end
-end
-
-def name
-  @name ||= left_id ? Card::Lexicon.lex_to_name([left_id, right_id]) : super.to_name
-end
-
-def key
-  @key ||= left_id ? name.key : super
-end
-
-def name= newname
-  @name = superize_name newname.to_name
-  self.key = @name.key
-  update_subcard_names @name
-  write_attribute :name, (@name.simple? ? @name.s : nil)
-  assign_side_ids
-  @name
-end
-
-def assign_side_ids
-  if name.simple?
-    self.left_id = self.right_id = nil
-  else
-    assign_side_id :left_id=, :left_name
-    assign_side_id :right_id=, :right_name
-  end
-end
-
-# assigns left_id and right_id based on names.
-# if side card is new, id is temporarily stored as -1
-def assign_side_id side_id_equals, side_name
-  side_id = Card::Lexicon.id(name.send(side_name)) || -1
-  send side_id_equals, side_id
-end
-
-def superize_name cardname
-  return cardname unless @supercard
-
-  @supercard.subcards.rename key, cardname.key
-  update_superleft cardname
-  @supercard.name.relative? ? cardname : cardname.absolute_name(@supercard.name)
-end
-
-def update_superleft cardname
-  @superleft = @supercard if cardname.field_of? @supercard.name
-end
-
-def key= newkey
-  return if newkey == key
-  update_cache_key key do
-    write_attribute :key, (name.simple? ? newkey : nil)
-    @key = newkey
-  end
-  clean_patterns
-  @key
-end
-
-def clean_patterns
-  return unless patterns?
-  reset_patterns
-  patterns
-end
-
-def update_cache_key oldkey
-  yield
-  was_in_cache = Card.cache.soft.delete oldkey
-  Card.write_to_soft_cache self if was_in_cache
-end
-
-def update_subcard_names new_name, name_to_replace=nil
-  return unless @subcards
-  subcards.each do |subcard|
-    update_subcard_name subcard, new_name, name_to_replace if subcard.new?
-  end
-end
-
-def update_subcard_name subcard, new_name, name_to_replace
-  name_to_replace ||= name_to_replace_for_subcard subcard, new_name
-  subcard.name = subcard.name.swap name_to_replace, new_name.s
-  subcard.update_subcard_names new_name, name # needed?  shouldn't #name= trigger this?
-end
-
-def name_to_replace_for_subcard subcard, new_name
-  # if subcard has a relative name like +C
-  # and self is a subcard as well that changed from +B to A+B then
-  # +C should change to A+B+C. #replace doesn't work in this case
-  # because the old name +B is not a part of +C
-  if subcard.name.starts_with_joint? && new_name.parts.first.present?
-    "".to_name
-  else
-    name
-  end
-end
-
-def autoname name
-  if Card.exists?(name) || Director.include?(name)
-    autoname name.next
-  else
-    name
-  end
-end
-
-# FIXME: use delegations and include all name functions
-delegate :simple?, :compound?, :junction?, to: :name
-
-def left *args
-  case
-  when simple?    then nil
-  when superleft then superleft
-  when name_is_changing? && name.to_name.trunk_name == name_before_act.to_name
-    nil # prevent recursion when, eg, renaming A+B to A+B+C
-  else
-    Card.fetch name.left, *args
-  end
-end
-
-def right *args
-  Card.fetch(name.right, *args) unless simple?
-end
-
-def [] *args
-  case args[0]
-  when Integer, Range
-    fetch_name = Array.wrap(name.parts[args[0]]).compact.join Card::Name.joint
-    Card.fetch(fetch_name, args[1] || {}) unless simple?
-  else
-    super
-  end
-end
-
-def trunk *args
-  simple? ? self : left(*args)
-end
-
-def tag *args
-  simple? ? self : Card.fetch(name.right, *args)
-end
-
-def left_or_new args={}
-  left(args) || Card.new(args.merge(name: name.left))
-end
-
-# NOTE: for all these helpers, method returns *all* fields/children/descendants.
-# (Not just those current user has permission to read.)
-
-def fields
-  field_ids.map { |id| Card[id] }
-end
-
-def field_names
-  field_ids.map { |id| Card::Name[id] }
-end
-
-def field_ids
-  child_ids :left
-end
-
-def each_child
-  child_ids.each do |id|
-    (child = Card[id]) && yield(child)
-    # check should not be needed (remove after fixing data problems)
-  end
-end
-
-# eg, A+B is a child of A and B
-def child_ids side=nil
-  return [] unless id
-  side ||= name.simple? ? :part : :left_id
-  Auth.as_bot do
-    Card.search({ side => id, return: :id, limit: 0 }, "children of #{name}")
-  end
-end
-
-def each_descendant &block
-  each_child do |child|
-    yield child
-    child.each_descendant(&block)
-  end
-end
-
-def right_id= cardish
-  write_card_or_id :right_id, cardish
-end
-
-def left_id= cardish
-  write_card_or_id :left_id, cardish
-end
-
-def write_card_or_id attribute, cardish
-  when_id_exists(cardish) { |id| write_attribute attribute, id }
-end
-
-def when_id_exists cardish, &block
-  if (card_id = Card.id cardish)
-    yield card_id
-  elsif cardish.is_a? Card
-    with_id_after_store cardish, &block
-  else
-    yield cardish # eg nil
-  end
-end
-
-# subcards are usually saved after super cards;
-# after_store forces it to save the subcard first
-# and callback afterwards
-def with_id_after_store subcard
-  add_subcard subcard
-  subcard.director.after_store { |card| yield card.id }
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/name.rb ~~

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

@@ -1,63 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Pattern)
-#
-module Pattern;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/pattern.rb"; end
-def patterns?
-  defined? @patterns
-end
-
-def all_patterns
-  @all_patterns ||= set_patterns.map { |sub| sub.new self }.compact
-end
-
-# new cards do not
-def patterns
-  @patterns ||= (new_card? ? all_patterns[1..-1] : all_patterns)
-end
-
-def reset_patterns
-  # Rails.logger.info "resetting patterns: #{name}"
-  @patterns = @all_patterns = nil
-  @template = @virtual = nil
-  @set_mods_loaded = @set_modules = @set_names = @rule_set_keys = nil
-  @junction_only = nil # only applies to set cards
-  true
-end
-
-def safe_set_keys
-  patterns.map(&:safe_key).reverse * " "
-end
-
-def set_modules
-  @set_modules ||= all_patterns[0..-2].reverse.map(&:module_list).flatten.compact
-end
-
-def set_format_modules klass
-  @set_format_modules ||= {}
-  @set_format_modules[klass] =
-    all_patterns[0..-2].reverse.map do |pattern|
-      pattern.format_module_list klass
-    end.flatten.compact
-end
-
-def set_names
-  @set_names = patterns.map(&:to_s) if @set_names.nil?
-  @set_names
-end
-
-def in_set? set_module
-  patterns.map(&:module_key).include? set_module.shortname
-end
-
-def rule_set_keys
-  @rule_set_keys ||= patterns.map(&:rule_set_key).compact
-end
-
-def include_module? set
-  singleton_class&.include? set
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/pattern.rb ~~