card 1.102.0 → 1.103.0

data/tmpsets/set/mod013-carrierwave/abstract/attachment/cloud.rb

@@ -1,146 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Abstract; module Attachment;
-# Set: Abstract (Attachment, Cloud)
-#
-module Cloud;
-extend Card::Set
-def self.source_location; "/Users/ezl5238/dev/decko/gem/mod/carrierwave/set/abstract/attachment/cloud.rb"; 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 :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, t(:carrierwave_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
-end;end;end;end;end;
-# ~~ generated from /Users/ezl5238/dev/decko/gem/mod/carrierwave/set/abstract/attachment/cloud.rb ~~

data/tmpsets/set/mod013-carrierwave/abstract/attachment/coded.rb

@@ -1,36 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Abstract; module Attachment;
-# Set: Abstract (Attachment, Coded)
-#
-module Coded;
-extend Card::Set
-def self.source_location; "/Users/ezl5238/dev/decko/gem/mod/carrierwave/set/abstract/attachment/coded.rb"; 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 :validate_coded_storage_type, :validate, on: :save, when: :will_become_coded? do
-  storage_type_error :mod_argument_needed_to_save unless mod || @new_mod
-  storage_type_error :codename_needed_for_storage if codename.blank?
-end
-
-def storage_type_error error_name
-  errors.add :storage_type, t("carrierwave_#{error_name}")
-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
-end;end;end;end;end;
-# ~~ generated from /Users/ezl5238/dev/decko/gem/mod/carrierwave/set/abstract/attachment/coded.rb ~~

data/tmpsets/set/mod013-carrierwave/abstract/attachment/local.rb

@@ -1,52 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Abstract; module Attachment;
-# Set: Abstract (Attachment, Local)
-#
-module Local;
-extend Card::Set
-def self.source_location; "/Users/ezl5238/dev/decko/gem/mod/carrierwave/set/abstract/attachment/local.rb"; 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
-
-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
-end;end;end;end;end;
-# ~~ generated from /Users/ezl5238/dev/decko/gem/mod/carrierwave/set/abstract/attachment/local.rb ~~

data/tmpsets/set/mod013-carrierwave/abstract/attachment/paths.rb

@@ -1,68 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Abstract; module Attachment;
-# Set: Abstract (Attachment, Paths)
-#
-module Paths;
-extend Card::Set
-def self.source_location; "/Users/ezl5238/dev/decko/gem/mod/carrierwave/set/abstract/attachment/paths.rb"; end
-MOD_FILE_DIR = "file".freeze
-
-def store_dir
-  will_become_coded? ? coded_dir(@new_mod) : upload_dir
-end
-
-def retrieve_dir
-  coded? ? coded_dir : upload_dir
-end
-
-# place for files of regular file cards
-def upload_dir
-  id ? "#{files_base_dir}/#{id}" : tmp_upload_dir
-end
-
-# place for files of mod file cards
-def coded_dir new_mod=nil
-  dir = File.join mod_dir(new_mod), MOD_FILE_DIR, codename.to_s
-  FileUtils.mkdir_p(dir) unless File.directory?(dir)
-  dir
-end
-
-def mod_dir new_mod=nil
-  mod_name = new_mod || mod
-  dir = Cardio::Mod.dirs.path(mod_name) || (mod_name.to_sym == :test && "test")
-
-  raise Error, "can't find mod \"#{mod_name}\"" unless dir
-
-  dir
-end
-
-def files_base_dir
-  dir = bucket ? bucket_config[:subdirectory] : Card.paths["files"].existent.first
-  dir || files_base_dir_configuration_error
-end
-
-def files_base_dir_configuration_error
-  raise StandardError,
-        "missing directory for file cache (default is `files` in deck root)"
-end
-
-# used in the indentifier
-def file_dir
-  if coded?
-    ":#{codename}"
-  elsif cloud?
-    "(#{bucket})/#{file_id}"
-  else
-    "~#{file_id}"
-  end
-end
-
-def public?
-  who_can(:read).include? Card::AnyoneID
-end
-
-def file_id
-  id? ? id : upload_cache_card.id
-end
-end;end;end;end;end;
-# ~~ generated from /Users/ezl5238/dev/decko/gem/mod/carrierwave/set/abstract/attachment/paths.rb ~~

data/tmpsets/set/mod013-carrierwave/abstract/attachment/storage_type.rb

@@ -1,180 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Abstract; module Attachment;
-# Set: Abstract (Attachment, StorageType)
-#
-module StorageType;
-extend Card::Set
-def self.source_location; "/Users/ezl5238/dev/decko/gem/mod/carrierwave/set/abstract/attachment/storage_type.rb"; end
-attr_writer :bucket, :storage_type
-
-event :storage_type_change, :store, on: :update, when: :storage_type_changed? do
-  # carrierwave stores file if @cache_id is not nil
-  attachment.cache_stored_file!
-  # attachment.retrieve_from_cache!(attachment.cache_name)
-  update_storage_attributes
-  # next line might be necessary to move files to cloud
-
-  # make sure that we get the new identifier
-  # otherwise action_id will return wrong id for new identifier
-  db_content_will_change!
-  write_identifier
-end
-
-event :validate_storage_type, :validate, on: :save do
-  return if known_storage_type? will_be_stored_as
-
-  errors.add :storage_type, unknown_storage_type(@new_storage_type)
-end
-
-def will_be_stored_as
-  @new_storage_type || storage_type
-end
-
-def read_only?
-  web? || (cloud? && bucket_config[:read_only])
-end
-
-def cloud?
-  storage_type == :cloud
-end
-
-def web?
-  storage_type == :web
-end
-
-def local?
-  storage_type == :local
-end
-
-def coded?
-  storage_type == :coded
-end
-
-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?
-  content && (lines = content.split("\n")) && lines.size == 4
-end
-
-def mod
-  @mod ||= coded? && mod_from_content
-end
-
-def mod_from_content
-  if (m = content.match %r{^:[^/]+/([^.]+)})
-    m[1] # current mod_file format
-  else
-    mod_from_deprecated_content
-  end
-end
-
-# old format is still used in card_changes
-def mod_from_deprecated_content
-  return if content.match?(/^~/)
-  return unless (lines = content.split("\n")) && lines.size == 4
-
-  lines.last
-end
-
-def storage_type_from_config
-  valid_storage_type ENV["FILE_STORAGE"] || Cardio.config.file_storage
-end
-
-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 valid_storage_type_list
-  CarrierWave::FileCardUploader::STORAGE_TYPES
-end
-
-def invalid_storage_type! type
-  raise Card::Error, t(:carrierwave_error_invalid_storage_type, type: type)
-end
-
-def storage_type_from_content
-  case content
-  when /^\(/          then :cloud
-  when %r{/^https?:/} then :web
-  when /^~/           then :local
-  when /^:/           then :coded
-  else
-    if deprecated_mod_file?
-      :coded
-    else
-      storage_type_from_config
-    end
-  end
-end
-
-def update_storage_attributes
-  @mod = @new_mod if @new_mod
-  @bucket = @new_bucket if @new_bucket
-  @storage_type = @new_storage_type
-end
-
-def storage_type_changed?
-  @new_bucket || (@new_storage_type && @new_storage_type != storage_type) || @new_mod
-end
-
-def storage_type= value
-  known_storage_type? value
-  if @action == :update # && storage_type != value
-    # we cant update the storage type directly here
-    # if we do then the uploader doesn't find the file we want to update
-    @new_storage_type = value
-  else
-    @storage_type = value
-  end
-end
-
-def with_storage_options opts={}
-  old_values = stash_and_set_storage_options opts
-  validate_temporary_storage_type_change opts[:storage_type]
-  @temp_storage_type = true
-  yield
-ensure
-  @temp_storage_type = false
-  old_values.each { |key, val| instance_variable_set "@#{key}", val }
-end
-
-def stash_and_set_storage_options opts
-  %i[storage_type mod bucket].each_with_object({}) do |opt_name, old_values|
-    next unless opts[opt_name]
-
-    old_values[opt_name] = instance_variable_get "@#{opt_name}"
-    instance_variable_set "@#{opt_name}", opts[opt_name]
-    old_values
-  end
-end
-
-def temporary_storage_type_change?
-  @temp_storage_type
-end
-
-def validate_temporary_storage_type_change type=nil
-  return unless type ||= @new_storage_type
-  raise Error, unknown_storage_type(type) unless known_storage_type? type
-  if type == :coded && codename.blank?
-    raise Error, "codename needed for storage type :coded"
-  end
-end
-
-def known_storage_type? type=storage_type
-  type.in? CarrierWave::FileCardUploader::STORAGE_TYPES
-end
-
-def unknown_storage_type type
-  t :carrierwave_unknown_storage_type, new_storage_type: type
-end
-end;end;end;end;end;
-# ~~ generated from /Users/ezl5238/dev/decko/gem/mod/carrierwave/set/abstract/attachment/storage_type.rb ~~