blacklight-spotlight 0.32.0 → 0.33.0

data/spec/uploaders/spotlight/featured_image_uploader_spec.rb

@@ -0,0 +1,30 @@
+describe Spotlight::FeaturedImageUploader do
+  let(:mounter) { FactoryGirl.create(:featured_image) }
+  subject(:featured_image_uploader) { described_class.new(mounter, 'mounted_as') }
+
+  describe '#extension_white_list' do
+    it 'is the configured array of approved extension to be uploaded' do
+      expect(featured_image_uploader.extension_white_list).to eq Spotlight::Engine.config.allowed_upload_extensions
+    end
+  end
+
+  describe '#store_dir' do
+    let(:store_dir) { featured_image_uploader.store_dir }
+
+    it 'is prefixed with "uploads/spotlight"' do
+      expect(store_dir).to start_with 'uploads/spotlight/'
+    end
+
+    it "includes the mounter's class name" do
+      expect(store_dir).to match '/featured_image/'
+    end
+
+    it 'includes the mounted_as option' do
+      expect(store_dir).to match '/mounted_as/'
+    end
+
+    it "ends with the mounter's id" do
+      expect(store_dir).to end_with "/#{mounter.id}"
+    end
+  end
+end

data/spec/views/_user_util_links.html.erb_spec.rb

@@ -32,7 +32,7 @@ describe '_user_util_links', type: :view do
     it 'renders the links' do
       render
       expect(rendered).to have_link 'Feedback'
-      expect(rendered).to_not have_link 'Dashboard'
+      expect(rendered).to_not have_link 'Exhibit dashboard'
       expect(rendered).to have_link 'Sign out'
     end
   end
@@ -40,6 +40,7 @@ describe '_user_util_links', type: :view do
   describe 'when user is a curator' do
     let(:current_user) { Spotlight::Engine.user_class.new }
     before do
+      allow(view).to receive(:can?).with(:manage, Spotlight::Site).and_return(false)
       allow(view).to receive(:can?).with(:update, current_exhibit).and_return(false)
       allow(view).to receive(:can?).with(:create, Spotlight::Exhibit).and_return(false)
       allow(view).to receive(:can?).with(:curate, current_exhibit).and_return(true)
@@ -47,7 +48,7 @@ describe '_user_util_links', type: :view do
     it 'renders the links' do
       render
       expect(rendered).to have_link 'Feedback'
-      expect(rendered).to have_link 'Dashboard'
+      expect(rendered).to have_link 'Exhibit dashboard'
       expect(rendered).to have_link 'Sign out'
     end
   end
@@ -55,6 +56,7 @@ describe '_user_util_links', type: :view do
   describe 'when user is an admin' do
     let(:current_user) { Spotlight::Engine.user_class.new }
     before do
+      allow(view).to receive(:can?).with(:manage, Spotlight::Site).and_return(false)
       allow(view).to receive(:can?).with(:update, current_exhibit).and_return(true)
       allow(view).to receive(:can?).with(:create, Spotlight::Exhibit).and_return(false)
       allow(view).to receive(:can?).with(:curate, current_exhibit).and_return(true)
@@ -62,7 +64,7 @@ describe '_user_util_links', type: :view do
     it 'renders the links' do
       render
       expect(rendered).to have_link 'Feedback'
-      expect(rendered).to have_link 'Dashboard'
+      expect(rendered).to have_link 'Exhibit dashboard'
       expect(rendered).to have_link 'Sign out'
     end
   end
@@ -70,6 +72,7 @@ describe '_user_util_links', type: :view do
   describe 'when user is a site-wide admin' do
     let(:current_user) { Spotlight::Engine.user_class.new }
     before do
+      allow(view).to receive(:can?).with(:manage, Spotlight::Site).and_return(true)
       allow(view).to receive(:can?).with(:update, current_exhibit).and_return(true)
       allow(view).to receive(:can?).with(:create, Spotlight::Exhibit).and_return(true)
       allow(view).to receive(:can?).with(:curate, current_exhibit).and_return(true)
@@ -77,8 +80,9 @@ describe '_user_util_links', type: :view do
     it 'renders the links' do
       render
       expect(rendered).to have_link 'Feedback'
-      expect(rendered).to have_link 'Dashboard'
-      expect(rendered).to have_link 'Create Exhibit'
+      expect(rendered).to have_link 'Site administration'
+      expect(rendered).to have_link 'Exhibit dashboard'
+      expect(rendered).to have_link 'Create new exhibit'
       expect(rendered).to have_link 'Sign out'
     end
   end

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

@@ -31,7 +31,10 @@ describe 'shared/_masthead', type: :view do
   end
 
   context 'with an exhibit masthead' do
-    let(:masthead) { FactoryGirl.create(:masthead) }
+    let(:iiif_url) { 'http://test.host/1/10,10,130,1210/1800,180/0/default.jpg' }
+    let(:masthead) do
+      FactoryGirl.create(:masthead, iiif_tilesource: 'http://test.host/1', iiif_region: '10,10,130,1210')
+    end
 
     before do
       exhibit.masthead = masthead
@@ -47,7 +50,7 @@ describe 'shared/_masthead', type: :view do
       render
       expect(rendered).to have_selector '.background-container'
       expect(rendered).to have_selector '.background-container-gradient'
-      expect(rendered).to match(/background-image: url\('#{masthead.image.cropped.url}'\)/)
+      expect(rendered).to match(/background-image: url\('#{iiif_url}'\)/)
     end
   end
 

data/spec/views/spotlight/browse/_search.html.erb_spec.rb

@@ -4,7 +4,7 @@ describe 'spotlight/browse/search', type: :view do
   let(:exhibit) { FactoryGirl.create(:exhibit) }
   before do
     allow(search).to receive_messages(documents: double(size: 15))
-    allow(search).to receive_message_chain(:thumbnail, :image, thumb: '/some/image')
+    allow(search).to receive_message_chain(:thumbnail, iiif_url: '/some/image')
   end
 
   before do
@@ -13,7 +13,7 @@ describe 'spotlight/browse/search', type: :view do
 
   it 'displays the image' do
     render partial: 'spotlight/browse/search', locals: { search: search }
-    expect(response).to have_selector 'a img'
+    expect(response).to have_selector 'a img[src="/some/image"]'
   end
 
   it 'has a heading' do

data/spec/views/spotlight/contacts/edit.html.erb_spec.rb

@@ -9,18 +9,15 @@ describe 'spotlight/contacts/edit.html.erb' do
   before do
     allow(view).to receive(:exhibit_contacts_path).and_return('/exhibit/1/contacts')
     allow(view).to receive(:exhibit_about_pages_path).and_return('/exhibit/admin/about')
+    allow(view).to receive(:contact_images_path).and_return('/contact_images')
     assign(:contact, contact)
     assign(:exhibit, exhibit)
     allow(view).to receive(:current_exhibit).and_return(exhibit)
   end
 
-  it 'has a photo field' do
+  it 'has an IIIF crop' do
     render
-    expect(rendered).to have_content 'Photo'
-  end
-
-  it 'has a cropbox' do
-    render
-    expect(rendered).to have_selector '#contact_avatar_cropbox'
+    expect(rendered).to have_content 'Upload an image'
+    expect(rendered).to have_selector '#contact_avatar_attributes_iiif_cropper'
   end
 end

data/spec/views/spotlight/metadata_configurations/_metadata_field.html.erb_spec.rb

@@ -12,12 +12,17 @@ describe 'spotlight/metadata_configurations/_metadata_field', type: :view do
     )
   end
 
-  let(:facet_field) { Blacklight::Configuration::FacetField.new }
+  let(:field) { Blacklight::Configuration::Field.new immutable: OpenStruct.new(another_view_type: false) }
   let(:builder) { ActionView::Helpers::FormBuilder.new 'z', nil, view, {} }
 
   it 'uses the index_field_label helper to render the label' do
     allow(view).to receive(:index_field_label).with(nil, 'some_key').and_return 'Some label'
-    render partial: p, locals: { key: 'some_key', config: facet_field, f: builder }
+    render partial: p, locals: { key: 'some_key', config: field, f: builder }
     expect(rendered).to have_selector '.field-label', text: 'Some label'
   end
+
+  it 'marks views as disabled if they are immutable' do
+    render partial: p, locals: { key: 'some_key', config: field, f: builder }
+    expect(rendered).to have_selector 'input[disabled][name="z[some_key][another_view_type]"]'
+  end
 end

data/spec/views/spotlight/pages/edit.html.erb_spec.rb

@@ -3,7 +3,9 @@ describe 'spotlight/pages/edit', type: :view do
   let(:page) { stub_model(Spotlight::FeaturePage, exhibit: exhibit) }
   before do
     assign(:page, page)
-    allow(view).to receive_messages(default_thumbnail_jcrop_options: {}, available_index_fields: [], available_view_fields: [])
+    allow(view).to receive_messages(featured_images_path: '/foo',
+                                    available_index_fields: [],
+                                    available_view_fields: [])
   end
 
   it 'renders the edit page form' do

data/spec/views/spotlight/pages/new.html.erb_spec.rb

@@ -2,7 +2,9 @@ describe 'spotlight/pages/new', type: :view do
   let(:exhibit) { stub_model(Spotlight::Exhibit) }
   before do
     assign(:page, stub_model(Spotlight::FeaturePage, exhibit: exhibit).as_new_record)
-    allow(view).to receive_messages(default_thumbnail_jcrop_options: {}, available_index_fields: [], available_view_fields: [])
+    allow(view).to receive_messages(featured_images_path: '/foo',
+                                    available_index_fields: [],
+                                    available_view_fields: [])
   end
 
   it 'renders new page form' do

data/spec/views/spotlight/searches/_search.html.erb_spec.rb

@@ -10,11 +10,12 @@ describe 'spotlight/searches/_search.html.erb', type: :view do
                                          }
                                        })
   end
+  let(:thumbnail) { double(id: '7777', iiif_url: '/images/7777/full/400,300/0/default.jpg') }
 
   before do
     allow(view).to receive(:edit_search_path).and_return('/edit')
     allow(view).to receive(:search_path).and_return('/search')
-    allow(search).to receive_message_chain(:thumbnail, :image, thumb: '/some/image')
+    allow(search).to receive(:thumbnail).and_return(thumbnail)
     allow(search).to receive(:count).and_return(15)
     allow(search).to receive(:params).and_return({})
 
@@ -29,7 +30,7 @@ describe 'spotlight/searches/_search.html.erb', type: :view do
     # rubocop:enable RSpec/InstanceVariable
     expect(rendered).to have_selector "li[data-id='99']"
     expect(rendered).to have_selector '.panel-heading .main .title', text: 'Title1'
-    expect(rendered).to have_selector 'img[src="/some/image"]'
+    expect(rendered).to have_selector 'img[src="/images/7777/full/400,300/0/default.jpg"]'
     expect(rendered).to have_selector 'input[type=hidden][data-property=weight]', visible: false
   end
 end

data/spec/views/spotlight/searches/edit.html.erb_spec.rb

@@ -1,4 +1,3 @@
-
 describe 'spotlight/searches/edit.html.erb', type: :view do
   let(:blacklight_config) do
     Blacklight::Configuration.new do |config|
@@ -10,15 +9,17 @@ describe 'spotlight/searches/edit.html.erb', type: :view do
     stub_model(Spotlight::Search, exhibit: exhibit,
                                   id: 99, title: 'Title1', query_params: { f: { 'some_field' => ['xyz'] } })
   end
+
   before do
     allow(view).to receive(:search_action_path).and_return('/search')
+    allow(view).to receive(:mastheads_path).and_return('/mastheads')
+    allow(view).to receive(:featured_images_path).and_return('/featured_images')
     allow(view).to receive(:exhibit_search_path).and_return('/search')
     allow(view).to receive(:exhibit_searches_path).and_return('/searches')
     allow(view).to receive(:blacklight_config).and_return(blacklight_config)
     assign(:exhibit, exhibit)
     assign(:search, search)
     allow(view).to receive(:current_exhibit).and_return(exhibit)
-    allow(view).to receive_messages(default_masthead_jcrop_options: {}, default_thumbnail_jcrop_options: {})
   end
 
   it 'renders a form w/ the appropriate autocomplete data attribute' do

data/vendor/assets/javascripts/leaflet-areaselect.js

@@ -0,0 +1,184 @@
+L.AreaSelect = L.Class.extend({
+    includes: L.Mixin.Events,
+
+    options: {
+        width: 200,
+        height: 300,
+        keepAspectRatio: false,
+    },
+
+    initialize: function(options) {
+        L.Util.setOptions(this, options);
+
+        this._width = this.options.width;
+        this._height = this.options.height;
+    },
+
+    addTo: function(map) {
+        this.map = map;
+        this._createElements();
+        this._render();
+        return this;
+    },
+
+    getBounds: function() {
+        var size = this.map.getSize();
+        var topRight = new L.Point();
+        var bottomLeft = new L.Point();
+
+        bottomLeft.x = Math.round((size.x - this._width) / 2);
+        topRight.y = Math.round((size.y - this._height) / 2);
+        topRight.x = size.x - bottomLeft.x;
+        bottomLeft.y = size.y - topRight.y;
+
+        var sw = this.map.containerPointToLatLng(bottomLeft);
+        var ne = this.map.containerPointToLatLng(topRight);
+
+        return new L.LatLngBounds(sw, ne);
+    },
+
+    remove: function() {
+        this.map.off("moveend", this._onMapChange);
+        this.map.off("zoomend", this._onMapChange);
+        this.map.off("resize", this._onMapResize);
+
+        this._container.parentNode.removeChild(this._container);
+    },
+
+
+    setDimensions: function(dimensions) {
+        if (!dimensions)
+            return;
+
+        this._height = parseInt(dimensions.height) || this._height;
+        this._width = parseInt(dimensions.width) || this._width;
+        this._render();
+        this.fire("change");
+    },
+
+
+    _createElements: function() {
+        if (!!this._container)
+            return;
+
+        this._container = L.DomUtil.create("div", "leaflet-areaselect-container", this.map._controlContainer)
+        this._topShade = L.DomUtil.create("div", "leaflet-areaselect-shade leaflet-control", this._container);
+        this._bottomShade = L.DomUtil.create("div", "leaflet-areaselect-shade leaflet-control", this._container);
+        this._leftShade = L.DomUtil.create("div", "leaflet-areaselect-shade leaflet-control", this._container);
+        this._rightShade = L.DomUtil.create("div", "leaflet-areaselect-shade leaflet-control", this._container);
+
+        this._nwHandle = L.DomUtil.create("div", "leaflet-areaselect-handle leaflet-control", this._container);
+        this._swHandle = L.DomUtil.create("div", "leaflet-areaselect-handle leaflet-control", this._container);
+        this._neHandle = L.DomUtil.create("div", "leaflet-areaselect-handle leaflet-control", this._container);
+        this._seHandle = L.DomUtil.create("div", "leaflet-areaselect-handle leaflet-control", this._container);
+
+        this._setUpHandlerEvents(this._nwHandle);
+        this._setUpHandlerEvents(this._neHandle, -1, 1);
+        this._setUpHandlerEvents(this._swHandle, 1, -1);
+        this._setUpHandlerEvents(this._seHandle, -1, -1);
+
+        this.map.on("moveend", this._onMapChange, this);
+        this.map.on("zoomend", this._onMapChange, this);
+        this.map.on("resize", this._onMapResize, this);
+
+        this.fire("change");
+    },
+
+    _setUpHandlerEvents: function(handle, xMod, yMod) {
+        xMod = xMod || 1;
+        yMod = yMod || 1;
+
+        var self = this;
+        function onMouseDown(event) {
+            event.stopPropagation();
+            self.map.dragging.disable();
+            L.DomEvent.removeListener(this, "mousedown", onMouseDown);
+            var curX = event.pageX;
+            var curY = event.pageY;
+            var ratio = self._width / self._height;
+            var size = self.map.getSize();
+
+            function onMouseMove(event) {
+                if (self.options.keepAspectRatio) {
+                    var maxHeight = (self._height >= self._width ? size.y : (size.x / ratio) ) - 30;
+                    self._height += (curY - event.originalEvent.pageY) * 2 * yMod;
+                    self._height = Math.max(30, self._height);
+                    self._height = Math.min(maxHeight, self._height);
+                    self._width = self._height * ratio;
+                } else {
+                    self._width += (curX - event.originalEvent.pageX) * 2 * xMod;
+                    self._height += (curY - event.originalEvent.pageY) * 2 * yMod;
+                    self._width = Math.max(30, self._width);
+                    self._height = Math.max(30, self._height);
+                    self._width = Math.min(size.x-30, self._width);
+                    self._height = Math.min(size.y-30, self._height);
+
+                }
+
+                curX = event.originalEvent.pageX;
+                curY = event.originalEvent.pageY;
+                self._render();
+            }
+            function onMouseUp(event) {
+                self.map.dragging.enable();
+                L.DomEvent.removeListener(self.map, "mouseup", onMouseUp);
+                L.DomEvent.removeListener(self.map, "mousemove", onMouseMove);
+                L.DomEvent.addListener(handle, "mousedown", onMouseDown);
+                self.fire("change");
+            }
+
+            L.DomEvent.addListener(self.map, "mousemove", onMouseMove);
+            L.DomEvent.addListener(self.map, "mouseup", onMouseUp);
+        }
+        L.DomEvent.addListener(handle, "mousedown", onMouseDown);
+    },
+
+    _onMapResize: function() {
+        this._render();
+    },
+
+    _onMapChange: function() {
+        this.fire("change");
+    },
+
+    _render: function() {
+        var size = this.map.getSize();
+        var handleOffset = Math.round(this._nwHandle.offsetWidth/2);
+
+        var topBottomHeight = Math.round((size.y-this._height)/2);
+        var leftRightWidth = Math.round((size.x-this._width)/2);
+
+        function setDimensions(element, dimension) {
+            element.style.width = dimension.width + "px";
+            element.style.height = dimension.height + "px";
+            element.style.top = dimension.top + "px";
+            element.style.left = dimension.left + "px";
+            element.style.bottom = dimension.bottom + "px";
+            element.style.right = dimension.right + "px";
+        }
+
+        setDimensions(this._topShade, {width:size.x, height:topBottomHeight, top:0, left:0});
+        setDimensions(this._bottomShade, {width:size.x, height:topBottomHeight, bottom:0, left:0});
+        setDimensions(this._leftShade, {
+            width: leftRightWidth,
+            height: size.y-(topBottomHeight*2),
+            top: topBottomHeight,
+            left: 0
+        });
+        setDimensions(this._rightShade, {
+            width: leftRightWidth,
+            height: size.y-(topBottomHeight*2),
+            top: topBottomHeight,
+            right: 0
+        });
+
+        setDimensions(this._nwHandle, {left:leftRightWidth-handleOffset, top:topBottomHeight-7});
+        setDimensions(this._neHandle, {right:leftRightWidth-handleOffset, top:topBottomHeight-7});
+        setDimensions(this._swHandle, {left:leftRightWidth-handleOffset, bottom:topBottomHeight-7});
+        setDimensions(this._seHandle, {right:leftRightWidth-handleOffset, bottom:topBottomHeight-7});
+    }
+});
+
+L.areaSelect = function(options) {
+    return new L.AreaSelect(options);
+}

data/vendor/assets/javascripts/leaflet-iiif.js

@@ -0,0 +1,230 @@
+/*
+ * Leaflet-IIIF 1.0.2
+ * IIIF Viewer for Leaflet
+ * by Jack Reed, @mejackreed
+ */
+
+L.TileLayer.Iiif = L.TileLayer.extend({
+  options: {
+    continuousWorld: true,
+    tileSize: 256,
+    updateWhenIdle: true,
+    tileFormat: 'jpg',
+    fitBounds: true
+  },
+
+  initialize: function(url, options) {
+    options = typeof options !== 'undefined' ? options : {};
+
+    if (options.maxZoom) {
+      this._customMaxZoom = true;
+    }
+
+    // Check for explicit tileSize set
+    if (options.tileSize) {
+      this._explicitTileSize = true;
+    }
+
+    options = L.setOptions(this, options);
+    this._infoDeferred = new $.Deferred();
+    this._infoUrl = url;
+    this._baseUrl = this._templateUrl();
+    this._getInfo();
+  },
+  getTileUrl: function(coords) {
+    var _this = this,
+      x = coords.x,
+      y = (coords.y),
+      zoom = _this._getZoomForUrl(),
+      scale = Math.pow(2, _this.maxNativeZoom - zoom),
+      tileBaseSize = _this.options.tileSize * scale,
+      minx = (x * tileBaseSize),
+      miny = (y * tileBaseSize),
+      maxx = Math.min(minx + tileBaseSize, _this.x),
+      maxy = Math.min(miny + tileBaseSize, _this.y);
+
+    var xDiff = (maxx - minx);
+    var yDiff = (maxy - miny);
+
+    return L.Util.template(this._baseUrl, L.extend({
+      format: _this.options.tileFormat,
+      quality: _this.quality,
+      region: [minx, miny, xDiff, yDiff].join(','),
+      rotation: 0,
+      size: Math.ceil(xDiff / scale) + ','
+    }, this.options));
+  },
+  onAdd: function(map) {
+    var _this = this;
+
+    // Wait for deferred to complete
+    $.when(_this._infoDeferred).done(function() {
+
+      // Set maxZoom for map
+      map._layersMaxZoom = _this.maxZoom;
+
+      // Call add TileLayer
+      L.TileLayer.prototype.onAdd.call(_this, map);
+
+      if (_this.options.fitBounds) {
+        _this._fitBounds();
+      }
+
+      // Reset tile sizes to handle non 256x256 IIIF tiles
+      _this.on('tileload', function(tile, url) {
+
+        var height = tile.tile.naturalHeight,
+          width = tile.tile.naturalWidth;
+
+        // No need to resize if tile is 256 x 256
+        if (height === 256 && width === 256) return;
+
+        tile.tile.style.width = width + 'px';
+        tile.tile.style.height = height + 'px';
+
+      });
+    });
+  },
+  _fitBounds: function() {
+    var _this = this;
+
+    // Find best zoom level and center map
+    var initialZoom = _this._getInitialZoom(_this._map.getSize());
+    var imageSize = _this._imageSizes[initialZoom];
+    var sw = _this._map.options.crs.pointToLatLng(L.point(0, imageSize.y), initialZoom);
+    var ne = _this._map.options.crs.pointToLatLng(L.point(imageSize.x, 0), initialZoom);
+    var bounds = L.latLngBounds(sw, ne);
+
+    _this._map.fitBounds(bounds, true);
+  },
+  _getInfo: function() {
+    var _this = this;
+
+    // Look for a way to do this without jQuery
+    $.getJSON(_this._infoUrl)
+      .done(function(data) {
+        _this.y = data.height;
+        _this.x = data.width;
+
+        var tierSizes = [],
+          imageSizes = [],
+          scale,
+          width_,
+          height_,
+          tilesX_,
+          tilesY_;
+
+        // Set quality based off of IIIF version
+        if (data.profile instanceof Array) {
+          _this.profile = data.profile[0];
+        }else {
+          _this.profile = data.profile;
+        }
+
+        _this._setQuality();
+
+        // Unless an explicit tileSize is set, use a preferred tileSize
+        if (!_this._explicitTileSize) {
+          // Set the default first
+          _this.options.tileSize = 256;
+          if (data.tiles) {
+            // Image API 2.0 Case
+            _this.options.tileSize = data.tiles[0].width;
+          } else if (data.tile_width){
+            // Image API 1.1 Case
+            _this.options.tileSize = data.tile_width;
+          }
+        }
+
+        ceilLog2 = function(x) {
+          return Math.ceil(Math.log(x) / Math.LN2);
+        };
+
+        // Calculates maximum native zoom for the layer
+        _this.maxNativeZoom = Math.max(ceilLog2(_this.x / _this.options.tileSize),
+          ceilLog2(_this.y / _this.options.tileSize));
+
+        // Enable zooming further than native if maxZoom option supplied
+        if (_this._customMaxZoom && _this.options.maxZoom > _this.maxNativeZoom) {
+          _this.maxZoom = _this.options.maxZoom;
+        }
+        else {
+          _this.maxZoom = _this.maxNativeZoom;
+        }
+
+        for (var i = 0; i <= _this.maxZoom; i++) {
+          scale = Math.pow(2, _this.maxNativeZoom - i);
+          width_ = Math.ceil(_this.x / scale);
+          height_ = Math.ceil(_this.y / scale);
+          tilesX_ = Math.ceil(width_ / _this.options.tileSize);
+          tilesY_ = Math.ceil(height_ / _this.options.tileSize);
+          tierSizes.push([tilesX_, tilesY_]);
+          imageSizes.push(L.point(width_,height_));
+        }
+
+        _this._tierSizes = tierSizes;
+        _this._imageSizes = imageSizes;
+
+        // Resolved Deferred to initiate tilelayer load
+        _this._infoDeferred.resolve();
+      });
+  },
+
+  _setQuality: function() {
+    var _this = this;
+
+    // Quality already specified by consumer
+    if (_this.options.quality) {
+      return;
+    }
+
+    // Set the quality based on the IIIF compliance level
+    switch (true) {
+      case /^http:\/\/library.stanford.edu\/iiif\/image-api\/1.1\/compliance.html.*$/.test(_this.profile):
+        _this.options.quality = 'native';
+        break;
+      case /^http:\/\/iiif.io\/api\/image\/2.*$/.test(_this.profile):
+        _this.options.quality = 'default';
+        break;
+    }
+  },
+
+  _infoToBaseUrl: function() {
+    return this._infoUrl.replace('info.json', '');
+  },
+  _templateUrl: function() {
+    return this._infoToBaseUrl() + '{region}/{size}/{rotation}/{quality}.{format}';
+  },
+  _isValidTile: function(coords) {
+    var _this = this,
+      zoom = _this._getZoomForUrl(),
+      sizes = _this._tierSizes[zoom],
+      x = coords.x,
+      y = (coords.y);
+
+    if (!sizes) return false;
+    if (x < 0 || sizes[0] <= x || y < 0 || sizes[1] <= y) {
+      return false;
+    }else {
+      return true;
+    }
+  },
+  _getInitialZoom: function (mapSize) {
+    var _this = this,
+      tolerance = 0.8,
+      imageSize;
+
+    for (var i = _this.maxNativeZoom; i >= 0; i--) {
+      imageSize = this._imageSizes[i];
+      if (imageSize.x * tolerance < mapSize.x && imageSize.y * tolerance < mapSize.y) {
+        return i;
+      }
+    }
+    // return a default zoom
+    return 2;
+  }
+});
+
+L.tileLayer.iiif = function(url, options) {
+  return new L.TileLayer.Iiif(url, options);
+};