curation_concerns 0.1.0 → 0.2.0

data/spec/views/curation_concerns/file_sets/_file_set.html.erb_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe 'curation_concerns/file_sets/_file_set.html.erb' do
+  let(:solr_document) { SolrDocument.new(id: '999',
+                                         has_model_ssim: ['FileSet'],
+                                         thumbnail_path_ss: '/downloads/999?file=thumbnail',
+                                         representative_tesim: ["999"],
+                                         title_tesim: ["My File"]) }
+
+  # Ability is checked in FileSetPresenter#link_name
+  let(:ability) { double(can?: true) }
+  let(:presenter) { CurationConcerns::FileSetPresenter.new(solr_document, ability) }
+
+  before do
+    assign(:presenter, presenter)
+    allow(view).to receive(:blacklight_config).and_return(CatalogController.blacklight_config)
+    allow(view).to receive(:current_search_session).and_return nil
+    allow(view).to receive(:search_session).and_return({})
+    # abilities called in _actions.html.erb
+    allow(view).to receive(:can?).with(:read, kind_of(String)).and_return(true)
+    allow(view).to receive(:can?).with(:edit, kind_of(String)).and_return(true)
+    allow(view).to receive(:can?).with(:destroy, String).and_return(true)
+    render 'curation_concerns/file_sets/file_set.html.erb', file_set: presenter
+  end
+
+  it 'renders the view' do
+    # A thumbnail
+    expect(rendered).to have_selector ".thumbnail img[src='#{download_path(presenter, file: 'thumbnail')}']"
+
+    # Action buttons
+    expect(rendered).to have_selector "a[title=\"Edit My File\"][href='#{edit_polymorphic_path([:curation_concerns, presenter])}']", text: 'Edit'
+    expect(rendered).to have_selector "a[title=\"Rollback to previous version\"][href='#{versions_curation_concerns_file_set_path(presenter)}']", text: 'Rollback'
+    expect(rendered).to have_selector "a[title=\"Delete My File\"][data-method='delete'][href='#{polymorphic_path([:curation_concerns, presenter])}']", text: 'Delete'
+    expect(rendered).to have_link('Download')
+    expect(rendered).to have_selector "a[title='Download \"My File\"'][href='#{download_path(presenter)}']", text: 'Download'
+  end
+end

data/spec/views/curation_concerns/file_sets/show.json.jbuilder_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe 'curation_concerns/file_sets/show.json.jbuilder' do
+  let(:file_set) { create(:file_set) }
+
+  before do
+    assign(:file_set, file_set)
+    render
+  end
+
+  it "renders json of the curation_concern" do
+    json = JSON.parse(rendered)
+    expect(json['id']).to eq file_set.id
+    expect(json['title']).to eq file_set.title
+    expected_fields = file_set.class.fields.select { |f| ![:has_model, :create_date].include? f }
+    expected_fields << :date_created
+    expected_fields.each do |field_symbol|
+      expect(json).to have_key(field_symbol.to_s)
+    end
+  end
+end

data/spec/views/curation_concerns/permissions/confirm.html.erb_spec.rb

@@ -7,26 +7,26 @@ describe 'curation_concerns/permissions/confirm.html.erb' do
     render
   end
 
-  context "when the work is embargoed" do
+  context 'when the work is embargoed' do
     let(:curation_concern) { build(:embargoed_work, embargo_date: '2099-09-26'.to_date) }
 
-    it "should have a message about embargos" do
+    it 'has a message about embargos' do
       expect(rendered).to have_content "You've applied an embargo to this Generic Work, Test title, changing its visibility to Private until September 26th, 2099. Would you like to apply the same embargo to all of the files within the Generic Work as well?"
     end
   end
 
-  context "when the work is leased" do
+  context 'when the work is leased' do
     let(:curation_concern) { build(:leased_work, embargo_date: '2099-09-26'.to_date) }
 
-    it "should have a message about leases" do
+    it 'has a message about leases' do
       expect(rendered).to have_content "You've applied a lease to this Generic Work, Test title, changing its visibility to Open Access until September 26th, 2099. Would you like to apply the same lease to all of the files within the Generic Work as well?"
     end
   end
 
-  context "when the work is not embargoed" do
+  context 'when the work is not embargoed' do
     let(:curation_concern) { build(:work) }
 
-    it "should have a message about visibility" do
+    it 'has a message about visibility' do
       expect(rendered).to have_content "You've changed the permissions on this Generic Work, Test title, making it visible to Private. Would you like change all of the files within the Generic Work to Private as well?"
     end
   end

data/spec/views/error/single_use_error.html.erb_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe 'error/single_use_error.html.erb' do
+  it 'renders without errors' do
+    render file: 'error/single_use_error'
+    expect(rendered).to have_text("Single Use Link Expired or Not Found")
+  end
+end

data/spec/views/layouts/error.html.erb_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe 'layouts/error.html.erb' do
+  it 'renders without errors' do
+    render
+    expect(rendered).to have_css("footer")
+  end
+end

data/spec/views/shared/_add_content.html.erb_spec.rb

@@ -1,42 +1,55 @@
 require 'spec_helper'
 
 describe 'shared/_add_content.html.erb' do
+  before do
+    allow(view).to receive(:current_user).and_return(user)
+  end
 
-  context "for people who can create Works and Collections" do
-    it 'has links to create works and collections' do
-      allow(view).to receive(:current_user).and_return(FactoryGirl.create(:admin))
+  context 'for people who can create Works and Collections' do
+    let(:user) { create(:admin) }
+    before do
       allow(view).to receive(:can?).and_return(true)
-      render partial: 'shared/add_content'
-      CurationConcerns.configuration.curation_concerns.each do |curation_concern_type|
+      render
+    end
+
+    it 'has links to create works and collections' do
+      CurationConcerns.config.curation_concerns.each do |curation_concern_type|
         expect(rendered).to have_link("New #{curation_concern_type.human_readable_type}", href: new_polymorphic_path([:curation_concerns, curation_concern_type]))
       end
-      expect(rendered).to have_link("Add a Collection", href: collections.new_collection_path)
+      expect(rendered).to have_link('Add a Collection', href: collections.new_collection_path)
     end
   end
-  context "for people who can only create Collections" do
-    it 'has links to add collections but not to add works' do
-      allow(view).to receive(:current_user).and_return(FactoryGirl.create(:admin))
+
+  context 'for people who can only create Collections' do
+    let(:user) { create(:admin) }
+    before do
       allow(view).to receive(:can?).and_return(true)
       allow(view).to receive(:can_ever_create_works?).and_return(false)
-      render partial: 'shared/add_content'
-      CurationConcerns.configuration.curation_concerns.each do |curation_concern_type|
+      render
+    end
+
+    it 'has links to add collections but not to add works' do
+      CurationConcerns.config.curation_concerns.each do |curation_concern_type|
         expect(rendered).not_to have_link("New #{curation_concern_type.human_readable_type}", href: new_polymorphic_path([:curation_concerns, curation_concern_type]))
       end
-      expect(rendered).to have_link("Add a Collection", href: collections.new_collection_path)
+      expect(rendered).to have_link('Add a Collection', href: collections.new_collection_path)
     end
   end
 
-  context "for people who cannot create anything" do
-    it 'does not have links to add works or collections' do
-      allow(view).to receive(:current_user).and_return(FactoryGirl.create(:user))
+  context 'for people who cannot create anything' do
+    let(:user) { create(:user) }
+    before do
       allow(view).to receive(:can?).and_return(false)
-      render partial: 'shared/add_content'
-      expect(rendered).not_to have_text("Add")
-      expect(rendered).not_to have_text("Admin")
-      CurationConcerns.configuration.curation_concerns.each do |curation_concern_type|
+      render
+    end
+
+    it 'does not have links to add works or collections' do
+      expect(rendered).not_to have_text('Add')
+      expect(rendered).not_to have_text('Admin')
+      CurationConcerns.config.curation_concerns.each do |curation_concern_type|
         expect(rendered).not_to have_link("New #{curation_concern_type.human_readable_type}", href: new_polymorphic_path([:curation_concerns, curation_concern_type]))
       end
-      expect(rendered).not_to have_link("Add a Collection", href: collections.new_collection_path)
+      expect(rendered).not_to have_link('Add a Collection', href: collections.new_collection_path)
     end
   end
 end

data/spec/views/shared/_my_actions.html.erb_spec.rb

@@ -2,20 +2,32 @@ require 'spec_helper'
 
 describe 'shared/_my_actions.html.erb' do
   include CurationConcerns::SearchPathsHelper
+
+  before do
+    allow(view).to receive(:current_user).and_return(build(:user, email: 'geraldine@example.com'))
+  end
   context "for admins" do
-    it 'has links to edit and add to collections' do
-      allow(view).to receive(:current_user).and_return(FactoryGirl.create(:user))
+    before do
       allow(view).to receive(:can?).and_return(true)
-      render partial: 'shared/my_actions'
+      render
+    end
+
+    it 'has links' do
+      expect(rendered).to have_text 'geraldine@example.com'
       expect(rendered).to have_link("My Works", href: search_path_for_my_works)
       expect(rendered).to have_link("My Collections", href: search_path_for_my_collections)
+      expect(rendered).to have_link("Embargos", href: embargoes_path)
+      expect(rendered).to have_link("Leases", href: leases_path)
     end
   end
+
   context "for non-admins" do
-    it 'does not have links to edit' do
-      allow(view).to receive(:current_user).and_return(FactoryGirl.create(:user))
+    before do
       allow(view).to receive(:can?).and_return(false)
-      render partial: 'shared/my_actions'
+      render
+    end
+    it 'does not have links to edit' do
+      expect(rendered).to have_text 'geraldine@example.com'
       expect(rendered).not_to have_text("My Works")
       expect(rendered).not_to have_text("My Collections")
     end

data/spec/views/single_use_links/new_download.html.erb_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe 'curation_concerns/single_use_links/new_download.html.erb' do
+  let(:user) { FactoryGirl.find_or_create(:jill) }
+
+  let(:f) do
+    file = FileSet.create do |gf|
+      gf.apply_depositor_metadata(user)
+    end
+    Hydra::Works::AddFileToFileSet.call(file, File.open(fixture_path + '/world.png'), :original_file)
+    file
+  end
+
+  let(:hash) { "some-dummy-sha2-hash" }
+
+  before do
+    assign :asset, f
+    assign :link, CurationConcerns::Engine.routes.url_helpers.download_single_use_link_path(hash)
+    render
+  end
+
+  it "has the download link" do
+    expect(rendered).to have_selector "a.download-link"
+  end
+
+  it "has turbolinks disabled in the download link" do
+    expect(rendered).to have_selector "a.download-link[data-no-turbolink]"
+  end
+end

data/spec/views/single_use_links_viewer/show.html.erb_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe 'curation_concerns/single_use_links_viewer/show.html.erb' do
+  let(:f) do
+    file = FileSet.create do |gf|
+      gf.apply_depositor_metadata('jill')
+    end
+    Hydra::Works::AddFileToFileSet.call(file, File.open(fixture_path + '/world.png'), :original_file)
+    file
+  end
+
+  let(:solr_document) { SolrDocument.new(has_model_ssim: ['FileSet']) }
+  let(:ability) { double }
+
+  let(:hash) { "some-dummy-sha2-hash" }
+
+  before do
+    assign :asset, f
+    assign :download_link, CurationConcerns::Engine.routes.url_helpers.download_single_use_link_path(hash)
+    assign :presenter, CurationConcerns::FileSetPresenter.new(solr_document, ability)
+    view.lookup_context.view_paths.push 'app/views/curation_concerns/base'
+    render
+  end
+
+  it "contains a download link" do
+    expect(rendered).to have_selector "a[href^='/single_use_link/download/']"
+  end
+
+  it "has turbolinks disabled in the download link" do
+    expect(rendered).to have_selector "a[data-no-turbolink][href^='/single_use_link/download/']"
+  end
+end

data/tasks/jetty.rake

@@ -1,7 +1,7 @@
 namespace :jetty do
   desc "Copies the default Solr & Fedora configs into the bundled Hydra Testing Server"
   task :config do
-    Rake::Task['curation_concerns:jetty:download_jars'].invoke
+    Rake::Task['hydra_works:jetty:config'].invoke
     Rake::Task["jetty:config_solr"].invoke
   end
 

data/vendor/assets/javascrips/fileupload/jquery.fileupload-process.js

@@ -0,0 +1,175 @@
+/*
+ * jQuery File Upload Processing Plugin
+ * https://github.com/blueimp/jQuery-File-Upload
+ *
+ * Copyright 2012, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ */
+
+/* jshint nomen:false */
+/* global define, require, window */
+
+(function (factory) {
+    'use strict';
+    if (typeof define === 'function' && define.amd) {
+        // Register as an anonymous AMD module:
+        define([
+            'jquery',
+            './jquery.fileupload'
+        ], factory);
+    } else if (typeof exports === 'object') {
+        // Node/CommonJS:
+        factory(require('jquery'));
+    } else {
+        // Browser globals:
+        factory(
+            window.jQuery
+        );
+    }
+}(function ($) {
+    'use strict';
+
+    var originalAdd = $.blueimp.fileupload.prototype.options.add;
+
+    // The File Upload Processing plugin extends the fileupload widget
+    // with file processing functionality:
+    $.widget('blueimp.fileupload', $.blueimp.fileupload, {
+
+        options: {
+            // The list of processing actions:
+            processQueue: [
+                /*
+                {
+                    action: 'log',
+                    type: 'debug'
+                }
+                */
+            ],
+            add: function (e, data) {
+                var $this = $(this);
+                data.process(function () {
+                    return $this.fileupload('process', data);
+                });
+                originalAdd.call(this, e, data);
+            }
+        },
+
+        processActions: {
+            /*
+            log: function (data, options) {
+                console[options.type](
+                    'Processing "' + data.files[data.index].name + '"'
+                );
+            }
+            */
+        },
+
+        _processFile: function (data, originalData) {
+            var that = this,
+                dfd = $.Deferred().resolveWith(that, [data]),
+                chain = dfd.promise();
+            this._trigger('process', null, data);
+            $.each(data.processQueue, function (i, settings) {
+                var func = function (data) {
+                    if (originalData.errorThrown) {
+                        return $.Deferred()
+                                .rejectWith(that, [originalData]).promise();
+                    }
+                    return that.processActions[settings.action].call(
+                        that,
+                        data,
+                        settings
+                    );
+                };
+                chain = chain.pipe(func, settings.always && func);
+            });
+            chain
+                .done(function () {
+                    that._trigger('processdone', null, data);
+                    that._trigger('processalways', null, data);
+                })
+                .fail(function () {
+                    that._trigger('processfail', null, data);
+                    that._trigger('processalways', null, data);
+                });
+            return chain;
+        },
+
+        // Replaces the settings of each processQueue item that
+        // are strings starting with an "@", using the remaining
+        // substring as key for the option map,
+        // e.g. "@autoUpload" is replaced with options.autoUpload:
+        _transformProcessQueue: function (options) {
+            var processQueue = [];
+            $.each(options.processQueue, function () {
+                var settings = {},
+                    action = this.action,
+                    prefix = this.prefix === true ? action : this.prefix;
+                $.each(this, function (key, value) {
+                    if ($.type(value) === 'string' &&
+                            value.charAt(0) === '@') {
+                        settings[key] = options[
+                            value.slice(1) || (prefix ? prefix +
+                                key.charAt(0).toUpperCase() + key.slice(1) : key)
+                        ];
+                    } else {
+                        settings[key] = value;
+                    }
+
+                });
+                processQueue.push(settings);
+            });
+            options.processQueue = processQueue;
+        },
+
+        // Returns the number of files currently in the processsing queue:
+        processing: function () {
+            return this._processing;
+        },
+
+        // Processes the files given as files property of the data parameter,
+        // returns a Promise object that allows to bind callbacks:
+        process: function (data) {
+            var that = this,
+                options = $.extend({}, this.options, data);
+            if (options.processQueue && options.processQueue.length) {
+                this._transformProcessQueue(options);
+                if (this._processing === 0) {
+                    this._trigger('processstart');
+                }
+                $.each(data.files, function (index) {
+                    var opts = index ? $.extend({}, options) : options,
+                        func = function () {
+                            if (data.errorThrown) {
+                                return $.Deferred()
+                                        .rejectWith(that, [data]).promise();
+                            }
+                            return that._processFile(opts, data);
+                        };
+                    opts.index = index;
+                    that._processing += 1;
+                    that._processingQueue = that._processingQueue.pipe(func, func)
+                        .always(function () {
+                            that._processing -= 1;
+                            if (that._processing === 0) {
+                                that._trigger('processstop');
+                            }
+                        });
+                });
+            }
+            return this._processingQueue;
+        },
+
+        _create: function () {
+            this._super();
+            this._processing = 0;
+            this._processingQueue = $.Deferred().resolveWith(this)
+                .promise();
+        }
+
+    });
+
+}));