card 1.99.6 → 1.100.0

data/lib/card/set/trait.rb

@@ -55,17 +55,13 @@ class Card
 
       def define_trait_card trait, opts
         define_method "#{trait}_card" do
-          trait_var "@#{trait}_card" do
-            fetch trait.to_sym, new: opts.clone
-          end
+          fetch trait.to_sym, new: opts.clone, eager_cache: true
         end
       end
 
       def define_trait_reader trait
         define_method trait do
-          trait_var "@#{trait}" do
-            send("#{trait}_card").content
-          end
+          send("#{trait}_card").content
         end
       end
 

data/lib/card/subcards/add.rb

@@ -11,8 +11,7 @@ class Card
       #
       # @example Add a subcard that is added in the integration phase
       #     (and hence doesn't hold up the transaction for the main card)
-      #   add 'spoiler', content: 'John Snow is a Targaryen',
-      #                  transact_in_stage: :integrate
+      #   add 'spoiler', content: 'John Snow is a Targaryen'
       #   add card_obj, delayed: true
 
       def << value
@@ -30,7 +29,7 @@ class Card
 
       def add *args
         case args.first
-        when Card then new_by_card(*args)
+        when Card then new_by_card args.first
         when Hash then add_hash args.first
         else new_by_attributes(*args)
         end
@@ -50,14 +49,14 @@ class Card
       end
       alias_method :add_field, :add_child
 
-      def new_by_card card, opts={}
+      def new_by_card card
         card.supercard = @context_card
         if !card.name.simple? && card.name.field_of?(@context_card.name)
           card.superleft = @context_card
         end
         @keys << card.key
         Card.write_to_soft_cache card
-        card.director = @context_card.director.subdirectors.add(card, opts)
+        card.director = @context_card.director.subdirectors.add card
         card
       end
 
@@ -65,9 +64,8 @@ class Card
         attributes ||= {}
         absolute_name = absolutize_subcard_name name
         subcard_args = extract_subcard_args! attributes
-        t_i_s = attributes.delete(:transact_in_stage)
         card = initialize_by_attributes absolute_name, attributes
-        subcard = new_by_card card, transact_in_stage: t_i_s
+        subcard = new_by_card card
         card.subcards.add subcard_args
         subcard
       end

data/lib/card/subcards/remove.rb

@@ -23,7 +23,7 @@ class Card
 
       def clear_key key
         if (subcard = fetch_subcard key)
-          ActManager.deep_delete subcard.director
+          Director.deep_delete subcard.director
           subcard.current_action&.delete
         end
         Card.cache.soft.delete key

data/lib/card/view.rb

@@ -20,11 +20,11 @@ class Card
   #
   class View
     include Options
-    include ::Card::View::Cache
+    include View::Cache
     include Classy
     include Permission
 
-    extend ::Card::View::Cache::ClassMethods
+    extend View::Cache::ClassMethods
 
     attr_reader :format, :parent, :card
 

data/lib/card/view/cache/stub.rb

@@ -25,7 +25,7 @@ class Card
 
         # @return [Hash]
         def stub_hash
-          { cast: card.cast,
+          { cast: stub_cast,
             view_opts: normalized_options.merge(normalized_visibility_options),
             format_opts: { nest_mode: format.nest_mode,
                            override: root?,
@@ -37,6 +37,12 @@ class Card
           # been replaced with stubs - only to standard nest calls. The override value
           # is used to retain this distinction.
         end
+
+        def stub_cast
+          cast = card.cast
+          cast.delete :content if cast[:content].nil?
+          cast
+        end
       end
     end
   end

data/lib/cardio.rb

@@ -94,7 +94,8 @@ module Cardio
         rescue_all_in_controller: true,
         navbox_match_start_only: true,
 
-        load_strategy: :eval
+        load_strategy: :eval,
+        cache_set_module_list: false
       }
     end
 

data/mod/account/set/abstract/account_field.rb

@@ -8,8 +8,10 @@ end
 
 # force inherit permission on create
 # (cannot be done with rule, because sets are not addressable)
-def applicable_permission_rule_id _direct_rule, action
-  return left_permission_rule_id action if action == :create
-
-  super
+def permission_rule_id action
+  if action == :create
+    left_permission_rule_id action
+  else
+    super
+  end
 end

data/mod/account/set/all/account.rb

@@ -30,6 +30,10 @@ def read_rules
   @read_rules ||= fetch_read_rules
 end
 
+def read_rules_hash
+  @read_rules_hash ||= read_rules.each_with_object({}) { |id, h| h[id] = true }
+end
+
 def fetch_read_rules
   return [] if id == WagnBotID # always_ok, so not needed
 
@@ -63,7 +67,7 @@ def enabled_role_ids
     # workaround for broken migrations
     return fetch_roles unless Card::Codename.exists? :enabled_roles
 
-    role_trait = fetch(:enabled_roles, new: { type_id: SessionID })
+    role_trait = fetch(:enabled_roles, eager_cache: true, new: { type_id: SessionID })
     role_trait.virtual? ? role_trait.item_ids : fetch_roles
   end
 end

data/mod/carrierwave/set/abstract/attachment/cloud.rb

@@ -0,0 +1,133 @@
+event :change_bucket_if_read_only, :initialize,
+      on: :update, when: :change_bucket_if_read_only? do
+  @new_storage_type = storage_type_from_config
+end
+
+event :validate_storage_type_update, :validate, on: :update, when: :cloud? do
+  # FIXME: make it possible to retrieve the file from cloud storage
+  #   to store it somewhere else. Currently, it only works to change the
+  #   storage type if a new file is provided
+  #   i.e. `update storage_type: :local` fails but
+  #        `update storage_type: :local, file: [file handle]` is ok
+  return unless storage_type_changed? && !attachment_is_changing?
+
+  errors.add :storage_type, tr(:moving_files_is_not_supported)
+end
+
+def bucket
+  @bucket ||= cloud? && (new_card_bucket || bucket_from_content || bucket_from_config)
+end
+
+def new_card_bucket
+  return unless new_card?
+  # If the file is assigned before the bucket option we have to
+  # check if there is a bucket options in set_specific.
+  # That happens for exmaple when the file appears before the bucket in the
+  # options hash:
+  #   Card.create file: file_handle, bucket: "my_bucket"
+  set_specific[:bucket] || set_specific["bucket"] || bucket_from_config
+end
+
+def bucket_config
+  @bucket_config ||= load_bucket_config
+end
+
+def load_bucket_config
+  return {} unless bucket
+  bucket_config = Cardio.config.file_buckets&.dig(bucket.to_sym) || {}
+  bucket_config.symbolize_keys!
+  bucket_config[:credentials]&.symbolize_keys!
+  # we don't want :attributes hash symbolized, so we can't use
+  # deep_symbolize_keys
+  ensure_bucket_config do
+    load_bucket_config_from_env bucket_config
+  end
+end
+
+def ensure_bucket_config
+  yield.tap do |config|
+    require_configuration! config
+    require_credentials! config
+  end
+end
+
+def require_configuration! config
+  cant_find_in_bucket! "configuration" unless config.present?
+end
+
+def require_credentials! config
+  cant_find_in_bucket! "credentials" unless config[:credentials]
+end
+
+def cant_find_in_bucket! need
+  raise Card::Error, "couldn't find #{need} for bucket #{bucket}"
+end
+
+def load_bucket_config_from_env config
+  config ||= {}
+  each_config_option_from_env do |key|
+    replace_with_env_variable config, key
+  end
+  credential_config config do |cred_hash|
+    load_bucket_credentials_from_env cred_hash
+  end
+end
+
+def credential_config config
+  config[:credentials] ||= {}
+  yield config[:credentials]
+  config.delete :credentials if config[:credentials].blank?
+  config
+end
+
+def each_config_option_from_env
+  CarrierWave::FileCardUploader::CONFIG_OPTIONS.each do |key|
+    yield key unless key.in? %i[attributes credentials]
+  end
+end
+
+def load_bucket_credentials_from_env cred_config
+  each_credential_from_env do |option|
+    replace_with_env_variable cred_config, option, "credentials"
+  end
+end
+
+def each_credential_from_env
+  regexp = credential_from_env_regexp
+  ENV.each_key do |env_key|
+    next unless (m = regexp.match env_key)
+    yield m[:option].downcase.to_sym
+  end
+end
+
+def credential_from_env_regexp
+  Regexp.new "^(?:#{bucket.to_s.upcase}_)?CREDENTIALS_(?<option>.+)$"
+end
+
+def replace_with_env_variable config, option, prefix=nil
+  env_key = [prefix, option].compact.join("_").upcase
+  new_value = ENV["#{bucket.to_s.upcase}_#{env_key}"] || ENV[env_key]
+  config[option] = new_value if new_value
+end
+
+def bucket_from_content
+  return unless content
+  content.match(/^\((?<bucket>[^)]+)\)/) { |m| m[:bucket] }
+end
+
+def bucket_from_config
+  cnf = Cardio.config
+  cnf.file_default_bucket || cnf.file_buckets&.keys&.first
+end
+
+def change_bucket_if_read_only?
+  cloud? && bucket_config[:read_only] && attachment_is_changing?
+end
+
+def bucket= value
+  if @action == :update
+    @new_bucket = value
+  else
+    @bucket = value
+  end
+end

data/mod/carrierwave/set/abstract/attachment/coded.rb

@@ -0,0 +1,22 @@
+event :lose_coded_status_on_update, :initialize, on: :update, when: :coded? do
+  # unless explicit
+  return if @new_mod
+  @new_storage_type ||= storage_type_from_config
+end
+
+event :validate_coded_storage_type, :validate, on: :save, when: :will_become_coded? do
+  errors.add :storage_type, tr(:mod_argument_needed_to_save) unless mod || @new_mod
+  errors.add :storage_type, tr(:codename_needed_for_storage) if codename.blank?
+end
+
+def will_become_coded?
+  will_be_stored_as == :coded
+end
+
+def mod= value
+  if @action == :update && mod != value
+    @new_mod = value.to_s
+  else
+    @mod = value.to_s
+  end
+end

data/mod/carrierwave/set/abstract/attachment/local.rb

@@ -0,0 +1,40 @@
+
+event :update_public_link_on_create, :integrate, on: :create, when: :local? do
+  update_public_link
+end
+
+event :remove_public_link_on_delete, :integrate, on: :delete, when: :local? do
+  remove_public_links
+end
+
+event :update_public_link, after: :update_read_rule, when: :local? do
+  return if content.blank?
+  if who_can(:read).include? Card::AnyoneID
+    create_public_links
+  else
+    remove_public_links
+  end
+end
+
+private
+
+def create_public_links
+  path = attachment.public_path
+  return if File.exist? path
+  FileUtils.mkdir_p File.dirname(path)
+  File.symlink attachment.path, path unless File.symlink? path
+  create_versions_public_links
+end
+
+def create_versions_public_links
+  attachment.versions.each_value do |version|
+    next if File.symlink? version.public_path
+    File.symlink version.path, version.public_path
+  end
+end
+
+def remove_public_links
+  symlink_dir = File.dirname attachment.public_path
+  return unless Dir.exist? symlink_dir
+  FileUtils.rm_rf symlink_dir
+end

data/mod/carrierwave/set/abstract/attachment/storage_type.rb

@@ -14,10 +14,6 @@ event :storage_type_change, :store, on: :update, when: :storage_type_changed? do
 end
 
 event :validate_storage_type, :validate, on: :save do
-  if will_become_coded?
-    errors.add :storage_type, tr(:mod_argument_needed_to_save) unless mod || @new_mod
-    errors.add :storage_type, tr(:codename_needed_for_storage) if codename.blank?
-  end
   unless known_storage_type? will_be_stored_as
     errors.add :storage_type, tr(
       :unknown_storage_type,
@@ -26,74 +22,10 @@ event :validate_storage_type, :validate, on: :save do
   end
 end
 
-event :validate_storage_type_update, :validate, on: :update do
-  # FIXME: make it possible to retrieve the file from cloud storage
-  #   to store it somewhere else. Currently, it only works to change the
-  #   storage type if a new file is provided
-  #   i.e. `update storage_type: :local` fails but
-  #        `update storage_type: :local, file: [file handle]` is ok
-  if cloud? && storage_type_changed? && !attachment_is_changing?
-    errors.add :storage_type, tr(:moving_files_is_not_supported)
-  end
-end
-
-event :lose_coded_status_on_update, :initialize, on: :update, when: :coded? do
-  # unless explicit
-  return if @new_mod
-  @new_storage_type ||= storage_type_from_config
-end
-
-event :change_bucket_if_read_only, :initialize,
-      on: :update, when: :change_bucket_if_read_only? do
-  @new_storage_type = storage_type_from_config
-end
-
-event :update_public_link_on_create, :integrate, on: :create, when: :local? do
-  update_public_link
-end
-
-event :remove_public_link_on_delete, :integrate, on: :delete, when: :local? do
-  remove_public_links
-end
-
-event :update_public_link, after: :update_read_rule, when: :local? do
-  return if content.blank?
-  if who_can(:read).include? Card::AnyoneID
-    create_public_links
-  else
-    remove_public_links
-  end
-end
-
-def create_public_links
-  path = attachment.public_path
-  return if File.exist? path
-  FileUtils.mkdir_p File.dirname(path)
-  File.symlink attachment.path, path unless File.symlink? path
-  create_versions_public_links
-end
-
-def create_versions_public_links
-  attachment.versions.each do |_name, version|
-    next if File.symlink? version.public_path
-    File.symlink version.path, version.public_path
-  end
-end
-
-def remove_public_links
-  symlink_dir = File.dirname attachment.public_path
-  return unless Dir.exist? symlink_dir
-  FileUtils.rm_rf symlink_dir
-end
-
 def will_be_stored_as
   @new_storage_type || storage_type
 end
 
-def change_bucket_if_read_only?
-  cloud? && bucket_config[:read_only] && attachment_is_changing?
-end
-
 def read_only?
   web? || (cloud? && bucket_config[:read_only])
 end
@@ -114,8 +46,13 @@ def coded?
   storage_type == :coded
 end
 
-def will_become_coded?
-  will_be_stored_as == :coded
+def remote_storage?
+  cloud? || web?
+end
+
+def storage_type
+  @storage_type ||=
+    new_card? ? storage_type_from_config : storage_type_from_content
 end
 
 def deprecated_mod_file?
@@ -141,113 +78,24 @@ def mod_from_deprecated_content
   lines.last
 end
 
-def remote_storage?
-  cloud? || web?
-end
-
-def no_upload?
-  storage_type_from_config == :web
-end
-
-def bucket
-  @bucket ||= cloud? &&
-              (new_card_bucket || bucket_from_content || bucket_from_config)
-end
-
-def new_card_bucket
-  return unless new_card?
-  # If the file is assigned before the bucket option we have to
-  # check if there is a bucket options in set_specific.
-  # That happens for exmaple when the file appears before the bucket in the
-  # options hash:
-  #   Card.create file: file_handle, bucket: "my_bucket"
-  set_specific[:bucket] || set_specific["bucket"] || bucket_from_config
-end
-
-def bucket_config
-  @bucket_config ||= load_bucket_config
-end
-
-def load_bucket_config
-  return {} unless bucket
-  bucket_config = Cardio.config.file_buckets &&
-                  Cardio.config.file_buckets[bucket.to_sym]
-  bucket_config &&= bucket_config.symbolize_keys
-  bucket_config ||= {}
-  # we don't want :attributes hash symbolized, so we can't use
-  # deep_symbolize_keys
-  bucket_config[:credentials] &&= bucket_config[:credentials].symbolize_keys
-  ensure_bucket_config do
-    load_bucket_config_from_env bucket_config
-  end
-end
-
-def ensure_bucket_config
-  config = yield
-  unless config.present?
-    raise Card::Error, "couldn't find configuration for bucket #{bucket}"
-  end
-  unless config[:credentials]
-    raise Card::Error, "couldn't find credentials for bucket #{bucket}"
-  end
-  config
-end
-
-def load_bucket_config_from_env config
-  config ||= {}
-  CarrierWave::FileCardUploader::CONFIG_OPTIONS.each do |key|
-    next if key.in? %i[attributes credentials]
-    replace_with_env_variable config, key
-  end
-  config[:credentials] ||= {}
-  load_bucket_credentials_from_env config[:credentials]
-  config.delete :credentials unless config[:credentials].present?
-  config
+def storage_type_from_config
+  valid_storage_type ENV["FILE_STORAGE"] || Cardio.config.file_storage
 end
 
-def load_bucket_credentials_from_env cred_config
-  cred_opt_pattern =
-    Regexp.new(/^(?:#{bucket.to_s.upcase}_)?CREDENTIALS_(?<option>.+)$/)
-  ENV.keys.each do |env_key|
-    next unless (m = cred_opt_pattern.match(env_key))
-    replace_with_env_variable cred_config, m[:option].downcase.to_sym,
-                              "credentials"
+def valid_storage_type storage_type
+  storage_type.to_sym.tap do |type|
+    invalid_storage_type! type unless type.in? valid_storage_type_list
   end
 end
 
-def replace_with_env_variable config, option, prefix=nil
-  env_key = [prefix, option].compact.join("_").upcase
-  new_value = ENV["#{bucket.to_s.upcase}_#{env_key}"] ||
-              ENV[env_key]
-  config[option] = new_value if new_value
-end
-
-def bucket_from_content
-  return unless content
-  content.match(/^\((?<bucket>[^)]+)\)/) { |m| m[:bucket] }
-end
-
-def bucket_from_config
-  Cardio.config.file_default_bucket ||
-    (Cardio.config.file_buckets&.keys&.first)
+def valid_storage_type_list
+  CarrierWave::FileCardUploader::STORAGE_TYPES
 end
 
-def storage_type
-  @storage_type ||=
-    new_card? ? storage_type_from_config : storage_type_from_content
-end
-
-def storage_type_from_config
-  type = ENV["FILE_STORAGE"] || Cardio.config.file_storage
-  return unless type
-  type = type.to_sym
-  unless type.in? CarrierWave::FileCardUploader::STORAGE_TYPES
-    raise Card::Error,
-          I18n.t(:error_invalid_storage_type,
-                 scope: "mod.carrierwave.set.abstract.attachment",
-                 type: type)
-  end
-  type
+def invalid_storage_type! type
+  raise Card::Error, I18n.t(:error_invalid_storage_type,
+                            scope: "mod.carrierwave.set.abstract.attachment",
+                            type: type)
 end
 
 def storage_type_from_content
@@ -275,14 +123,6 @@ def storage_type_changed?
   @new_bucket || (@new_storage_type && @new_storage_type != storage_type) || @new_mod
 end
 
-def bucket= value
-  if @action == :update
-    @new_bucket = value
-  else
-    @bucket = value
-  end
-end
-
 def storage_type= value
   known_storage_type? value
   if @action == :update #&& storage_type != value
@@ -294,14 +134,6 @@ def storage_type= value
   end
 end
 
-def mod= value
-  if @action == :update && mod != value
-    @new_mod = value.to_s
-  else
-    @mod = value.to_s
-  end
-end
-
 def with_storage_options opts={}
   old_values = {}
   validate_temporary_storage_type_change opts[:storage_type]