card 1.91 → 1.92

data/mod/core/chunk/nest.rb

@@ -56,7 +56,7 @@ class Card
             if key == :item
               options_hash[:items] ||= {}
               options_hash[:items][:view] = value
-            elsif Card::View::Options.nest_keys.include? key
+            elsif Card::View::Options.carditect_keys.include? key
               options_hash[key] = value
               # else
               # handle other keys

data/mod/core/chunk/reference.rb

@@ -13,7 +13,7 @@ class Card
             ref_card = fetch_referee_card rendered_name
             ref_card ? ref_card.cardname : rendered_name.to_name
           end
-          @referee_name = @referee_name.to_absolute(card.cardname).to_name
+          @referee_name = @referee_name.absolute(card.cardname).to_name
         end
 
         def referee_card

data/mod/core/chunk/view_stub.rb

@@ -9,6 +9,10 @@ class Card
           idx_char: "<"
         )
 
+        def initialize text, content
+          super
+        end
+
         def interpret match, _content
           @options_json = match[1]
           @stub_hash = JSON.parse(@options_json).symbolize_keys
@@ -33,6 +37,10 @@ class Card
           @stub_hash[:mode] = @stub_hash[:mode].to_sym
         end
 
+        def interpret_override
+          @stub_hash[:override] = @stub_hash[:override] == "true"
+        end
+
         def process_chunk
           @processed = yield @stub_hash
         end

data/mod/core/format/html_format.rb

@@ -17,7 +17,7 @@ class Card
       end
 
       def focal? # meaning the current card is the requested card
-        show_layout? ? main? : @depth.zero?
+        show_layout? ? main? : depth.zero?
       end
 
       def first_head?
@@ -60,8 +60,10 @@ class Card
         elsif (hardcoded_layout = LAYOUTS[name])
           hardcoded_layout
         else
-          "<h1>Unknown layout: #{name}</h1>"\
-          "Built-in Layouts: #{LAYOUTS.keys.join(', ')}"
+          content_tag(:h1, I18n.t(:unknown_layout, scope: "mod.core.format.html_format",
+                                                   name: name)) +
+            I18n.t(:built_in, scope: "mod.core.format.html_format",
+                              build_in_layouts: LAYOUTS.keys.join(', '))
         end
       end
 
@@ -70,6 +72,10 @@ class Card
         s.to_s.gsub(/&/, "&amp;").gsub(/\'/, "&apos;")
          .gsub(/>/, "&gt;").gsub(/</, "&lt;")
       end
+
+      def mime_type
+        "text/html"
+      end
     end
   end
 end

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

@@ -21,7 +21,7 @@ def source_dir
 end
 
 def find_file filename
-  mod_path = Card::Mod::Loader.mod_dirs.path file_content_mod_name
+  mod_path = Card::Mod.dirs.path file_content_mod_name
   file_path = File.join(mod_path, "lib", source_dir, filename)
   return unless File.exist? file_path
   file_path

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

@@ -128,3 +128,37 @@ end
 def success
   Env.success(cardname)
 end
+
+[:name, :db_content, :trash, :type_id].each do |field|
+  define_method "#{field}_before_act" do
+    attribute_before_act field
+  end
+
+  define_method "#{field}_is_changing?" do
+      attribute_is_changing? field
+    end
+end
+
+def attribute_before_act attr
+  if saved_change_to_attribute? attr
+    attribute_before_last_save attr
+  elsif will_save_change_to_attribute? attr
+    mutations_from_database.changed_values[attr]
+  elsif not_in_callback?
+    attribute_was attr
+  else
+    _read_attribute attr
+  end
+end
+
+def not_in_callback? # or in integrate_with_delay stage
+  mutation_tracker.equal?(mutations_from_database)
+end
+
+def attribute_is_changing? attr
+  if not_in_callback?
+    attribute_changed? attr
+  else
+    saved_change_to_attribute?(attr) || will_save_change_to_attribute?(attr)
+  end
+end

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

@@ -26,12 +26,25 @@ def extract_subcard_args! args
   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

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

@@ -0,0 +1,96 @@
+module ClassMethods
+  def retrieve_from_cache cache_key, local_only=false
+    return unless Card.cache
+    if local_only
+      Card.cache.soft.read cache_key
+    else
+      Card.cache.read cache_key
+    end
+  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 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
+  cardname.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!
+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

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

@@ -293,6 +293,14 @@ format :html do
     construct_tabs "tabs"
   end
 
+  view :carousel do
+    bs_carousel unique_id do
+      nest_item_array.each do |rendered_item|
+        item rendered_item
+      end
+    end
+  end
+
   def construct_tabs tab_type
     tabs = { active: {}, paths: {} }
     voo.items[:view] ||= :content
@@ -305,17 +313,17 @@ format :html do
 
   def construct_tab tabs, name, explicit_options
     tab_options = item_view_options explicit_options
-    title = tab_title tab_options[:title], name
-    tabs[:paths][title] = { title: title,
-                            path: nest_path(name, tab_options).html_safe }
+    tabs[:paths][name] = {
+        title: nest(name, view: :title, title: tab_options[:title]),
+        path: nest_path(name, tab_options).html_safe }
     return unless tabs[:active].empty?
-    tabs[:active] = { name: title, content: nest(name, tab_options) }
+    tabs[:active] = { name: name, content: nest(name, tab_options) }
   end
 
-  def tab_title title, name
-    return name unless title
-    name.to_name.title title, @context_names
-  end
+  #def tab_title title, name
+  #  return name unless title
+  #  name.to_name.title title, @context_names
+  #end
 
   # create a path for a nest with respect ot the nest options
   def nest_path name, nest_opts={}

data/mod/core/set/all/{event.rb → event_conditions.rb}

@@ -40,7 +40,7 @@ def single_changed_condition_applies? db_column
     when :type    then "type_id"
     else db_column.to_s
     end
-  @action != :delete && changes[db_column]
+  @action != :delete && attribute_is_changing?(db_column)
 end
 
 def wrong_stage opts

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

@@ -8,7 +8,7 @@ module ClassMethods
   # * database
   # * virtual cards
   #
-  # @param args [Integer, String, Card::Name, Symbol]
+  # @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)
@@ -24,7 +24,7 @@ module ClassMethods
   def fetch *args
     mark, opts = normalize_fetch_args args
     validate_fetch_opts! opts
-    card, needs_caching = fetch_existing mark, opts
+    card, needs_caching = retrieve_existing mark, opts
 
     if (new_card = new_for_cache card, mark, opts)
       card = new_card
@@ -36,257 +36,66 @@ module ClassMethods
     standard_fetch_results card, mark, opts
   end
 
-  # #fetch converts String to Card::Name. That can break in some cases.
-  # For example if you fetch "Siemens" by its key "siemen", you won't get
-  # "Siemens" because "siemen".to_name.key == "sieman"
-  # If you have a key of a real card use this method.
-  def fetch_real_by_key key, opts={}
-    raise Card::Error, "fetch_real_by_key called with new args" if opts[:new]
-
-    # look in cache
-    card = fetch_from_cache_by_key key, opts[:local_only]
-    # look in db if needed
-    if retrieve_from_db?(card, opts)
-      card = fetch_from_db :key, key, opts
-      write_to_cache card, opts if !card.nil? && !card.trash
-    end
-    return if card.nil?
-    card.include_set_modules unless opts[:skip_modules]
-    card
+  # fetch only real (no virtual) cards
+  #
+  # @params *args - see #fetch
+  # @return [Card]
+  def [] *args
+    fetch(*args, skip_virtual: true)
   end
 
-  def standard_fetch_results card, mark, opts
-    if card.new_card?
-      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.name_from_mark! mark, opts
-    end
-    # need to load modules here to call the right virtual? method
-    card.include_set_modules unless opts[:skip_modules]
-    card if opts[:new] || card.known?
+  # fetch real cards without set modules loaded. Should only be used for simple attributes
+  #
+  # @params *args - see #fetch
+  # @return [Card]
+  def quick_fetch *args
+    fetch *args, skip_virtual: true, skip_modules: true
   end
 
-  def fetch_soft mark, opts={}
+  # fetch only from the soft cache
+  #
+  # @params *args - see #fetch
+  # @return [Card]
+  def fetch_soft *args
+    mark, opts = normalize_fetch_args args
     fetch mark, opts.merge(local_only: true)
   end
 
-  def fetch_id *args
-    mark, _opts = normalize_fetch_args args
-    if mark.is_a?(Integer)
-      mark
-    else
-      card = quick_fetch mark.to_s
-      card && card.id
-    end
-  end
-
-  def fetch_name *mark
-    if (card = quick_fetch(mark))
-      card.name
-    elsif block_given?
-      yield
-    end
-  end
-
-  def fetch_type_id *mark
-    (card = quick_fetch(mark)) && card.type_id
-  end
-
-  def quick_fetch *mark
-    fetch mark, skip_virtual: true, skip_modules: true
-  end
-
-  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
-
-  def [] *marks
-    fetch(*marks, skip_virtual: true)
-  end
-
-  def exists? mark
-    card = quick_fetch mark
-    card.present?
-  end
-
-  def known? mark
-    card = fetch mark, skip_modules: true
-    card.present?
-  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 fetch_from_cache cache_key, local_only=false
-    return unless Card.cache
-    if local_only
-      Card.cache.soft.read cache_key
-    else
-      Card.cache.read cache_key
-    end
-  end
-
-  def parse_mark! mark
-    # return mark_type, mark_value, and absolutized mark
-    if mark.is_a? Integer
-      [:id, mark]
-    else
-      [:key, mark.key]
-    end
-  end
-
-  def fetch_existing mark, opts
-    return [nil, false] unless mark.present?
-    mark_type, mark_key = parse_mark! mark
-    needs_caching = false # until proven true :)
-
-    # look in cache
-    card = send "fetch_from_cache_by_#{mark_type}", mark_key, opts[:local_only]
-
-    if retrieve_from_db?(card, opts)
-      # look in db if needed
-      card = fetch_from_db mark_type, mark_key, opts
-      needs_caching = !card.nil? && !card.trash
-    end
-
-    [card, needs_caching]
-  end
-
-  def retrieve_from_db? card, opts
-    card.nil? || (opts[:look_in_trash] && card.new_card? && !card.trash)
-  end
-
-  def fetch_from_cache_by_id id, local_only=false
-    name = fetch_from_cache "~#{id}", local_only
-    fetch_from_cache name, local_only if name
-  end
-
-  def fetch_from_cache_by_key key, local_only=false
-    fetch_from_cache key, local_only
-  end
-
-  def fetch_from_db mark_type, mark_key, opts
-    query = { mark_type => mark_key }
-    query[:trash] = false unless opts[:look_in_trash]
-    card = Card.where(query).take
-    card
-  end
-
-  def deep_fetch args
-    opts = deep_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 opts
-    else
-      mark = args[:id] || opts[:name]
-      Card.fetch mark, look_in_trash: args[:look_in_trash], new: opts
-    end
-  end
-
+  # @return [Card]
   def fetch_from_cast cast
     fetch_args = cast[:id] ? [cast[:id].to_i] : [cast[:name], { new: cast }]
-    Card.fetch(*fetch_args)
-  end
-
-  def cardish cardish
-    if cardish.is_a? Card
-      cardish
-    else
-      fetch cardish, new: {}
-    end
-  end
-
-  def deep_opts args
-    opts = (args[:card] || {}).clone
-    # clone so that original params remain unaltered.  need deeper clone?
-    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[:id])
-    opts
-  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
-
-  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 compose_mark parts, opts={}
-    parts.flatten!
-    return normalize_mark(parts.first, opts) if parts.size == 1
-    parts.map do |p|
-      normalized = normalize_mark p, {}
-      normalized.is_a?(Integer) ? quick_fetch(normalized).name : normalized.to_s
-    end.join("+").to_name
+    fetch *fetch_args
   end
 
-  def normalize_fetch_args args
-    opts = args.last.is_a?(Hash) ? args.pop : {}
-    [compose_mark(args, opts), opts]
-  end
+  #----------------------------------------------------------------------
+  # ATTRIBUTE FETCHING
+  # The following methods optimize fetching of specific attributes
 
-  def normalize_mark mark, opts
-    case mark
-    when Symbol            then require_id_for_codename mark
-    when Integer           then mark.to_i
-    when Card              then mark.cardname
-    when String, SmartName then normalize_stringy_mark mark, opts
-      # there are some situations where this breaks if we use Card::Name
-      # rather than SmartName, which would seem more correct.
-      # very hard to reproduce, not captured in a spec :(
-    end
-  end
-
-  def normalize_stringy_mark mark, opts
-    case mark.to_s
-    when /^\~(\d+)$/  # id, eg "~75"
-      Regexp.last_match[1].to_i
-    when /^\:(\w+)$/  # codename, eg ":options"
-      require_id_for_codename(Regexp.last_match[1].to_sym)
-    else
-      fullname_from_mark mark, opts[:new]
-    end
+  # @params *args - see #fetch
+  # @return [Integer]
+  def fetch_id *args
+    mark, _opts = normalize_fetch_args args
+    return mark if mark.is_a? Integer
+    card = quick_fetch mark.to_s
+    card && card.id
   end
 
-  def require_id_for_codename mark
-    id = Card::Codename[mark]
-    raise Card::Error::NotFound, "missing card with codename: #{mark}" unless id
-    id
+  # @params *args - see #fetch
+  # @return [Card::Name]
+  def fetch_name *mark
+    Card::Name.compose mark
   end
 
-  def fullname_from_mark name, new_opts={}
-    if new_opts && (supercard = new_opts[:supercard])
-      name.to_name.to_absolute_name supercard.name
-    else
-      name.to_name
-    end
+  # @params *args - see #fetch
+  # @return [Integer]
+  def fetch_type_id *mark
+    (card = quick_fetch(mark)) && card.type_id
   end
 end
 
-# ~~~~~~~~~~ Instance ~~~~~~~~~~~~~
+#----------------------------------------------------------------------
+# INSTANCE METHODS
+# fetching from the context of a card
 
 def fetch opts={}
   traits = opts.delete(:trait)
@@ -315,74 +124,6 @@ def handle_default_content opts
   end
 end
 
-def expire_pieces
-  cardname.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!
-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_was].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
-
 def refresh force=false
   return self unless force || frozen? || readonly?
   fresh_card = self.class.find id
@@ -390,16 +131,3 @@ def refresh force=false
   fresh_card
 end
 
-def eager_renew? opts
-  opts[:skip_virtual] && new_card? && opts[:new].present?
-end
-
-def type_known?
-  type_id.present?
-end
-
-def name_from_mark! mark, opts
-  return if opts[:local_only]
-  return unless mark && mark.to_s != name
-  self.name = mark.to_s
-end