card 1.101.5 → 1.103.0

data/tmpsets/set/mod014-card-mod-carrierwave/abstract/attachment.rb

@@ -1,121 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Abstract
-# Set: Abstract (Attachment)
-#
-module Attachment;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card-mod-carrierwave/set/abstract/attachment.rb"; end
-attr_writer :empty_ok
-
-def self.included host_class
-  host_class.extend CarrierWave::CardMount
-end
-
-event :select_file_revision, after: :select_action do
-  attachment.retrieve_from_store!(attachment.identifier)
-end
-
-# we need a card id for the path so we have to update db_content when we have
-# an id
-event :correct_identifier, :finalize, on: :create, when: proc { |c| !c.web? } do
-  update_column(:db_content, attachment.db_content)
-  expire
-end
-
-event :save_original_filename, :prepare_to_store, on: :save, when: :file_ready_to_save? do
-  return unless @current_action
-  @current_action.update! comment: original_filename
-end
-
-event :validate_file_exist, :validate, on: :create do
-  return if empty_ok?
-  if will_be_stored_as == :web
-    errors.add "url is missing" if content.blank?
-  elsif !attachment.file.present?
-    errors.add attachment_name, "is missing"
-  end
-end
-
-event :write_identifier, after: :save_original_filename, when: proc { |c| !c.web? } do
-  self.content = attachment.db_content
-end
-
-def file_ready_to_save?
-  attachment.file.present? &&
-    !preliminary_upload? &&
-    !save_preliminary_upload? &&
-    attachment_is_changing?
-end
-
-def item_names _args={} # needed for flexmail attachments.  hacky.
-  [name]
-end
-
-def original_filename
-  return content.split("/").last if web?
-  attachment.original_filename
-end
-
-def unfilled?
-  !attachment.present? && !save_preliminary_upload? && !subcards? && blank_content?
-end
-
-def attachment_changed?
-  send "#{attachment_name}_changed?"
-end
-
-def attachment_is_changing?
-  send "#{attachment_name}_is_changing?"
-end
-
-def attachment_before_act
-  send "#{attachment_name}_before_act"
-end
-
-def create_versions? _new_file
-  true
-end
-
-def empty_ok?
-  @empty_ok
-end
-
-def assign_set_specific_attributes
-  # reset content if we really have something to upload
-  self.content = nil if set_specific[attachment_name.to_s].present?
-  super
-end
-
-def delete_files_for_action action
-  with_selected_action_id(action.id) do
-    attachment.file.delete
-    attachment.versions.each_value do |version|
-      version.file.delete
-    end
-  end
-end
-
-def revision action, before_action=false
-  return unless (result = super)
-  result[:empty_ok] = true
-  result
-end
-
-def attachment_format ext
-  if ext.present? && attachment && (original_ext = attachment.extension.sub(/^\./, ""))
-    if ["file", original_ext].member? ext
-      original_ext
-    elsif (exts = Mime::Types[attachment.content_type])
-      if exts.find { |mt| mt.extensions.member? ext }
-        ext
-      else
-        exts[0].extensions[0]
-      end
-    end
-  end
-rescue => e
-  Rails.logger.info "attachment_format issue: #{e.message}"
-  nil
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card-mod-carrierwave/set/abstract/attachment.rb ~~

data/tmpsets/set/mod014-card-mod-carrierwave/abstract/attachment/cloud.rb

@@ -1,142 +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/ethan/dev/decko/gem/card-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, 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
-end;end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card-mod-carrierwave/set/abstract/attachment/cloud.rb ~~

data/tmpsets/set/mod014-card-mod-carrierwave/abstract/attachment/coded.rb

@@ -1,31 +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/ethan/dev/decko/gem/card-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
-  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
-end;end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card-mod-carrierwave/set/abstract/attachment/coded.rb ~~

data/tmpsets/set/mod014-card-mod-carrierwave/abstract/attachment/local.rb

@@ -1,49 +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/ethan/dev/decko/gem/card-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/ethan/dev/decko/gem/card-mod-carrierwave/set/abstract/attachment/local.rb ~~

data/tmpsets/set/mod014-card-mod-carrierwave/abstract/attachment/paths.rb

@@ -1,67 +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/ethan/dev/decko/gem/card-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/ethan/dev/decko/gem/card-mod-carrierwave/set/abstract/attachment/paths.rb ~~

data/tmpsets/set/mod014-card-mod-carrierwave/abstract/attachment/storage_type.rb

@@ -1,179 +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/ethan/dev/decko/gem/card-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
-  unless known_storage_type? will_be_stored_as
-    errors.add :storage_type, tr(
-      :unknown_storage_type,
-      new_storage_type: @new_storage_type
-    )
-  end
-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 content =~ %r{^:[^/]+/([^.]+)}
-    Regexp.last_match(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 =~ /^\~/
-  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, tr(: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 = {}
-  validate_temporary_storage_type_change opts[:storage_type]
-  %i[storage_type mod bucket].each do |opt_name|
-    next unless opts[opt_name]
-    old_values[opt_name] = instance_variable_get "@#{opt_name}"
-    instance_variable_set "@#{opt_name}", opts[opt_name]
-    @temp_storage_type = true
-  end
-  yield
-ensure
-  @temp_storage_type = false
-  old_values.each do |key, val|
-    instance_variable_set "@#{key}", val
-  end
-end
-
-def temporary_storage_type_change?
-  @temp_storage_type
-end
-
-def validate_temporary_storage_type_change new_storage_type=nil
-  new_storage_type ||= @new_storage_type
-  return unless new_storage_type
-  unless known_storage_type? new_storage_type
-    raise Error, tr(:unknown_storage_type, new_storage_type: new_storage_type)
-  end
-
-  if new_storage_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
-end;end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card-mod-carrierwave/set/abstract/attachment/storage_type.rb ~~