card 1.99.2 → 1.100.0

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]

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

@@ -54,7 +54,7 @@ end
 
 # at some point uploaded files of canceled file card creation
 # should be deleted. We do this when ever an new file is created.
-event :clear_draft_files, :integrate_with_delay, on: :create do
+event :clear_draft_files, :integrate_with_delay, priority: 100, on: :create do
   Card.delete_tmp_files_of_cached_uploads
 end
 

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

@@ -0,0 +1,3 @@
+def no_upload?
+  web? || storage_type_from_config == :web
+end

data/mod/carrierwave/set/type/file.rb

@@ -81,18 +81,23 @@ format :html do
     end
   end
 
+  view :input do
+    if card.no_upload?
+      text_field :content, class: "d0-card-content"
+    else
+      haml :file_chooser, action_text: file_chooser_action_text
+    end
+  end
+
+  view :preview_editor, unknown: true, cache: :never do
+    haml :preview_editor
+  end
+
   def file_chooser_action_text
     action = card.new_card? ? "Add" : "Replace"
     "#{action} #{humanized_attachment_name}..."
   end
 
-  view :input do
-    if card.web? || card.no_upload?
-      return text_field(:content, class: "d0-card-content")
-    end
-    haml :file_chooser, action_text: file_chooser_action_text
-  end
-
   def humanized_attachment_name
     card.attachment_name.to_s.humanize
   end
@@ -108,8 +113,4 @@ format :html do
   def preview_editor_delete_text
     tr :delete
   end
-
-  view :preview_editor, unknown: true, cache: :never do
-    haml :preview_editor
-  end
 end

data/mod/carrierwave/set/type/image.rb

@@ -64,9 +64,7 @@ format do
     voo.size = :original if voo.size == :full
     voo.size
   end
-end
 
-format do
   view :inline do
     _render_core
   end

data/mod/carrierwave/spec/lib/carrier_wave/file_card_uploader_spec.rb

@@ -1,20 +1,6 @@
 # -*- encoding : utf-8 -*-
 
-describe CarrierWave::FileCardUploader do
-  def test_file
-    File.new(File.join(CARD_TEST_SEED_PATH, "file1.txt"))
-  end
-
-  def create_file_card storage_type, file=test_file, opts={}
-    Card::Auth.as_bot do
-      Card.create! opts.reverse_merge(name: "file card",
-                                      type_id: Card::FileID,
-                                      file: file,
-                                      storage_type: storage_type,
-                                      codename: "file_card_codename")
-    end
-  end
-
+RSpec.describe CarrierWave::FileCardUploader do
   let(:local_file) { create_file_card :local }
   let(:coded_file) { Card[:logo] }
   let(:web_file) { create_file_card :web, "http://web.de/test.txt" }

data/mod/carrierwave/spec/set/abstract/attachment/cloud_spec.rb

@@ -0,0 +1,109 @@
+# -*- encoding : utf-8 -*-
+
+RSpec.describe Card::Set::Abstract::Attachment::Cloud do
+  DIRECTORY = "deckodev-test".freeze
+
+  let :file_card do
+    with_storage_config :cloud do
+      ensure_test_bucket
+      create_file_card :cloud, test_file, bucket: :test_bucket
+    end
+  end
+
+  let(:cloud_url) { "http://#{DIRECTORY}.s3.amazonaws.com/files/#{file_path}" }
+
+  def ensure_test_bucket
+    Decko.config.file_buckets = {
+      test_bucket: {
+        provider: "fog/aws",
+        credentials: bucket_credentials(:aws),
+        subdirectory: "files",
+        directory: DIRECTORY,
+        public: true,
+        attributes: { "Cache-Control" => "max-age=#{365.day.to_i}" },
+        authenticated_url_expiration: 180
+      }
+    }
+  end
+
+  def file_path
+    "#{file_card.id}/#{file_card.last_action_id}.txt"
+  end
+
+  describe "db_content" do
+    it "stores correct identifier ((<bucket>)/<card id>/<action id>.<ext>)" do
+      expect(file_card.db_content).to eq("(test_bucket)/#{file_path}")
+    end
+  end
+
+  describe "file object" do
+    it "stores file" do
+      expect(file_card.file.read.strip).to eq "file1"
+    end
+
+    it "generates correct absolute url" do
+      expect(file_card.file.url).to eq(cloud_url)
+    end
+  end
+
+  describe "view: source" do
+    it "renders absolute url to cloud" do
+      expect(file_card.format.render_source).to eq(cloud_url)
+    end
+  end
+
+  context "when changing storage type to cloud" do
+    let(:file_card) { create_file_card :local }
+
+    it "works" do
+      # local
+      expect(file_card.db_content).to eq "~#{file_path}"
+
+      # cloud
+      ensure_test_bucket
+      file_card.update! storage_type: :cloud
+      expect(file_card.db_content).to eq("(test_bucket)/#{file_path}")
+      url = file_card.file.url
+      expect(url).to eq(cloud_url)
+      expect(open(url).read.strip).to eq "file1"
+    end
+  end
+
+  it "copies file to local file system" do
+    # not yet supported
+    expect { Card[file_card.name].update!(storage_type: :local) }
+      .to raise_error(ActiveRecord::RecordInvalid)
+  end
+
+  #   describe "cloud" do
+  #     before(:context) do
+  #       storage_config :cloud
+  #       @cloud_card = create_file_card :cloud, test_file, bucket: :test_bucket
+  #       storage_config :local
+  #     end
+  #     after(:context) do
+  #       Card::Auth.as_bot do
+  #         update "file card", codename: nil
+  #         Card["file card"].delete!
+  #       end
+  #     end
+  #     #file_card { cloud_file }
+  #
+  #     it "stores correct identifier "\
+  #        "((<bucket>)/<card id>/<action id>.<ext>)" do
+  #       expect(@cloud_card.content)
+  #         .to eq "(test_bucket)/#{@cloud_card.id}/#{@cloud_card.last_action_id}.txt"
+  #     end
+  #
+  #     it "stores file" do
+  #       expect(@cloud_card.file.read.strip).to eq "file1"
+  #     end
+  #
+  #     it "generates correct absolute url" do
+  #       expect(@cloud_card.file.url)
+  #         .to eq "http://#{DIRECTORY}.s3.amazonaws.com/"\
+  #            "files/#{@cloud_card.id}/#{@cloud_card.last_action_id}.txt"
+  #     end
+  #   end
+  # end
+end