card 1.19.0 → 1.19.1

data/mod/carrierwave/set/self/admin.rb

@@ -0,0 +1,23 @@
+add_to_basket(
+  :tasks,
+  name: :update_file_storage_locations,
+  execute_policy: -> { Card.update_all_storage_locations },
+  stats: {
+    title: "cards with attachment",
+    count: -> { Card.search(type_id: ["in", FileID, ImageID], return: :count) },
+    link_text: "update storage locations",
+    task: "update_file_storage_locations"
+  }
+)
+
+add_to_basket(
+  :tasks,
+  name: :delete_upload_tmp_files,
+  execute_policy: -> { Card.delete_tmp_files_of_cached_uploads },
+  stats: {
+    title: "tmp files of canceled uploads",
+    count: -> { ::Card.draft_actions_with_attachment },
+    link_text: "delete tmp files",
+    task: "delete_tmp_files_of_cached_uploads"
+  }
+)

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

@@ -8,8 +8,9 @@ module SelectedAction
   end
 
   def last_content_action_id
+    return super if temporary_storage_type_change?
     # find action id from content (saves lookups)
-    db_content.to_s.split(%r{[/\.]})[1]
+    db_content.to_s.split(%r{[/\.]})[-2]
   end
 end
 include SelectedAction
@@ -37,30 +38,29 @@ format :file do
   # returns send_file args.  not in love with this...
   view :core do |_args|
     # this means we only support known formats.  dislike.
-    if (_format = card.attachment_format(params[:format]))
-      if params[:explicit_file] && (r = controller.response)
-        r.headers["Expires"] = 1.year.from_now.httpdate
-        # currently using default "private", because proxy servers could block
-        # needed permission checks
-        # r.headers["Cache-Control"] = "public"
-      end
+    attachment_format = card.attachment_format(params[:format])
+    return _render_not_found unless attachment_format
+    return card.format(:html).render_core(args) if card.remote_storage?
 
-      # formerly supported redirecting to correct file format
-      # elsif ![format, 'file'].member? params[:format]
-      #   path = request.fullpath.sub( /\.#{params[:format]}\b/, '.' + format )
-      #   return redirect_to(path) #card.attachment.url(style) )
-
-      file = selected_file_version
-      [file.path,
-       {
-         type: file.content_type,
-         filename:  "#{card.cardname.safe_key}#{file.extension}",
-         x_sendfile: true,
-         disposition: (params[:format] == "file" ? "attachment" : "inline")
-       }]
-    else
-      _render_not_found
+    if params[:explicit_file] && (r = controller.response)
+      r.headers["Expires"] = 1.year.from_now.httpdate
+      # currently using default "private", because proxy servers could block
+      # needed permission checks
+      # r.headers["Cache-Control"] = "public"
     end
+
+    # formerly supported redirecting to correct file format
+    # elsif ![format, 'file'].member? params[:format]
+    #   path = request.fullpath.sub( /\.#{params[:format]}\b/, '.' + format )
+    #   return redirect_to(path) #card.attachment.url(style) )
+    file = selected_file_version
+    [file.path,
+     {
+       type: file.content_type,
+       filename:  "#{card.cardname.safe_key}#{file.extension}",
+       x_sendfile: true,
+       disposition: (params[:format] == "file" ? "attachment" : "inline")
+     }]
   end
 
   def selected_file_version
@@ -76,6 +76,9 @@ format :html do
   end
 
   view :editor do |args|
+    if card.web? || card.no_upload?
+      return text_field(:content, class: "card-content")
+    end
     file_chooser args
   end
 

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

@@ -10,6 +10,7 @@ format do
   end
 
   view :source do |args|
+    return card.raw_content if card.web?
     style =
       case
       when @mode == :closed then :icon

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

@@ -0,0 +1,67 @@
+# -*- encoding : utf-8 -*-
+
+describe CarrierWave::FileCardUploader do
+  def test_file
+    File.new(File.join(FIXTURES_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
+
+  let(:local_file) { create_file_card :local }
+  let(:coded_file) { Card[:logo] }
+  let(:web_file) { create_file_card :web, "http://web.de/test.txt" }
+
+  describe "#db_content" do
+    context "coded file" do
+      subject { coded_file }
+      it "returns correct identifier" do
+        expect(subject.attachment.db_content)
+          .to eq ":logo/standard.png"
+      end
+
+      it "handles storage options" do
+        expect(subject.attachment.db_content(storage_type: :local))
+          .to eq "~#{subject.id}/#{subject.last_action_id}.png"
+      end
+    end
+
+    context "local file" do
+      subject { local_file }
+      it "returns correct identifier" do
+        expect(subject.attachment.db_content)
+          .to eq "~#{subject.id}/#{subject.last_action_id}.txt"
+      end
+
+      it "handles storage options" do
+        db_content =
+          subject.attachment.db_content(storage_type: :coded, mod: "test_mod")
+        expect(db_content).to eq ":file_card_codename/test_mod.txt"
+      end
+
+      it "without codename fails for storage option :coded" do
+        subject.codename = nil
+        expect do
+          subject.attachment.db_content(storage_type: :coded, mod: "test_mod")
+        end.to raise_error(
+          Card::Error, "codename needed for storage type :coded"
+        )
+      end
+    end
+
+    context "web file" do
+      subject { web_file }
+      it "returns correct identifier" do
+        expect(subject.attachment.db_content)
+          .to eq "http://web.de/test.txt"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,557 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Set::Type::File do
+  def test_file no=1
+    File.new(File.join(FIXTURES_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
+      Card.create! name: "#{card.name}+*self+*read",
+                   content: "[[Anyone Signed in]]"
+    end
+    card
+  end
+  let(:unprotected_file) do
+    create_file_card :local, test_file(2), codename: nil
+  end
+  let(:coded_file) { Card[:logo] }
+  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
+      card.format.render(:source)
+    end
+    context "storage type: protected" do
+      subject { source_view protected_file }
+      it "renders protected url to be processed by wagn" do
+        is_expected.to(
+          eq "/files/~#{protected_file.id}/#{protected_file.last_action_id}.txt"
+        )
+      end
+    end
+
+    context "storage type: unprotected" 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 wagn" do
+        is_expected.to(
+          eq "/files/:#{coded_file.codename}/standard-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"
+      end
+    end
+  end
+
+  context "creating" do
+    it "fails if no file given" do
+      expect 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
+
+    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
+        expect(card).to be_instance_of(Card)
+        expect(card.content).to eq ""
+      end
+    end
+
+    it "handles urls as source" do
+      url = "http://wagn.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$/)
+    end
+
+    context "storage type:" do
+      context "protected" do
+        subject { protected_file }
+        it "stores correct identifier (~<card id>/<action id>.<ext>)" do
+          expect(subject.content)
+            .to eq "~#{subject.id}/#{subject.last_action_id}.txt"
+        end
+
+        it "stores file" do
+          expect(File.exist?(subject.file.path)).to be_truthy
+          expect(subject.file.read.strip).to eq "file1"
+        end
+
+        it "saves original file name as action comment" do
+          expect(subject.last_action.comment).to eq "file1.txt"
+        end
+
+        it "has correct original filename" do
+          expect(subject.original_filename).to eq "file1.txt"
+        end
+
+        it "has correct url" do
+          expect(subject.file.url).to(
+            eq "/files/~#{subject.id}/#{subject.last_action_id}.txt"
+          )
+        end
+
+        it "doesn't create public symlink" do
+          subject
+          expect(public_path_exist?).to be_falsey
+        end
+      end
+
+      context "unprotected" do
+        subject { unprotected_file }
+        it "creates public symlink" do
+          subject
+          expect(public_path_exist?).to be_truthy
+        end
+      end
+
+      context "web" do
+        subject { web_file }
+        it "saves url as identifier" do
+          expect(subject.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.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.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::Loader.mod_dirs.mod "test_mod"
+        end
+        after do
+          FileUtils.rm_rf mod_path
+          Card::Mod::Loader.mod_dirs.mods.delete "test_mod"
+        end
+        let(:file_path) { File.join mod_path, "file", "mod_file", "file.txt" }
+
+        subject do
+          create_file_card :coded, test_file,
+                           codename: "mod_file", mod: "test_mod"
+        end
+        it "stores correct identifier (:<codename>/<mod_name>.<ext>)" do
+          expect(subject.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
+        subject { cloud_file }
+        it "stores correct identifier "\
+           "((<bucket>)/<card id>/<action id>.<ext>)" do
+          expect(subject.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(FIXTURES_PATH, "file1.txt"))
+        Card.create! name: "new card with 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
+    end
+  end
+
+  context "updating" do
+    subject do
+      card = protected_file
+      card.update_attributes! file: test_file(2)
+      card
+    end
+
+    it "updates file" do
+      expect(subject.file.read.strip).to eq "file2"
+    end
+
+    it "updates original file name" do
+      expect(subject.original_filename).to eq "file2.txt"
+    end
+
+    it "updates url" do
+      expect(subject.file.url)
+        .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::Loader.mod_dirs.mod "test_mod"
+      end
+      after do
+        FileUtils.rm_rf mod_path
+        Card::Mod::Loader.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_attributes! file: test_file(2)
+        expect(subject.storage_type).to eq :local
+        expect(subject.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_attributes! file: test_file(2), storage_type: :coded
+        expect(subject.storage_type).to eq :coded
+        expect(subject.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 }
+      it "removes public svmlink" do
+        expect(public_path_exist?).to be_truthy
+        Card::Auth.as_bot do
+          Card.create! name: "#{subject.name}+*self+*read",
+                       content: "[[Anyone Signed In]]"
+        end
+        expect(public_path_exist?).to be_falsey
+      end
+    end
+
+    context "when read rules changed to 'Anyone'" do
+      subject { protected_file }
+      it "creates public symlink" do
+        expect(public_path_exist?).to be_falsey
+        Card::Auth.as_bot do
+          Card["#{subject.name}+*self+*read"].delete
+        end
+        expect(public_path_exist?).to be_truthy
+      end
+    end
+  end
+
+  context "deleting" do
+    it "removes symlink for unprotected files" do
+      pp = unprotected_file.attachment.public_path
+      expect(File.exist?(pp)).to be_truthy
+      Card::Auth.as_bot do
+        unprotected_file.delete!
+      end
+      expect(Dir.exist?(File.dirname(pp))).to be_falsey
+    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(FIXTURES_PATH, "file1.txt")),
+                     storage_type: @storage_type || :cloud
+      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 { subject.update_attributes!(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.content)
+          .to eq "~#{subject.id}/#{subject.last_action_id}.txt"
+        Card::Auth.as_bot do
+          subject.update_attributes! storage_type: :coded, mod: "test_mod",
+                                     codename: "mod_file"
+        end
+        expect(subject.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_attributes! storage_type: :local
+        end
+        expect(subject.content)
+          .to eq "~#{subject.id}/#{subject.last_action_id}.png"
+      end
+    end
+
+    context "from local to cloud" do
+      it "copies file to cloud" do
+        @storage_type = :local
+        expect(subject.content)
+          .to eq "~#{subject.id}/#{subject.last_action_id}.txt"
+        subject.update_attributes! storage_type: :cloud
+
+        expect(subject.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
+
+  describe "#bucket config" do
+    subject do
+      Card.new(name: "test", type_id: Card::FileID,
+               empty_ok: true, storage_type: :cloud,
+               bucket: :test_bucket).bucket_config
+    end
+    let(:bucket_config) do
+      {
+        test_bucket: {
+          provider: "fog/aws",
+          credentials: {
+            provider: "credential_provider",
+            region: "region",
+            host: "host",
+            endpoint: "endpoint",
+            aws_access_key_id: "aws_access_key_id",
+            aws_secret_access_key: "aws_secret_access_key"
+          },
+          subdirectory: "files",
+          directory: "directory",
+          public: true,
+          attributes: { "Cache-Control" => "max-age=#{365.day.to_i}" },
+          authenticated_url_expiration: 180,
+          use_ssl_for_aws: true
+        }
+      }
+    end
+    before do
+      @old_bucket_config = Cardio.config.file_buckets
+      Cardio.config.file_buckets = bucket_config
+    end
+    after do
+      Cardio.config.file_buckets = @old_bucket_config
+      %w(PROVIDER CREDENTIALS_PROVIDER TEST_BUCKET_PROVIDER
+         TEST_BUCKET_CREDENTIALS_PROVIDER).each do |key|
+        ENV.delete key
+      end
+    end
+
+    it "takes config from Cardio.config" do
+      is_expected.to eq bucket_config[:test_bucket]
+    end
+
+    it "raises error if no bucket config given" do
+      Cardio.config.file_buckets = {}
+      expect { subject }.to raise_error(Card::Error)
+    end
+
+    it "it takes config from env variables" do
+      Cardio.config.file_buckets = {}
+      ENV["PROVIDER"] = "env provider"
+      ENV["CREDENTIALS_PROVIDER"] = "env cred provider"
+      is_expected.to eq provider: "env provider",
+                        credentials: { provider:  "env cred provider" }
+    end
+
+    it "overrides Cardio.config with env variables" do
+      ENV["PROVIDER"] = "env provider"
+      ENV["CREDENTIALS_PROVIDER"] = "env cred provider"
+      changed_config = bucket_config[:test_bucket]
+      changed_config[:provider] =  "env provider"
+      changed_config[:credentials][:provider] = "env cred provider"
+      is_expected.to eq changed_config
+    end
+
+    it "prefers bucket specific env variables" do
+      ENV["PROVIDER"] = "ignore"
+      ENV["CREDENTIALS_PROVIDER"] = "ignore"
+      ENV["TEST_BUCKET_PROVIDER"] = "bucket provider"
+      ENV["TEST_BUCKET_CREDENTIALS_PROVIDER"] = "bucket cred provider"
+      changed_config = bucket_config[:test_bucket]
+      changed_config[:provider] =  "bucket provider"
+      changed_config[:credentials][:provider] = "bucket cred provider"
+      is_expected.to eq changed_config
+    end
+
+    it "finds any credential env variable" do
+      ENV["CREDENTIALS_MY_OWN_CLOUD_BUCKET"] = "my provider"
+      ENV["CREDENTIALS_MY_OWN_CLOUD"] = "ignore me"
+      ENV["TEST_BUCKET_CREDENTIALS_MY_OWN_CLOUD"] = "find me"
+      changed_config = bucket_config[:test_bucket]
+      changed_config[:credentials][:my_own_cloud_bucket] =  "my provider"
+      changed_config[:credentials][:my_own_cloud] = "find me"
+      is_expected.to eq changed_config
+    end
+  end
+
+  def public_path_exist?
+    File.exist? public_path
+  end
+
+  def public_path
+    "public/files/~#{subject.id}/#{subject.last_action_id}.txt"
+  end
+
+  let(:directory) { "philipp-test" }
+  def storage_config type=:local
+    Cardio.config.file_storage = type
+    Wagn.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