riiif 0.3.0 → 0.4.0

data/riiif.gemspec

@@ -4,24 +4,26 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'riiif/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "riiif"
+  spec.name          = 'riiif'
   spec.version       = Riiif::VERSION
-  spec.authors       = ["Justin Coyne"]
-  spec.email         = ["justin@curationexperts.com"]
-  spec.description   = %q{A IIIF image server}
-  spec.summary       = %q{A rails engine that support IIIF requests}
-  spec.homepage      = "https://github.com/curationexperts/riiif"
-  spec.license       = "APACHE2"
+  spec.authors       = ['Justin Coyne']
+  spec.email         = ['justin@curationexperts.com']
+  spec.description   = 'A IIIF image server'
+  spec.summary       = 'A rails engine that support IIIF requests'
+  spec.homepage      = 'https://github.com/curationexperts/riiif'
+  spec.license       = 'APACHE2'
 
-  spec.files         = `git ls-files|grep -v spec/samples`.split($/)
+  spec.files         = `git ls-files|grep -v spec/samples`.split($INPUT_RECORD_SEPARATOR)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "engine_cart", '~> 0.8'
-  spec.add_development_dependency "rspec-rails"
-  spec.add_development_dependency "sqlite3"
   spec.add_dependency 'rails', '> 3.2.0'
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'engine_cart', '~> 0.8'
+  spec.add_development_dependency 'rspec-rails'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'rubocop', '~> 0.41.2'
+  spec.add_development_dependency 'rubocop-rspec', '~> 1.5'
 end

data/spec/controllers/riiif/images_controller_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+require 'open-uri'
+
+describe Riiif::ImagesController do
+  let(:filename) { File.expand_path('spec/samples/world.jp2') }
+  routes { Riiif::Engine.routes }
+
+  describe '#show' do
+    it 'sends images to the service' do
+      image = double
+      expect(Riiif::Image).to receive(:new).with('abcd1234').and_return(image)
+      expect(image).to receive(:render).with('region' => 'full', 'size' => 'full',
+                                             'rotation' => '0', 'quality' => 'default',
+                                             'format' => 'jpg').and_return('IMAGEDATA')
+      get :show, id: 'abcd1234', action: 'show', region: 'full', size: 'full',
+                 rotation: '0', quality: 'default', format: 'jpg'
+      expect(response).to be_successful
+      expect(response.body).to eq 'IMAGEDATA'
+      expect(response.headers['Link']).to eq '<http://iiif.io/api/image/2/level1.json>;rel="profile"'
+      expect(response.headers['Access-Control-Allow-Origin']).to eq '*'
+    end
+
+    context 'with an unauthorized image' do
+      let(:auth) { double('no auth service', can?: false) }
+      let(:not_found_image) { double('not_found_image', render: 'test data') }
+      before do
+        allow(controller).to receive(:authorization_service).and_return(auth)
+        allow(controller).to receive(:not_found_image).and_return(not_found_image)
+      end
+      it 'renders 401' do
+        get :show, id: 'abcd1234', action: 'show', region: 'full', size: 'full',
+                   rotation: '0', quality: 'default', format: 'jpg'
+        expect(response.body).to eq 'test data'
+        expect(response.code).to eq '401'
+      end
+    end
+
+    context 'with a invalid region' do
+      it 'renders 400' do
+        image = double('an image')
+        allow(image).to receive(:render).and_raise Riiif::InvalidAttributeError
+        allow(Riiif::Image).to receive(:new).with('abcd1234').and_return(image)
+        get :show, id: 'abcd1234', action: 'show', region: '`szoW0', size: 'full',
+                   rotation: '0', quality: 'default', format: 'jpg'
+        expect(response.code).to eq '400'
+      end
+    end
+
+    context 'with a nonexistent image' do
+      it "errors when a default image isn't sent" do
+        expect(Riiif::Image).to receive(:new).with('bad_id').and_raise(OpenURI::HTTPError.new('fail', StringIO.new))
+        expect do
+          get :show, id: 'bad_id', action: 'show', region: 'full', size: 'full',
+                     rotation: '0', quality: 'default', format: 'jpg'
+        end.to raise_error(StandardError)
+      end
+
+      context 'with a default image set' do
+        around do |example|
+          old_value = Riiif.not_found_image
+          Riiif.not_found_image = filename
+          example.run
+          Riiif.not_found_image = old_value
+        end
+
+        it "sends the default 'not found' image for failed http files" do
+          not_found_image = double
+          expect(Riiif::Image).to receive(:new) do |_id, file|
+            raise Riiif::ImageNotFoundError unless file.present?
+            not_found_image
+          end.twice
+          expect(not_found_image).to receive(:render).with('region' => 'full', 'size' => 'full',
+                                                           'rotation' => '0', 'quality' => 'default',
+                                                           'format' => 'jpg').and_return('default-image-data')
+
+          get :show, id: 'bad_id', action: 'show', region: 'full', size: 'full',
+                     rotation: '0', quality: 'default', format: 'jpg'
+          expect(response).to be_not_found
+          expect(response.body).to eq 'default-image-data'
+        end
+
+        it "sends the default 'not found' image for failed files on the filesystem" do
+          not_found_image = double
+          expect(Riiif::Image).to receive(:new) do |_id, file|
+            raise Riiif::ImageNotFoundError unless file.present?
+            not_found_image
+          end.twice
+          expect(not_found_image).to receive(:render).with('region' => 'full', 'size' => 'full',
+                                                           'rotation' => '0', 'quality' => 'default',
+                                                           'format' => 'jpg').and_return('default-image-data')
+
+          get :show, id: 'bad_id', action: 'show', region: 'full', size: 'full',
+                     rotation: '0', quality: 'default', format: 'jpg'
+          expect(response).to be_not_found
+          expect(response.body).to eq 'default-image-data'
+        end
+      end
+    end
+  end
+
+  describe 'info' do
+    it 'returns info' do
+      image = double
+      expect(Riiif::Image).to receive(:new).with('abcd1234').and_return(image)
+      expect(image).to receive(:info).and_return(width: 6000, height: 4000)
+      get :info, id: 'abcd1234', format: 'json'
+      expect(response).to be_successful
+      json = JSON.parse(response.body)
+      expect(json).to eq '@context' => 'http://iiif.io/api/image/2/context.json',
+                         '@id' => 'http://test.host/images/abcd1234',
+                         'width' => 6000,
+                         'height' => 4000,
+                         'profile' => ['http://iiif.io/api/image/2/level1.json', 'formats' => %w(jpg png)],
+                         'protocol' => 'http://iiif.io/api/image'
+      expect(response.headers['Link']).to eq '<http://iiif.io/api/image/2/level1.json>;rel="profile"'
+      expect(response.headers['Content-Type']).to eq 'application/ld+json; charset=utf-8'
+      expect(response.headers['Access-Control-Allow-Origin']).to eq '*'
+    end
+
+    context 'with an unauthorized image' do
+      let(:auth) { double('no auth service', can?: false) }
+      before do
+        allow(controller).to receive(:authorization_service).and_return(auth)
+      end
+      it 'renders 401' do
+        get :info, id: 'abcd1234', format: 'json'
+        expect(response.body).to eq '{"error":"unauthorized"}'
+        expect(response.code).to eq '401'
+      end
+    end
+  end
+end

data/spec/models/riiif/akubra_system_file_resolver_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Riiif::AkubraSystemFileResolver do
+  subject { described_class.new(Rails.root.join('../spec/samples/'), 'jp2', [[0, 2], [2, 2], [4, 1]]) }
+  it "raises an error when the file isn't found" do
+    expect { subject.find('demo:2') }.to raise_error Riiif::ImageNotFoundError
+  end
+
+  it 'gets the jpeg2000 file' do
+    expect(subject.find('demo:1').path).to eq Riiif::File.new(Dir.glob(subject.pathroot + '22/7e/9/info%3Afedora%2Fdemo%3A1%2Fjp2%2Fjp2.0').first).path
+  end
+end

data/spec/models/riiif/file_system_file_resolver_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Riiif::FileSystemFileResolver do
+  let(:resolver) { described_class.new }
+
+  describe '#find' do
+    subject { resolver.find(id) }
+
+    context "when the file isn't found" do
+      let(:id) { '1234' }
+      it 'raises an error' do
+        expect { subject }.to raise_error Riiif::ImageNotFoundError
+      end
+    end
+
+    context 'when the file is found' do
+      let(:id) { 'world' }
+      it 'returns the jpeg2000 file' do
+        expect(subject.path).to eq resolver.root + '/spec/samples/world.jp2'
+      end
+    end
+  end
+
+  describe '#pattern' do
+    subject { resolver.pattern(id) }
+
+    context 'with dashes' do
+      let(:id) { 'foo-bar-baz' }
+      it 'accepts ids with dashes' do
+        expect { subject }.not_to raise_error
+      end
+    end
+
+    context 'with colins' do
+      let(:id) { 'fo:baz' }
+      it 'accepts ids with colins' do
+        expect { subject }.not_to raise_error
+      end
+    end
+  end
+end

data/spec/models/{http_file_resolver_spec.rb → riiif/http_file_resolver_spec.rb}

@@ -1,17 +1,17 @@
 require 'spec_helper'
 
 describe Riiif::HTTPFileResolver do
-  subject { Riiif::HTTPFileResolver.new }
+  subject { described_class.new }
 
   before do
-    Dir.glob("tmp/network_files/*") do |f|
+    Dir.glob('tmp/network_files/*') do |f|
       File.unlink(f)
     end
-    subject.id_to_uri = lambda {|id| id}
+    subject.id_to_uri = ->(id) { id }
   end
 
   it "raises an error when the file isn't found" do
-    expect(Kernel).to receive(:open).and_raise(OpenURI::HTTPError.new("failure", StringIO.new))
+    expect(Kernel).to receive(:open).and_raise(OpenURI::HTTPError.new('failure', StringIO.new))
     begin
       subject.find('1234')
     rescue Riiif::ImageNotFoundError => e
@@ -20,14 +20,14 @@ describe Riiif::HTTPFileResolver do
     expect(e.original_exception).to be_an OpenURI::HTTPError
   end
 
-  context "when basic authentication credentials are set" do
-    let(:credentials) { ['username', 's0s3kr3t'] }
+  context 'when basic authentication credentials are set' do
+    let(:credentials) { %w(username s0s3kr3t) }
     before do
       subject.basic_auth_credentials = credentials
     end
 
-    it "should use basic auth credentials" do
-      expect(Kernel).to receive(:open).with("1234", { http_basic_authentication: credentials })
+    it 'uses basic auth credentials' do
+      expect(Kernel).to receive(:open).with('1234', http_basic_authentication: credentials)
       subject.find('1234')
     end
   end

data/spec/models/{image_spec.rb → riiif/image_spec.rb}

@@ -3,149 +3,149 @@ require 'spec_helper'
 describe Riiif::Image do
   before { Rails.cache.clear }
   let(:filename) { File.expand_path('spec/samples/world.jp2') }
-  subject { Riiif::Image.new('world') }
-  describe "happy path" do
+  subject { described_class.new('world') }
+  describe 'happy path' do
     before do
       expect(subject.image).to receive(:execute).with("convert #{filename} jpg:-").and_return('imagedata')
     end
-    it "should render" do
+    it 'renders' do
       expect(subject.render('size' => 'full', format: 'jpg')).to eq 'imagedata'
     end
   end
 
-  it "should be able to override the file used for the Image" do
-    img = Riiif::Image.new('some_id', Riiif::File.new(filename))
+  it 'is able to override the file used for the Image' do
+    img = described_class.new('some_id', Riiif::File.new(filename))
     expect(img.id).to eq 'some_id'
     expect(img.info).to eq height: 400, width: 800
   end
 
-  describe "without a format" do
-    it "should raise an error" do
+  describe 'without a format' do
+    it 'raises an error' do
       expect { subject.render('size' => 'full') }.to raise_error ArgumentError
     end
   end
 
-  describe "info" do
-    it "should return the data" do
-      expect(subject.info).to eq height: 400, width:800
+  describe 'info' do
+    it 'returns the data' do
+      expect(subject.info).to eq height: 400, width: 800
     end
   end
 
-  context "using HTTPFileResolver" do
+  context 'using HTTPFileResolver' do
     before do
-      Riiif::Image.file_resolver = Riiif::HTTPFileResolver.new
-      Riiif::Image.file_resolver.id_to_uri = lambda do |id|
+      described_class.file_resolver = Riiif::HTTPFileResolver.new
+      described_class.file_resolver.id_to_uri = lambda do |id|
         "https://upload.wikimedia.org/wikipedia/commons/thumb/a/a4/#{id}.jpg/600px-#{id}.jpg"
       end
     end
     after do
-      Riiif::Image.file_resolver = Riiif::FileSystemFileResolver.new
+      described_class.file_resolver = Riiif::FileSystemFileResolver.new
     end
 
-    describe "get info" do
-      subject { Riiif::Image.new('Cave_26,_Ajanta') }
-      it "should be easy" do
-        expect(subject.info).to eq height: 390, width:600
+    describe 'get info' do
+      subject { described_class.new('Cave_26,_Ajanta') }
+      it 'is easy' do
+        expect(subject.info).to eq height: 390, width: 600
       end
     end
 
-    context "when the rendered image is in the cache" do
-      subject { Riiif::Image.new('Cave_26,_Ajanta') }
+    context 'when the rendered image is in the cache' do
+      subject { described_class.new('Cave_26,_Ajanta') }
       before { allow(Rails.cache).to receive(:fetch).and_return('expected') }
 
-      it "should not fetch the file" do
-        expect(Riiif::Image.file_resolver).not_to receive(:find)
+      it 'does not fetch the file' do
+        expect(described_class.file_resolver).not_to receive(:find)
         expect(subject.render(region: 'full', format: 'png')).to eq 'expected'
       end
     end
   end
 
-  describe "mogrify" do
-    describe "region" do
-      it "should return the original when specifing full size" do
+  describe 'mogrify' do
+    describe 'region' do
+      it 'returns the original when specifing full size' do
         expect(subject.image).to receive(:execute).with("convert #{filename} png:-")
         subject.render(region: 'full', format: 'png')
       end
-      it "should handle absolute geometry" do
+      it 'handles absolute geometry' do
         expect(subject.image).to receive(:execute).with("convert -crop 60x75+80+15 #{filename} png:-")
         subject.render(region: '80,15,60,75', format: 'png')
       end
-      it "should handle percent geometry" do
+      it 'handles percent geometry' do
         expect(subject.image).to receive(:execute).with("identify -format %hx%w #{filename}").and_return('131x175')
         expect(subject.image).to receive(:execute).with("convert -crop 80%x70+18+13 #{filename} png:-")
         subject.render(region: 'pct:10,10,80,70', format: 'png')
       end
-      it "should raise an error for invalid geometry" do
+      it 'raises an error for invalid geometry' do
         expect { subject.render(region: '150x75', format: 'png') }.to raise_error Riiif::InvalidAttributeError
       end
     end
 
-    describe "resize" do
-      it "should return the original when specifing full size" do
+    describe 'resize' do
+      it 'returns the original when specifing full size' do
         expect(subject.image).to receive(:execute).with("convert #{filename} png:-")
         subject.render(size: 'full', format: 'png')
       end
-      it "should handle integer percent sizes" do
+      it 'handles integer percent sizes' do
         expect(subject.image).to receive(:execute).with("convert -resize 50% #{filename} png:-")
         subject.render(size: 'pct:50', format: 'png')
       end
-      it "should handle float percent sizes" do
+      it 'handles float percent sizes' do
         expect(subject.image).to receive(:execute).with("convert -resize 12.5% #{filename} png:-")
         subject.render(size: 'pct:12.5', format: 'png')
       end
-      it "should handle w," do
+      it 'handles w,' do
         expect(subject.image).to receive(:execute).with("convert -resize 50 #{filename} png:-")
         subject.render(size: '50,', format: 'png')
       end
-      it "should handle ,h" do
+      it 'handles ,h' do
         expect(subject.image).to receive(:execute).with("convert -resize x50 #{filename} png:-")
         subject.render(size: ',50', format: 'png')
       end
-      it "should handle w,h" do
+      it 'handles w,h' do
         expect(subject.image).to receive(:execute).with("convert -resize 150x75! #{filename} png:-")
         subject.render(size: '150,75', format: 'png')
       end
-      it "should handle bestfit (!w,h)" do
+      it 'handles bestfit (!w,h)' do
         expect(subject.image).to receive(:execute).with("convert -resize 150x75 #{filename} png:-")
         subject.render(size: '!150,75', format: 'png')
       end
-      it "should raise an error for invalid size" do
+      it 'raises an error for invalid size' do
         expect { subject.render(size: '150x75', format: 'png') }.to raise_error Riiif::InvalidAttributeError
       end
     end
 
-    describe "rotate" do
-      it "should return the original when specifing full size" do
+    describe 'rotate' do
+      it 'returns the original when specifing full size' do
         expect(subject.image).to receive(:execute).with("convert #{filename} png:-")
         subject.render(rotation: '0', format: 'png')
       end
-      it "should handle floats" do
+      it 'handles floats' do
         expect(subject.image).to receive(:execute).with("convert -virtual-pixel white +distort srt 22.5 #{filename} png:-")
         subject.render(rotation: '22.5', format: 'png')
       end
-      it "should raise an error for invalid angle" do
+      it 'raises an error for invalid angle' do
         expect { subject.render(rotation: '150x', format: 'png') }.to raise_error Riiif::InvalidAttributeError
       end
     end
 
-    describe "quality" do
-      it "returns the original when specifing default" do
+    describe 'quality' do
+      it 'returns the original when specifing default' do
         expect(subject.image).to receive(:execute).with("convert #{filename} png:-")
         subject.render(quality: 'default', format: 'png')
       end
-      it "should return the original when specifing color" do
+      it 'returns the original when specifing color' do
         expect(subject.image).to receive(:execute).with("convert #{filename} png:-")
         subject.render(quality: 'color', format: 'png')
       end
-      it "should convert to grayscale" do
+      it 'converts to grayscale' do
         expect(subject.image).to receive(:execute).with("convert -colorspace Gray #{filename} png:-")
         subject.render(quality: 'grey', format: 'png')
       end
-      it "should convert to bitonal" do
+      it 'converts to bitonal' do
         expect(subject.image).to receive(:execute).with("convert -colorspace Gray -type Bilevel #{filename} png:-")
         subject.render(quality: 'bitonal', format: 'png')
       end
-      it "should raise an error for invalid angle" do
+      it 'raises an error for invalid angle' do
         expect { subject.render(rotation: '150x', format: 'png') }.to raise_error Riiif::InvalidAttributeError
       end
     end

data/spec/routing/redirect_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe "GET /abcd%2F1234", type: :request do
-  it "redirects, without unescaping" do
-    get "/images/abcd%2F1234"
-    expect(response).to redirect_to ('/images/abcd%2F1234/info.json')
+describe 'GET /abcd%2F1234', type: :request do
+  it 'redirects, without unescaping' do
+    get '/images/abcd%2F1234'
+    expect(response).to redirect_to '/images/abcd%2F1234/info.json'
   end
 end

data/spec/routing/resize_routes_spec.rb

@@ -1,58 +1,58 @@
 require 'spec_helper'
 
-describe "routes" do
+describe 'routes' do
   routes { Riiif::Engine.routes }
 
   describe 'for conversion' do
-    it "routes GET /abcd1234/full/full/0/default.jpg" do
+    it 'routes GET /abcd1234/full/full/0/default.jpg' do
       expect(
-        get: "/abcd1234/full/full/0/default.jpg"
-      ).to route_to(controller: "riiif/images", id: 'abcd1234', action: "show", 
-                    region: 'full', size: 'full', rotation: '0', 
-                    quality: 'default', format: 'jpg', model: "riiif/image")
+        get: '/abcd1234/full/full/0/default.jpg'
+      ).to route_to(controller: 'riiif/images', id: 'abcd1234', action: 'show',
+                    region: 'full', size: 'full', rotation: '0',
+                    quality: 'default', format: 'jpg', model: 'riiif/image')
     end
 
-    it "routes requests with floating point percent size" do
+    it 'routes requests with floating point percent size' do
       expect(
-        get: "/abcd1234/full/pct:12.5/22.5/default.jpg"
-      ).to route_to(controller: "riiif/images", id: 'abcd1234', action: "show",
+        get: '/abcd1234/full/pct:12.5/22.5/default.jpg'
+      ).to route_to(controller: 'riiif/images', id: 'abcd1234', action: 'show',
                     region: 'full', size: 'pct:12.5', rotation: '22.5',
-                    quality: 'default', format: 'jpg', model: "riiif/image")
+                    quality: 'default', format: 'jpg', model: 'riiif/image')
     end
-    it "routes requests with pixel size" do
+    it 'routes requests with pixel size' do
       expect(
-        get: "/abcd1234/full/100,50/22.5/default.jpg"
-      ).to route_to(controller: "riiif/images", id: 'abcd1234', action: "show",
+        get: '/abcd1234/full/100,50/22.5/default.jpg'
+      ).to route_to(controller: 'riiif/images', id: 'abcd1234', action: 'show',
                     region: 'full', size: '100,50', rotation: '22.5',
-                    quality: 'default', format: 'jpg', model: "riiif/image")
+                    quality: 'default', format: 'jpg', model: 'riiif/image')
     end
-    it "routes requests with dashes in the id" do
+    it 'routes requests with dashes in the id' do
       expect(
-        get: "/abcd-1234-5678/full/full/0/default.jpg"
-      ).to route_to(controller: "riiif/images", id: 'abcd-1234-5678', action: "show",
+        get: '/abcd-1234-5678/full/full/0/default.jpg'
+      ).to route_to(controller: 'riiif/images', id: 'abcd-1234-5678', action: 'show',
                     region: 'full', size: 'full', rotation: '0',
-                    quality: 'default', format: 'jpg', model: "riiif/image")
+                    quality: 'default', format: 'jpg', model: 'riiif/image')
     end
 
-    describe "route helper" do
-      it "takes all the options" do
+    describe 'route helper' do
+      it 'takes all the options' do
         expect(image_path('abcd1234', region: 'full', size: '100,50', rotation: '22.5', quality: 'default',
-                          format: 'jpg')).to eq '/images/abcd1234/full/100,50/22.5/default.jpg'
+                                      format: 'jpg')).to eq '/images/abcd1234/full/100,50/22.5/default.jpg'
       end
-      it "has defaults" do
+      it 'has defaults' do
         expect(image_path('abcd1234', size: '100,50')).to eq '/images/abcd1234/full/100,50/0/default.jpg'
       end
     end
   end
 
-  describe "for info" do
-    it "routes GET /abcd1234/info.json" do
+  describe 'for info' do
+    it 'routes GET /abcd1234/info.json' do
       expect(
-        get: "/abcd1234/info.json"
-      ).to route_to(controller: "riiif/images", id: 'abcd1234',
-                    action: "info", format: 'json', model: "riiif/image")
+        get: '/abcd1234/info.json'
+      ).to route_to(controller: 'riiif/images', id: 'abcd1234',
+                    action: 'info', format: 'json', model: 'riiif/image')
     end
-    it "should have a route helper" do
+    it 'has a route helper' do
       expect(info_path('abcd1234')).to eq '/images/abcd1234/info.json'
     end
   end

data/spec/spec_helper.rb

@@ -1,17 +1,14 @@
 require 'engine_cart'
-ENV["RAILS_ENV"] ||= 'test'
-
+ENV['RAILS_ENV'] ||= 'test'
 
 EngineCart.load_application!
 require 'rspec/rails'
 
-
 RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
 
   config.infer_spec_type_from_file_location!
 
-
   # Run specs in random order to surface order dependencies. If you find an
   # order dependency and want to debug it, you can fix the order by providing
   # the seed, which is printed after each run.

data/spec/test_app_templates/lib/generators/test_app_generator.rb

@@ -1,10 +1,9 @@
 require 'rails/generators'
 
 class TestAppGenerator < Rails::Generators::Base
-  source_root "spec/test_app_templates"
+  source_root 'spec/test_app_templates'
 
   def add_routes
     route "mount Riiif::Engine => '/images', as: 'riiif'"
   end
-
 end