card 1.99.6 → 1.100.0

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

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

@@ -0,0 +1,111 @@
+RSpec.describe Card::Set::Abstract::Attachment::Coded do
+  ENV["STORE_CODED_FILES"] = "true"
+
+  let :mod_path do
+    deck_mod_path = Cardio.paths["mod"].existent.last
+    File.join deck_mod_path, "test_mod"
+  end
+
+  let(:codename) { :yeti_skin_image }
+
+  let(:file_card) { Card[codename] }
+
+  before do
+    FileUtils.mkdir_p mod_path
+    Card::Mod.dirs.mod "test_mod"
+  end
+
+  after do
+    FileUtils.rm_rf mod_path
+    Card::Mod.dirs.mods.delete "test_mod"
+  end
+
+  specify "view: source" do
+    expect(file_card.format.render_source)
+      .to eq("/files/:#{codename}/bootstrap-medium.png")
+  end
+
+  describe "creating" do
+    let :file_card do
+      create_file_card :coded, test_file, codename: "mod_file", mod: "test_mod"
+    end
+
+    let(:file_path) { File.join mod_path, "file", "mod_file", "file.txt" }
+
+    it "stores correct identifier (:<codename>/<mod_name>.<ext>)" do
+      expect(file_card.db_content)
+        .to eq ":#{file_card.codename}/test_mod.txt"
+    end
+
+    it "has correct store path" do
+      expect(file_card.file.path).to eq file_path
+    end
+
+    it "has correct original filename" do
+      expect(file_card.original_filename).to eq "file1.txt"
+    end
+
+    it "stores file in mod directory" do
+      file_card
+      expect(File.read(file_path).strip).to eq "file1"
+    end
+
+    it "has correct url" do
+      expect(file_card.file.url).to eq("/files/:#{file_card.codename}/test_mod.txt")
+    end
+  end
+
+  describe "updating" do
+    let :file_card do
+      create_file_card :coded, test_file, codename: "mod_file", mod: "test_mod"
+    end
+
+    let :id_filenames do
+      "#{file_card.id}/#{file_card.last_action_id}"
+    end
+
+    it "changes storage type to default" do
+      with_storage_config :local do
+        file_card.update! file: test_file(2)
+        expect(file_card.storage_type).to eq :local
+        expect(file_card.db_content)
+          .to eq("~#{file_card.id}/#{file_card.last_action_id}.txt")
+      end
+    end
+
+    it "keeps storage type coded if explicitly set" do
+      with_storage_config :local do
+        file_card.update! file: test_file(2), storage_type: :coded
+        expect(file_card.storage_type).to eq(:coded)
+        expect(file_card.db_content).to eq(":#{file_card.codename}/test_mod.txt")
+        expect(file_card.attachment.path).to match(%r{test_mod/file/mod_file/file.txt$})
+        expect(File.read(file_card.attachment.path).strip).to eq "file2"
+      end
+    end
+
+    context "when changing from local to coded" do
+      let(:file_path) { File.join mod_path, "file", "mod_file", "file.txt" }
+      let(:file_card) { create_file_card :local }
+
+      it "copies file to mod" do
+        expect(file_card.db_content).to eq("~#{id_filenames}.txt")
+        Card::Auth.as_bot do
+          file_card.update! storage_type: :coded, mod: "test_mod", codename: "mod_file"
+        end
+        expect(file_card.db_content).to eq(":#{file_card.codename}/test_mod.txt")
+        expect(File.exist?(file_path)).to be_truthy
+      end
+    end
+
+    context "when changing from coded to local" do
+      let(:file_card) { Card[:logo] }
+
+      it "copies file to local file" do
+        Card::Auth.as_bot do
+          file_card.update! storage_type: :local
+        end
+        expect(file_card.db_content).to eq("~#{id_filenames}.svg")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+RSpec.describe Card::Set::Abstract::Attachment::Web do
+  let :file_card do
+    with_storage_config :web do
+      create_file_card :web, nil, content: web_url
+    end
+  end
+
+  let(:web_url) { "http://web.de/web_file.txt" }
+
+  specify "view: core" do
+    expect(file_card.format.render_core)
+      .to have_tag("a[href=\"#{web_url}\"]") do
+        with_text "Download file card"
+      end
+  end
+
+  specify "view: :source" do
+    expect(file_card.format.render_source).to eq(web_url)
+  end
+
+  it "saves url as identifier" do
+    expect(file_card.db_content).to eq(web_url)
+  end
+
+  it "has correct original filename" do
+    expect(file_card.original_filename).to eq("web_file.txt")
+  end
+
+  it "has correct url" do
+    expect(file_card.attachment.url).to eq(web_url)
+  end
+
+  it "accepts url as file argument" do
+    expect(create_file_card(:web, web_url).db_content).to eq(web_url)
+  end
+
+  it "accepts url as remote url argument" do
+    expect(create_file_card(:web, nil, remote_file_url: web_url).db_content)
+      .to eq(web_url)
+  end
+end

data/mod/carrierwave/spec/set/type/file_spec.rb

@@ -1,27 +1,6 @@
 # -*- encoding : utf-8 -*-
 
 RSpec.describe Card::Set::Type::File do
-  DIRECTORY = "deckodev-test"
-  ENV["STORE_CODED_FILES"] = "true"
-
-  def test_file no=1
-    File.new(File.join(CARD_TEST_SEED_PATH, "file#{no}.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
-
-  let(:web_url) { "http://web.de/web_file.txt" }
-  let(:mod_path) do
-    deck_mod_path = Cardio.paths["mod"].existent.last
-    File.join deck_mod_path, "test_mod"
-  end
-
   let(:protected_file) do
     card = create_file_card :local
     Card::Auth.as_bot do
@@ -33,27 +12,6 @@ RSpec.describe Card::Set::Type::File do
   let(:unprotected_file) do
     create_file_card :local, test_file(2), codename: nil
   end
-  let(:coded_file) { Card[:yeti_skin_image] }
-  let(:web_file) do
-    Card::Auth.as_bot do
-      Card.create! name: "file card", type_id: Card::FileID,
-                   content: web_url, storage_type: :web
-    end
-  end
-  let(:cloud_file) do
-    storage_config :cloud
-    card = create_file_card :cloud, test_file, bucket: :test_bucket
-    storage_config :local
-    card
-  end
-
-  describe "view: core" do
-    it "renders source view as link" do
-      core_view = web_file.format(:html)._render_core
-      assert_view_select core_view, "a[href=\"#{web_url}\"]",
-                         text: "Download file card"
-    end
-  end
 
   describe "view: source" do
     def source_view card
@@ -73,38 +31,8 @@ RSpec.describe Card::Set::Type::File do
       subject { source_view unprotected_file }
 
       it "renders relative url" do
-        is_expected.to(
-          eq "/files/~#{unprotected_file.id}/"\
-             "#{unprotected_file.last_action_id}.txt"
-        )
-      end
-    end
-
-    context "storage type: web" do
-      subject { source_view web_file }
-
-      it "renders saved url" do
-        is_expected.to eq web_url
-      end
-    end
-
-    context "storage type: coded" do
-      subject { source_view coded_file }
-
-      it "renders protected url to be processed by decko" do
-        is_expected.to(
-          eq "/files/:#{coded_file.codename}/bootstrap-medium.png"
-        )
-      end
-    end
-
-    context "storage type: cloud" do
-      subject { source_view cloud_file }
-
-      it "renders absolute url to cloud" do
         is_expected
-          .to eq "http://#{DIRECTORY}.s3.amazonaws.com/"\
-                 "files/#{cloud_file.id}/#{cloud_file.last_action_id}.txt"
+          .to eq("/files/~#{unprotected_file.id}/#{unprotected_file.last_action_id}.txt")
       end
     end
   end
@@ -115,14 +43,12 @@ RSpec.describe Card::Set::Type::File do
         Card::Auth.as_bot do
           Card.create! name: "hide and seek", type_id: Card::FileID
         end
-      end.to raise_error ActiveRecord::RecordInvalid,
-                         "Validation failed: File is missing"
+      end.to raise_error ActiveRecord::RecordInvalid, "Validation failed: File is missing"
     end
 
     it "allows no file if 'empty_ok' is true" do
       Card::Auth.as_bot do
-        card = Card.create! name: "hide and seek", type_id: Card::FileID,
-                            empty_ok: true
+        card = Card.create! name: "hide and seek", type_id: Card::FileID, empty_ok: true
         expect(card).to be_instance_of(Card)
         expect(card.content).to eq ""
       end
@@ -130,10 +56,11 @@ RSpec.describe Card::Set::Type::File do
 
     it "handles urls as source" do
       url = "https://decko.org/files/bruce_logo-large-122798.png"
-      storage_config :local
-      Card.create! name: "url test", type_id: Card::FileID, remote_file_url: url
-      expect(Card["url test"].file.size).to be > 0
-      expect(Card["url test"].file.url).to match(/\.png$/)
+      with_storage_config :local do
+        file = (create_file_card :local, nil, remote_file_url: url)&.file
+        expect(file.size).to be > 0
+        expect(file.url).to match(/\.png$/)
+      end
     end
 
     context "storage type:" do
@@ -178,147 +105,15 @@ RSpec.describe Card::Set::Type::File do
           expect(public_path_exist?).to be_truthy
         end
       end
-
-      context "web" do
-        subject { web_file }
-
-        it "saves url as identifier" do
-          expect(subject.db_content).to eq web_url
-        end
-
-        it "has correct original filename" do
-          expect(subject.original_filename).to eq "web_file.txt"
-        end
-
-        it "has correct url" do
-          expect(subject.attachment.url).to eq web_url
-        end
-
-        it "accepts url as file argument" do
-          Card::Auth.as_bot do
-            card = Card.create! name: "file card", type_id: Card::FileID,
-                                file: web_url, storage_type: :web
-            expect(card.db_content).to eq web_url
-          end
-        end
-
-        it "accepts url as remote url argument" do
-          Card::Auth.as_bot do
-            card = Card.create! name: "file card", type_id: Card::FileID,
-                                remote_file_url: web_url, storage_type: :web
-            expect(card.db_content).to eq web_url
-          end
-        end
-      end
-
-      describe "coded" do
-        before do
-          FileUtils.mkdir_p mod_path
-          # file_dir = File.join(mod_path,  "file", "mod_file")
-          # FileUtils.mkdir_p file_dir
-          # File.open(File.join(file_dir, "test_mod.txt"),"w") do |f|
-          #   f.puts "test"
-          # end
-          Card::Mod.dirs.mod "test_mod"
-        end
-        after do
-          FileUtils.rm_rf mod_path
-          Card::Mod.dirs.mods.delete "test_mod"
-        end
-        subject do
-          create_file_card :coded, test_file, codename: "mod_file", mod: "test_mod"
-        end
-
-        let(:file_path) { File.join mod_path, "file", "mod_file", "file.txt" }
-
-        it "stores correct identifier (:<codename>/<mod_name>.<ext>)" do
-          expect(subject.db_content)
-            .to eq ":#{subject.codename}/test_mod.txt"
-        end
-
-        it "has correct store path" do
-          expect(subject.file.path).to eq file_path
-        end
-
-        it "has correct original filename" do
-          expect(subject.original_filename).to eq "file1.txt"
-        end
-
-        it "stores file in mod directory" do
-          subject
-          expect(File.read(file_path).strip).to eq "file1"
-        end
-
-        it "has correct url" do
-          expect(subject.file.url).to(
-            eq "/files/:#{subject.codename}/test_mod.txt"
-          )
-        end
-      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
-    #     #subject { 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
-      describe "cloud" do
-        subject { cloud_file }
-
-        it "stores correct identifier "\
-           "((<bucket>)/<card id>/<action id>.<ext>)" do
-          expect(subject.db_content)
-            .to eq "(test_bucket)/#{subject.id}/#{subject.last_action_id}.txt"
-        end
-
-        it "stores file" do
-          expect(subject.file.read.strip).to eq "file1"
-        end
-
-        it "generates correct absolute url" do
-          expect(subject.file.url)
-            .to eq "http://#{DIRECTORY}.s3.amazonaws.com/"\
-               "files/#{subject.id}/#{subject.last_action_id}.txt"
-        end
-      end
     end
 
     context "with subcards" do
       it "handles file subcards" do
         file = File.open(File.join(CARD_TEST_SEED_PATH, "file1.txt"))
         Card.create! name: "new card with file",
-                     subcards: {
-                       "+my file" => {
-                         content: "ignore content",
-                         type_id: Card::FileID,
-                         file: file
-                       }
-                     }
+                     subcards: { "+my file" => { content: "ignore content",
+                                                 type_id: Card::FileID,
+                                                 file: file } }
         expect(Card["new card with file+my file"].file.file.read.strip)
           .to eq "file1"
       end
@@ -345,39 +140,6 @@ RSpec.describe Card::Set::Type::File do
         .to eq "/files/~#{subject.id}/#{subject.last_action_id}.txt"
     end
 
-    context "if storage type is coded" do
-      before do
-        FileUtils.mkdir_p mod_path
-        Card::Mod.dirs.mod "test_mod"
-      end
-      after do
-        FileUtils.rm_rf mod_path
-        Card::Mod.dirs.mods.delete "test_mod"
-      end
-
-      subject do
-        create_file_card :coded, test_file, codename: "mod_file", mod: "test_mod"
-      end
-
-      it "changes storage type to default" do
-        storage_config :local
-        subject.update! file: test_file(2)
-        expect(subject.storage_type).to eq :local
-        expect(subject.db_content)
-          .to eq "~#{subject.id}/#{subject.last_action_id}.txt"
-      end
-      it "keeps storage type coded if explicitly set" do
-        storage_config :local
-        subject.update! file: test_file(2), storage_type: :coded
-        expect(subject.storage_type).to eq :coded
-        expect(subject.db_content)
-          .to eq ":#{subject.codename}/test_mod.txt"
-        expect(subject.attachment.path)
-          .to match(%r{test_mod/file/mod_file/file.txt$})
-        expect(File.read(subject.attachment.path).strip).to eq "file2"
-      end
-    end
-
     context "when read rules are restricted" do
       subject { unprotected_file }
 
@@ -415,82 +177,6 @@ RSpec.describe Card::Set::Type::File do
     end
   end
 
-  context "when changing storage type" do
-    subject do
-      Card::Auth.as_bot do
-        Card.create! name: "file card", type_code: "file",
-                     file: File.new(File.join(CARD_TEST_SEED_PATH, "file1.txt")),
-                     storage_type: @storage_type || :cloud,
-                     bucket: :test_bucket
-      end
-    end
-
-    context "from cloud to local" do
-      before { storage_config :cloud }
-      after { Cardio.config.file_storage = :local }
-      it "copies file to local file system" do
-        # not yet supported
-        expect { Card[subject.name].update!(storage_type: :local) }
-          .to raise_error(ActiveRecord::RecordInvalid)
-        # expect(subject.content)
-        #   .to eq "~#{subject.id}/#{subject.last_action_id - 1}.txt"
-        # expect(File.read(subject.file.retrieve_path)).to eq "file1"
-      end
-    end
-
-    context "from local to coded" do
-      before do
-        FileUtils.mkdir_p mod_path
-      end
-      after do
-        FileUtils.rm_rf mod_path
-      end
-      let(:file_path) { File.join mod_path, "file", "mod_file", "file.txt" }
-
-      it "copies file to mod" do
-        @storage_type = :local
-        expect(subject.db_content)
-          .to eq "~#{subject.id}/#{subject.last_action_id}.txt"
-        Card::Auth.as_bot do
-          subject.update! storage_type: :coded, mod: "test_mod", codename: "mod_file"
-        end
-        expect(subject.db_content)
-          .to eq ":#{subject.codename}/test_mod.txt"
-        expect(File.exist?(file_path)).to be_truthy
-      end
-    end
-
-    context "from coded to local" do
-      subject { Card[:logo] }
-
-      it "copies file to mod" do
-        @storage_type = :local
-        Card::Auth.as_bot do
-          subject.update! storage_type: :local
-        end
-        expect(subject.db_content)
-          .to eq "~#{subject.id}/#{subject.last_action_id}.svg"
-      end
-    end
-
-    context "from local to cloud" do
-      it "copies file to cloud" do
-        @storage_type = :local
-        expect(subject.db_content)
-          .to eq "~#{subject.id}/#{subject.last_action_id}.txt"
-        subject.update! storage_type: :cloud
-
-        expect(subject.db_content).to eq(
-          "(test_bucket)/#{subject.id}/#{subject.last_action_id}.txt"
-        )
-        url = subject.file.url
-        expect(url).to match(/^http/)
-        file_content = open(url).read
-        expect(file_content.strip).to eq "file1"
-      end
-    end
-  end
-
   def public_path_exist?
     File.exist? public_path
   end
@@ -498,28 +184,4 @@ RSpec.describe Card::Set::Type::File do
   def public_path
     "public/files/~#{subject.id}/#{subject.last_action_id}.txt"
   end
-
-  # expects access keys in card/spec/support/bucket_credentials.yml for the
-  # bucket defined in `directory` in the following format:
-  # aws:
-  #   provider: AWS
-  #   aws_access_key_id: ...
-  #   aws_secret_access_key: ...
-  #   region: eu-central-1
-
-  def storage_config type=:local
-    Cardio.config.file_storage = type
-    # config.file_default_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
 end