card 1.101.3 → 1.101.4

data/lib/card/mod_inflector.rb

@@ -1,16 +0,0 @@
-class ModInflector < Zeitwerk::Inflector
-  def camelize basename, abspath
-    ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector.camelize(basename, abspath)
-
-    # if basename =~ /\Ahtml_(.*)/
-    #   ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector.camelize(basename, abspath)
-    #   # "HTML" + super($1, abspath)
-    # else
-    #   super
-    # end
-  end
-
-  def inflect overrides
-    ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector.inflect(overrides)
-  end
-end

data/lib/card/name/all/class_methods.rb

@@ -1,28 +0,0 @@
-class Card
-  class Name
-    module All
-      # Name-related Card class methods
-      module ClassMethods
-        def rename! oldname, newname
-          Card[oldname].update! name: newname, update_referers: true
-        end
-
-        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
-
-        private
-
-        def generate_alternative_name name
-          uniq_name = "#{name} 1"
-          uniq_name.next! while Card.exists?(uniq_name)
-          uniq_name
-        end
-      end
-    end
-  end
-end

data/mod/core/set/all/actify.rb

@@ -1,68 +0,0 @@
-def act options={}, &block
-  if act_card
-    add_to_act options, &block
-  else
-    start_new_act &block
-  end
-end
-
-def act_card
-  Card::Director.act_card
-end
-
-def act_card?
-  self == act_card
-end
-
-module ClassMethods
-  def create! opts
-    card = Card.new opts
-    card.save!
-    card
-  end
-
-  def create opts
-    card = Card.new opts
-    card.save
-    card
-  end
-end
-
-def save! *args
-  as_subcard = args.first&.delete :as_subcard
-  act(as_subcard: as_subcard) { super }
-end
-
-def save(*)
-  act { super }
-end
-
-def valid?(*)
-  act(validating: true) { super }
-end
-
-def update *args
-  act { super }
-end
-
-def update! *args
-  act { super }
-end
-
-alias_method :update_attributes, :update
-alias_method :update_attributes!, :update!
-
-private
-
-def start_new_act
-  self.director = nil
-  Director.run_act(self) do
-    run_callbacks(:act) { yield }
-  end
-end
-
-def add_to_act options={}
-  director.appoint self unless @director
-  director.head = true unless options[:validating] || options[:as_subcard]
-  yield
-end

data/mod/core/set/all/cache.rb

@@ -1,109 +0,0 @@
-module ClassMethods
-  def retrieve_from_cache cache_key, local_only=false
-    return unless cache
-    local_only ? cache.soft.read(cache_key) : cache.read(cache_key)
-  end
-
-  def retrieve_from_cache_by_id id, local_only=false
-    key = Card::Lexicon.name(id)&.key
-    return unless key.present?
-
-    retrieve_from_cache key, local_only if key
-  end
-
-  def retrieve_from_cache_by_key key, local_only=false
-    retrieve_from_cache key, local_only
-  end
-
-  def write_to_cache card, local_only=false
-    if local_only
-      write_to_soft_cache card
-    elsif cache
-      cache.write card.key, card
-    end
-  end
-
-  def write_to_soft_cache card
-    return unless cache
-    cache.soft.write card.key, card
-  end
-
-  def expire name
-    key = name.to_name.key
-    return unless (card = Card.cache.read key)
-    card.expire
-  end
-end
-
-def update_soft_cache
-  Card.write_to_soft_cache self
-end
-
-def expire_pieces
-  name.piece_names.each do |piece|
-    Card.expire piece
-  end
-end
-
-def expire cache_type=nil
-  return unless (cache_class = cache_class_from_type cache_type)
-  expire_views
-  expire_names cache_class
-  expire_id cache_class
-end
-
-def cache_class_from_type cache_type
-  cache_type ? Card.cache.send(cache_type) : Card.cache
-end
-
-def view_cache_clean?
-  !db_content_changed?
-end
-
-def view_cache_keys
-  @view_cache_keys ||= hard_read_view_cache_keys || []
-end
-
-def ensure_view_cache_key cache_key
-  return if view_cache_keys.include? cache_key
-
-  @view_cache_keys << cache_key
-  hard_write_view_cache_keys
-end
-
-def hard_read_view_cache_keys
-  Card.cache.hard&.read_attribute key, :view_cache_keys
-end
-
-def hard_write_view_cache_keys
-  # puts "WRITE VIEW CACHE KEYS (#{name}): #{view_cache_keys}"
-  Card.cache.hard&.write_attribute key, :view_cache_keys, view_cache_keys
-end
-
-def expire_views
-  # puts "EXPIRE VIEW CACHE (#{name}): #{view_cache_keys}"
-  return unless view_cache_keys.present?
-  Array.wrap(view_cache_keys).each do |view_cache_key|
-    Card::View.cache.delete view_cache_key
-  end
-  @view_cache_keys = []
-  hard_write_view_cache_keys
-end
-
-def expire_names cache
-  [name, name_before_act].uniq.each do |name_version|
-    expire_name name_version, cache
-  end
-end
-
-def expire_name name_version, cache
-  return unless name_version.present?
-  key_version = name_version.to_name.key
-  return unless key_version.present?
-  cache.delete key_version
-end
-
-def expire_id cache
-  return unless id.present?
-  cache.delete "~#{id}"
-end

data/mod/core/set/all/event_conditions.rb

@@ -1,172 +0,0 @@
-Card.action_specific_attributes +=
-  %i[skip_hash full_skip_hash trigger_hash full_trigger_hash]
-
-def event_applies? event
-  return unless set_condition_applies? event.set_module, event.opts[:changing]
-
-  Card::Set::Event::CONDITIONS.all? do |key|
-    send "#{key}_condition_applies?", event, event.opts[key]
-  end
-end
-
-# force skipping this event for all cards in act
-def skip_event! *events
-  @full_skip_hash = nil
-  events.each do |event|
-    act_skip_hash[event.to_s] = :force
-  end
-end
-
-# force skipping this event for this card only
-def skip_event_in_action! *events
-  events.each do |event|
-    full_skip_hash[event.to_s] = :force
-  end
-end
-
-# force triggering this event (when it comes up) for all cards in act
-def trigger_event! *events
-  @full_trigger_hash = nil
-  events.each do |event|
-    act_trigger_hash[event.to_s] = :force
-  end
-end
-
-# force triggering this event (when it comes up) for this card only
-def trigger_event_in_action! *events
-  events.each do |event|
-    full_trigger_hash[event.to_s] = :force
-  end
-end
-
-# hash form of raw skip setting, eg { "my_event" => true }
-def skip_hash
-  @skip_hash ||= hash_with_value skip, true
-end
-
-def trigger_hash
-  @trigger_hash ||= hash_with_value trigger, true
-end
-
-private
-
-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
-  actions.empty? ? true : 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
-
-# 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
-
-# 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
-
-# "applies always means event can run
-# so if skip_condition_applies?, we do NOT skip
-def skip_condition_applies? event, allowed
-  return true unless (val = full_skip_hash[event.name.to_s])
-
-  allowed ? val.blank? : (val != :force)
-end
-
-def trigger_condition_applies? event, required
-  return true unless required
-
-  full_trigger_hash[event.name.to_s].present?
-end
-
-def single_changed_condition_applies? db_column
-  return true unless db_column
-  send "#{db_column}_is_changing?"
-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 actn
-  return false if on_condition_applies?(nil, actn)
-  "on: #{actn} method #{method} called on #{action}"
-end
-
-def full_skip_hash
-  @full_skip_hash ||= act_skip_hash.merge skip_in_action_hash
-end
-
-def act_skip_hash
-  (act_card || self).skip_hash
-end
-
-def skip_in_action_hash
-  hash_with_value skip_in_action, true
-end
-
-def full_trigger_hash
-  @full_trigger_hash ||= act_trigger_hash.merge trigger_in_action_hash
-end
-
-def trigger_in_action_hash
-  hash_with_value trigger_in_action, true
-end
-
-def act_trigger_hash
-  (act_card || self).trigger_hash
-end
-
-def hash_with_value array, value
-  Array.wrap(array).each_with_object({}) do |event, hash|
-    hash[event.to_s] = value
-  end
-end

data/mod/core/set/all/fetch.rb

@@ -1,122 +0,0 @@
-# = 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 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