card 1.99.4 → 1.99.5

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

@@ -1,74 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Actify)
-#
-module Actify;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/actify.rb"; end
-def act &block
-  @action ||= identify_action
-  if ActManager.act_card
-    add_to_act &block
-  else
-    start_new_act &block
-  end
-end
-
-def start_new_act
-  self.director = nil
-  ActManager.run_act(self) do
-    run_callbacks(:act) { yield }
-  end
-end
-
-def add_to_act
-  # if only_storage_phase is true then the card is already part of the act
-  return yield if ActManager.act_card == self || only_storage_phase
-  director.reset_stage
-  director.update_card self
-  self.only_storage_phase = true
-  yield
-end
-
-module ClassMethods
-  def create! opts
-    card = Card.new opts
-    card.act do
-      card.save!
-    end
-    card
-  end
-
-  def create opts
-    card = Card.new opts
-    card.act do
-      card.save
-    end
-    card
-  end
-end
-
-def save!(*)
-  act { super }
-end
-
-def save(*)
-  act { super }
-end
-
-def valid?(*)
-  act { super }
-end
-
-def update *args
-  act { super }
-end
-
-def update! *args
-  act { super }
-end
-
-alias_method :update_attributes, :update
-alias_method :update_attributes!, :update!
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/actify.rb ~~

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

@@ -1,131 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (AssignAttributes)
-#
-module AssignAttributes;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/assign_attributes.rb"; end
-
-def assign_attributes args={}
-  args = prepare_assignment_args args
-
-  assign_with_subcards args do
-    assign_with_set_modules args do
-      params = prepare_assignment_params args
-      super params
-    end
-  end
-end
-
-def assign_set_specific_attributes
-  set_specific.each_pair do |name, value|
-    send "#{name}=", value
-  end
-end
-
-def extract_subcard_args! args
-  subcards = args.delete("subcards") || args.delete(:subcards) || {}
-  if (subfields = args.delete("subfields") || args.delete(:subfields))
-    subfields.each_pair do |key, value|
-      subcards[name.field(key)] = value
-    end
-  end
-  args.keys.each do |key|
-    subcards[key] = args.delete(key) if key =~ /^\+/
-  end
-  subcards = subcards.to_unsafe_h if subcards.respond_to?(:to_unsafe_h)
-  subcards
-end
-
-protected
-
-module ClassMethods
-  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
-end
-
-def prepare_assignment_params args
-  args = args.to_unsafe_h if args.respond_to?(:to_unsafe_h)
-  params = ActionController::Parameters.new(args)
-  params.permit!
-  if params[:db_content].is_a? Array
-    params[:db_content] = params[:db_content].join("\n")
-  end
-  params
-end
-
-def prepare_assignment_args args
-  return {} unless args
-  args = args.stringify_keys
-  normalize_type_attributes args
-  stash_set_specific_attributes args
-  args
-end
-
-def assign_with_set_modules args
-  set_changed = args["name"] || args["type_id"]
-  return yield unless set_changed
-
-  refresh_set_modules { yield }
-end
-
-def assign_with_subcards args
-  subcard_args = extract_subcard_args! args
-  yield
-  # name= must come before process subcards
-  return unless subcard_args.present?
-  subcards.add subcard_args
-end
-
-def refresh_set_modules
-  reload_set_modules = @set_mods_loaded
-  yield
-  reset_patterns
-  include_set_modules if reload_set_modules
-end
-
-def stash_set_specific_attributes args
-  @set_specific = {}
-  Card.set_specific_attributes.each do |key|
-    set_specific[key] = args.delete(key) if args.key?(key)
-  end
-end
-
-def normalize_type_attributes args
-  new_type_id = extract_type_id! args unless args.delete("skip_type_lookup")
-  args["type_id"] = new_type_id if new_type_id
-end
-
-def extract_type_id! args={}
-  type_id =
-    case
-    when args["type_id"]
-      id = args.delete("type_id").to_i
-      # type_id can come in as 0,'' or nil
-      id.zero? ? nil : id
-    when args["type_code"]
-      Card.fetch_id args.delete("type_code").to_sym
-    when args["type"]
-      Card.fetch_id args.delete("type")
-    else
-      return nil
-    end
-
-  unless type_id
-    errors.add :type, "#{args[:type] || args[:type_code]} is not a known type."
-  end
-  type_id
-end
-
-# 'set' refers to the noun not the verb
-def set_specific
-  @set_specific ||= {}
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/assign_attributes.rb ~~

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

@@ -1,123 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Cache)
-#
-module Cache;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/cache.rb"; end
-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
-    name = retrieve_from_cache "~#{id}", local_only
-    retrieve_from_cache name, local_only if name
-  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
-      cache.write "~#{card.id}", card.key if card.id.to_i.nonzero?
-    end
-  end
-
-  def write_to_soft_cache card
-    return unless cache
-    cache.soft.write card.key, card
-    cache.soft.write "~#{card.id}", card.key if card.id.to_i.nonzero?
-  end
-
-  def expire name
-    key = name.to_name.key
-    return unless (card = Card.cache.read key)
-    card.expire
-  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
-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 register_view_cache_key cache_key
-  view_cache_keys cache_key
-  hard_write_view_cache_keys
-end
-
-def view_cache_keys new_key=nil
-  @view_cache_keys ||= []
-  @view_cache_keys << new_key if new_key
-  append_missing_view_cache_keys
-  @view_cache_keys.uniq!
-  @view_cache_keys
-end
-
-def append_missing_view_cache_keys
-  return unless Card.cache.hard
-  @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}"
-  return unless Card.cache.hard
-  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 = nil
-end
-
-def expire_names cache
-  [name, name_before_act].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
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/cache.rb ~~

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

@@ -1,156 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Chunk)
-#
-module Chunk;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/chunk.rb"; end
-
-def chunks content, type, named=false
-  content ||= self.content
-  type ||= Card::Content::Chunk
-  all_chunks = Card::Content.new(content, self).find_chunks type
-  named ? all_chunks.select(&:referee_name) : all_chunks
-end
-
-def reference_chunks content=nil, named=true
-  chunks content, Card::Content::Chunk::Reference, named
-end
-
-# named=true rejects commented nests
-def nest_chunks content=nil, named=true
-  chunks content, Card::Content::Chunk::Nest, named
-end
-
-# named=true rejects external links (since the don't refer to a card name)
-def link_chunks content=nil, named=false
-  chunks content, Card::Content::Chunk::Link, named
-end
-
-def each_item_name_with_options content=nil
-  reference_chunks(content).each do |chunk|
-    options = chunk.respond_to?(:options) ? chunk.options : {}
-    yield chunk.referee_name, options
-  end
-end
-
-module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
-  def nested_fields content=nil
-    result = []
-    each_nested_card(content, true) do |chunk|
-      result << [chunk.referee_name, chunk.options]
-    end
-    result
-  end
-
-  def nested_field_cards content=nil
-    nested_fields(content).map do |name, _options|
-      Card.fetch name
-    end
-  end
-
-  def nested_cards_for_edit fields_only=false
-    return normalized_edit_fields if edit_fields.present?
-    result = []
-    each_nested_card nil, fields_only do |chunk|
-      result << [chunk.options[:nest_name], chunk.options]
-    end
-    result
-  end
-
-  def edit_fields
-    voo.edit_structure || []
-  end
-
-  def normalized_edit_fields
-    edit_fields.map do |cardish, options|
-      field_mark = normalized_edit_field_mark cardish, options
-      options = normalized_edit_field_options options, Card::Name[field_mark]
-      [field_mark, options]
-    end
-  end
-
-  def normalized_edit_field_options options, cardname
-    options ||= cardname
-    options.is_a?(String) ? { title: options } : options
-  end
-
-  def normalized_edit_field_mark cardish, options
-    return cardish if cardish.is_a?(Card) ||
-                      (options.is_a?(Hash) && options.delete(:absolute))
-    card.name.field cardish
-  end
-
-  def process_field chunk, processed
-    return unless process_unique_field? chunk, processed
-    yield chunk if block_given?
-  end
-
-  def each_nested_field content=nil, &block
-    each_nested_card content, true, &block
-  end
-
-  def each_nested_card content=nil, fields_only=false, &block
-    processed = process_tally
-    nest_chunks(content).each do |chunk|
-      next if fields_only && !field_chunk?(chunk)
-      process_nested_chunk chunk, processed, &block
-    end
-  end
-
-  def uniq_nested_cards content: nil
-    with_unique_chunks do
-      nest_chunks(content).map do |chunk|
-        chunk.referee_card if unique_chunk? chunk
-      end
-    end
-  end
-
-  def nest_chunks content=nil
-    content ||= _render_raw
-    card.nest_chunks content
-  end
-
-  def process_tally
-    ::Set.new [card.key]
-  end
-
-  def field_chunk? chunk
-    chunk.referee_name.to_name.field_of? card.name
-  end
-
-  def unique_chunk? chunk
-    key = chunk.referee_name.key
-    return false if @processed.include? key
-    @processed << key
-    true
-  end
-
-  def with_unique_chunks
-    @processed = ::Set.new [card.key]
-    yield
-  end
-
-  def process_nested_chunk chunk, processed, &block
-    virtual = chunk.referee_card&.virtual?
-    # TODO: handle structures that are non-virtual
-    method = virtual ? :process_virtual_field : :process_field
-    send method, chunk, processed, &block
-  end
-
-  def process_virtual_field chunk, processed, &block
-    return unless process_unique_field? chunk, processed
-    subformat(chunk.referee_card).each_nested_field do |sub_chunk|
-      process_field sub_chunk, processed, &block
-    end
-  end
-
-  def process_unique_field? chunk, processed
-    key = chunk.referee_name.key
-    return false if processed.include? key
-    processed << key
-    true
-  end
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/chunk.rb ~~