card 1.99.2 → 1.100.0

data/mod/core/set/abstract/code_file.rb

@@ -9,17 +9,17 @@ end
 # @return [Array<String>, String] the name of file(s) to be loaded
 def source_files
   case type_id
-  when Card::CoffeeScriptID then "#{codename}.js.coffee"
-  when Card::JavaScriptID   then "#{codename}.js"
-  when Card::CssID          then "#{codename}.css"
-  when Card::ScssID         then "#{codename}.scss"
+  when CoffeeScriptID then "#{codename}.js.coffee"
+  when JavaScriptID   then "#{codename}.js"
+  when CssID          then "#{codename}.css"
+  when ScssID         then "#{codename}.scss"
   end
 end
 
 def source_dir
   case type_id
-  when Card::CoffeeScriptID, Card::JavaScriptID then "lib/javascript"
-  when Card::CssID, Card::ScssID then "lib/stylesheets"
+  when CoffeeScriptID, JavaScriptID then "lib/javascript"
+  when CssID, ScssID then "lib/stylesheets"
   else
     "lib"
   end

data/mod/core/set/abstract/haml_file.rb

@@ -10,6 +10,10 @@ def content
 end
 
 format :html do
+  view :input do
+    "Content is managed by code and cannot be edited"
+  end
+
   def haml_locals
     {}
   end

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

@@ -1,42 +1,29 @@
 def act &block
-  @action ||= identify_action
-  if ActManager.act_card
+  if 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
+def act_card
+  Card::Director.act_card
 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
+def act_card?
+  self == act_card
 end
 
 module ClassMethods
   def create! opts
     card = Card.new opts
-    card.act do
-      card.save!
-    end
+    card.save!
     card
   end
 
   def create opts
     card = Card.new opts
-    card.act do
-      card.save
-    end
+    card.save
     card
   end
 end
@@ -63,3 +50,17 @@ 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
+  director.appoint self unless @director
+  yield
+end

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

@@ -1,31 +1,3 @@
-=begin
-
-# following may be useful, but is neither tested nor in use
-
-def card_attributes
-  if Card::Set.traits
-    set_modules.each do |mod|
-      if mod_traits = Card::Set.traits[mod]
-        return mod_traits
-      end
-    end
-  end
-  nil
-end
-
-def trait_var? var_name
-  !instance_variable_get( var_name ).nil?
-end
-
-=end
-
-def trait_var _var_name, &_block
-  # FIXME: - following optimization attempt needs to handle cache clearing!
-  #  instance_variable_get var_name or begin
-  #    instance_variable_set var_name, block_given? ? yield : raise("no block?")
-  #  end
-  yield
-end
 
 # FIXME: -this needs a better home!
 def format opts={}

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

@@ -33,9 +33,9 @@ end
 protected
 
 module ClassMethods
-  def assign_or_initialize_by name, attributes, fetch_opts={}
+  def assign_or_newish name, attributes, fetch_opts={}
     if (known_card = Card.fetch(name, fetch_opts))
-      known_card.refresh.assign_attributes attributes
+      known_card.refresh.newish attributes
       known_card
     else
       Card.new attributes.merge(name: name)
@@ -47,9 +47,7 @@ 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[:db_content] = standardize_content(params[:db_content]) if params[:db_content]
   params
 end
 
@@ -77,10 +75,10 @@ def assign_with_subcards args
 end
 
 def refresh_set_modules
-  reload_set_modules = @set_mods_loaded
+  reinclude_set_modules = @set_mods_loaded
   yield
   reset_patterns
-  include_set_modules if reload_set_modules
+  include_set_modules if reinclude_set_modules
 end
 
 def stash_set_specific_attributes args
@@ -91,29 +89,35 @@ def stash_set_specific_attributes args
 end
 
 def normalize_type_attributes args
-  new_type_id = extract_type_id! args unless args.delete("skip_type_lookup")
+  new_type_id = extract_type_id! args unless args.delete("type_lookup") == :skip
   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."
+  case
+  when (type_id = args.delete("type_id")&.to_i)
+    type_id.zero? ? nil : type_id
+  when (type_code = args.delete("type_code")&.to_sym)
+    type_id_from_codename type_code
+  when (type_name = args.delete "type")
+    type_id_from_cardname type_name
   end
-  type_id
+end
+
+def type_id_from_codename type_code
+  type_id_or_error(type_code) { Card::Codename.id type_code }
+end
+
+def type_id_from_cardname type_name
+  type_id_or_error(type_name) { Card.fetch_id type_name }
+end
+
+def type_id_or_error val
+  type_id = yield
+  return type_id if type_id
+
+  errors.add :type, "#{val} is not a known type."
+  nil
 end
 
 # 'set' refers to the noun not the verb

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

@@ -5,8 +5,10 @@ module ClassMethods
   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
+    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
@@ -33,15 +35,6 @@ module ClassMethods
     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
@@ -61,29 +54,28 @@ 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
+def view_cache_clean?
+  !db_content_changed?
 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
+def view_cache_keys
+  @view_cache_keys ||= hard_read_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) || [])
+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}"
-  return unless Card.cache.hard
-  Card.cache.hard.write_attribute key, :view_cache_keys, view_cache_keys
+  Card.cache.hard&.write_attribute key, :view_cache_keys, view_cache_keys
 end
 
 def expire_views
@@ -92,11 +84,12 @@ def expire_views
   Array.wrap(view_cache_keys).each do |view_cache_key|
     Card::View.cache.delete view_cache_key
   end
-  @view_cache_keys = nil
+  @view_cache_keys = []
+  hard_write_view_cache_keys
 end
 
 def expire_names cache
-  [name, name_before_act].each do |name_version|
+  [name, name_before_act].uniq.each do |name_version|
     expire_name name_version, cache
   end
 end

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

@@ -28,120 +28,115 @@ def each_item_name_with_options content=nil
 end
 
 format do
-  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
+  def nest_chunks content=nil
+    content ||= _render_raw
+    card.nest_chunks content
   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
+  def nested_cards content=nil
+    nest_chunks(content).map(&:referee_card).uniq
   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
+  def nested_field_names content=nil
+    nest_chunks(content).map(&:referee_name).select { |n| field_name? n }
   end
 
-  def normalized_edit_field_options options, cardname
-    options ||= cardname
-    options.is_a?(String) ? { title: options } : options
+  def nested_field_cards content=nil
+    nested_cards(content).select { |c| field_name? c.name }
   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
+  def field_name? name
+    name.field_of? card.name
   end
 
-  def process_field chunk, processed
-    return unless process_unique_field? chunk, processed
-    yield chunk if block_given?
+  # @return [Array] of Arrays.  each is [nest_name, nest_options_hash]
+  def edit_field_configs fields_only=false
+    if edit_fields.present?
+      explicit_edit_fields_config # explicitly configured in voo or code
+    else
+      implicit_edit_fields_config fields_only # inferred from nests
+    end
   end
 
-  def each_nested_field content=nil, &block
-    each_nested_card content, true, &block
+  def implicit_edit_fields_config fields_only
+    result = []
+    each_nested_chunk(fields: fields_only) do |chunk|
+      result << [chunk.options[:nest_name], chunk.options]
+    end
+    result
   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
+  def each_nested_field_chunk &block
+    each_nested_chunk fields: true, &block
   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
+  def each_nested_chunk content: nil, fields: false, uniq: true, virtual: true, &block
+    return unless block_given?
+    chunks = prepare_nested_chunks content, fields, uniq
+    process_nested_chunks chunks, virtual, &block
   end
 
-  def nest_chunks content=nil
-    content ||= _render_raw
-    card.nest_chunks content
+  def uniq_chunks chunks
+    processed = ::Set.new [card.key]
+    chunks.select do |chunk|
+      key = chunk.referee_name.key
+      ok = !processed.include?(key)
+      processed << key
+      ok
+    end
   end
 
-  def process_tally
-    ::Set.new [card.key]
+  def field_chunks chunks
+    chunks.select { |chunk| field_name?(chunk.referee_name) }
   end
 
-  def field_chunk? chunk
-    chunk.referee_name.to_name.field_of? card.name
+  private
+
+  def prepare_nested_chunks content, fields, uniq
+    chunks = nest_chunks content
+    chunks = field_chunks chunks if fields
+    chunks = uniq_chunks chunks if uniq
+    chunks
   end
 
-  def unique_chunk? chunk
-    key = chunk.referee_name.key
-    return false if @processed.include? key
-    @processed << key
-    true
+  def process_nested_chunks chunks, virtual, &block
+    chunks.each do |chunk|
+      process_nested_chunk chunk, virtual, &block
+    end
   end
 
-  def with_unique_chunks
-    @processed = ::Set.new [card.key]
-    yield
+  def process_nested_chunk chunk, virtual, &block
+    if chunk.referee_card&.virtual?
+      process_nested_virtual_chunk chunk, &block unless virtual
+    else
+      yield chunk
+    end
   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
+  def process_virtual_chunk chunk
+    subformat(chunk.referee_card).each_nested_field_chunk { |sub_chunk| yield sub_chunk }
   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
+  def explicit_edit_fields_config
+    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 process_unique_field? chunk, processed
-    key = chunk.referee_name.key
-    return false if processed.include? key
-    processed << key
-    true
+  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
 end