card-mod-carrierwave 0.11.0

data/lib/carrier_wave/image_card_uploader.rb

@@ -0,0 +1,59 @@
+require "mini_magick"
+
+module CarrierWave
+  # Adds image specific version handling to {FileCardUploader}.
+  # The ImageCardUploader creates five versions of different sizes when it
+  # uploads an imagae file:
+  # icon (16x16), small (75x75), medium (200X200), large (500x500) and
+  # the original size.
+  class ImageCardUploader < FileCardUploader
+    include CarrierWave::MiniMagick
+
+    def path version=nil
+      (version && version != :original) ? versions[version].path : super()
+    end
+
+    version :icon, if: :create_versions?, from_version: :small do
+      process resize_and_pad: [16, 16]
+    end
+    version :small, if: :create_versions?, from_version: :medium do
+      process resize_to_fit: [75, 75]
+    end
+    version :medium, if: :create_versions? do
+      process resize_to_limit: [200, 200]
+    end
+    version :large, if: :create_versions? do
+      process resize_to_limit: [500, 500]
+    end
+
+    # version :small_square, if: :create_versions?,
+    #                        from_version: :medium_square do
+    #   process resize_to_fill: [75, 75]
+    # end
+    # version :medium_square, if: :create_versions? do
+    #   process resize_to_fill: [200, 200]
+    # end
+    #
+    # In case we decide to support the squared versions
+    # we have to update all existing images with the following snippet:
+    # Card.search(type_id: Card::ImageID) do |card|
+    #   card.image.cache_stored_file!
+    #   card.image.recreate_versions!
+    # end
+
+    def identifier
+      full_filename(super())
+    end
+
+    # add 'original' if no version is given
+    def full_filename for_file
+      name = super(for_file)
+      if version_name
+        name
+      else
+        parts = name.split "."
+        "#{parts.shift}-original.#{parts.join('.')}"
+      end
+    end
+  end
+end

data/set/abstract/attachment.rb

@@ -0,0 +1,112 @@
+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

data/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/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/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/set/abstract/attachment/paths.rb

@@ -0,0 +1,58 @@
+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

data/set/abstract/attachment/storage_type.rb

@@ -0,0 +1,170 @@
+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