chore: Address Rubocop offenses

Author: blocknotes

.rubocop.yml

@@ -45,6 +45,10 @@ RSpec/NestedGroups:
   # Default is 3
   Max: 5
 
+RSpec/Output:
+  Exclude:
+    - spec/dummy/bin/*
+
 Style/ClassAndModuleChildren:
   Exclude:
     - 'lib/active_storage/service/db_service.rb'

lib/active_storage/service/db_service.rb

@@ -173,7 +173,7 @@ def stream(key)
       data_size = adapter_sqlserver? ? "DATALENGTH(data)" : "OCTET_LENGTH(data)"
       size = object_for(key, fields: "#{data_size} AS size")&.size || raise(ActiveStorage::FileNotFoundError)
       (size / @chunk_size.to_f).ceil.times.each do |i|
-        range = (i * @chunk_size..((i + 1) * @chunk_size) - 1)
+        range = (i * @chunk_size)..(((i + 1) * @chunk_size) - 1)
         yield download_chunk(key, range)
       end
     end

spec/dummy/app/controllers/posts_controller.rb

@@ -28,7 +28,7 @@ def create
 
     respond_to do |format|
       if @post.save
-        format.html { redirect_to @post, notice: 'Post was successfully created.' }
+        format.html { redirect_to @post, notice: "Post was successfully created." }
         format.json { render :show, status: :created, location: @post }
       else
         format.html { render :new }
@@ -42,7 +42,7 @@ def create
   def update
     respond_to do |format|
       if @post.update(post_params)
-        format.html { redirect_to @post, notice: 'Post was successfully updated.' }
+        format.html { redirect_to @post, notice: "Post was successfully updated." }
         format.json { render :show, status: :ok, location: @post }
       else
         format.html { render :edit }
@@ -56,7 +56,7 @@ def update
   def destroy
     @post.destroy
     respond_to do |format|
-      format.html { redirect_to posts_url, notice: 'Post was successfully destroyed.' }
+      format.html { redirect_to posts_url, notice: "Post was successfully destroyed." }
       format.json { head :no_content }
     end
   end

spec/dummy/app/models/application_record.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class ApplicationRecord < ActiveRecord::Base
-  if Gem::Version.new(Rails.version) >= Gem::Version.new('7.0')
+  if Rails::VERSION::MAJOR >= 7
     primary_abstract_class
   else
     self.abstract_class = true

spec/requests/file_controller_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-RSpec.describe 'File controller' do
-  def create_blob(data: 'Hello world!', filename: 'hello.txt', content_type: 'text/plain', identify: true, record: nil)
+RSpec.describe "File controller" do
+  def create_blob(data: "Hello world!", filename: "hello.txt", content_type: "text/plain", identify: true, record: nil)
     ActiveStorage::Blob.create_and_upload!(
       io: StringIO.new(data),
       filename: filename,
@@ -11,7 +11,7 @@ def create_blob(data: 'Hello world!', filename: 'hello.txt', content_type: 'text
     )
   end
 
-  def create_blob_before_direct_upload(byte_size:, checksum:, filename: 'hello.txt', content_type: 'text/plain')
+  def create_blob_before_direct_upload(byte_size:, checksum:, filename: "hello.txt", content_type: "text/plain")
     ActiveStorage::Blob.create_before_direct_upload!(
       filename: filename,
       byte_size: byte_size,
@@ -24,12 +24,12 @@ def unprocessable
     Gem::Version.new(Rails.version) >= Gem::Version.new("7.1") ? :unprocessable_content : :unprocessable_entity
   end
 
-  let(:blob) { create_blob(filename: 'img.jpg', content_type: 'image/jpeg') }
+  let(:blob) { create_blob(filename: "img.jpg", content_type: "image/jpeg") }
   let(:url_options) do
     {
-      protocol: 'http://',
-      host: 'test.example.com',
-      port: '3001',
+      protocol: "http://",
+      host: "test.example.com",
+      port: "3001"
     }
   end
   let(:host) { "#{url_options[:protocol]}#{url_options[:host]}:#{url_options[:port]}" }
@@ -43,120 +43,120 @@ def unprocessable
     end
   end
 
-  it 'creates a new File entity in the DB' do
+  it "creates a new File entity in the DB" do
     expect { create_blob }.to change(ActiveStorageDB::File, :count).from(0).to(1)
   end
 
-  describe '.show' do
-    it 'returns the blob as inline' do
+  describe ".show" do
+    it "returns the blob as inline" do
       blob_url = blob.respond_to?(:url) ? blob.url : blob.service_url
 
       get blob_url
 
       expect(response).to have_http_status(:ok)
-      expect(response.content_type).to eq('image/jpeg')
-      content_disposition = response.headers['Content-Disposition']
+      expect(response.content_type).to eq("image/jpeg")
+      content_disposition = response.headers["Content-Disposition"]
       expect(content_disposition).to eq("inline; filename=\"img.jpg\"; filename*=UTF-8''img.jpg")
-      expect(response.body).to eq 'Hello world!'
+      expect(response.body).to eq "Hello world!"
     end
 
-    it 'returns the blob as attachment' do
+    it "returns the blob as attachment" do
       url = blob.respond_to?(:url) ? blob.url(disposition: :attachment) : blob.service_url(disposition: :attachment)
       get url
 
       expect(response).to have_http_status(:ok)
-      expect(response.content_type).to eq('image/jpeg')
-      content_disposition = response.headers['Content-Disposition']
+      expect(response.content_type).to eq("image/jpeg")
+      content_disposition = response.headers["Content-Disposition"]
       expect(content_disposition).to eq("attachment; filename=\"img.jpg\"; filename*=UTF-8''img.jpg")
-      expect(response.body).to eq 'Hello world!'
+      expect(response.body).to eq "Hello world!"
     end
 
-    context 'with a deleted blob' do
+    context "with a deleted blob" do
       let!(:blob) { create_blob }
 
       before { blob.delete }
 
-      it 'returns not found' do
+      it "returns not found" do
         blob_url = blob.respond_to?(:url) ? blob.url : blob.service_url
         get blob_url
 
         expect(response).to have_http_status(:not_found)
       end
     end
 
-    context 'with an invalid key' do
-      it 'returns not found', :aggregate_failures do
+    context "with an invalid key" do
+      it "returns not found", :aggregate_failures do
         get blob.respond_to?(:url) ? blob.url : blob.service_url
         expect(response).to have_http_status(:ok)
 
-        invalid_key = [blob.key, '_'].join
-        get engine_url_helpers.service_path(encoded_key: invalid_key, filename: 'hello.txt')
+        invalid_key = [blob.key, "_"].join
+        get engine_url_helpers.service_path(encoded_key: invalid_key, filename: "hello.txt")
         expect(response).to have_http_status(:not_found)
       end
     end
   end
 
-  describe '.update' do
-    let(:data) { 'Something else entirely!' }
+  describe ".update" do
+    let(:data) { "Something else entirely!" }
     let(:blob) { create_blob_before_direct_upload(byte_size: data.size, checksum: Digest::MD5.base64digest(data)) }
 
-    it 'uses blob direct upload with integrity' do
-      put blob.service_url_for_direct_upload, params: data, headers: { 'Content-Type' => 'text/plain' }
+    it "uses blob direct upload with integrity" do
+      put blob.service_url_for_direct_upload, params: data, headers: { "Content-Type" => "text/plain" }
 
       expect(response).to have_http_status(:no_content)
       expect(data).to eq blob.download
     end
 
-    it 'uses blob direct upload with mismatched content type' do
-      put blob.service_url_for_direct_upload, params: data, headers: { 'Content-Type' => 'application/octet-stream' }
+    it "uses blob direct upload with mismatched content type" do
+      put blob.service_url_for_direct_upload, params: data, headers: { "Content-Type" => "application/octet-stream" }
 
       expect(response).to have_http_status(unprocessable)
       expect(blob.service).not_to exist(blob.key)
     end
 
-    context 'with an invalid checksum' do
+    context "with an invalid checksum" do
       let(:blob) do
-        create_blob_before_direct_upload(byte_size: data.size, checksum: Digest::MD5.base64digest('bad data'))
+        create_blob_before_direct_upload(byte_size: data.size, checksum: Digest::MD5.base64digest("bad data"))
       end
 
-      it 'fails to upload' do
+      it "fails to upload" do
         put blob.service_url_for_direct_upload, params: data
 
         expect(response).to have_http_status(unprocessable)
         expect(blob.service).not_to exist(blob.key)
       end
     end
 
-    context 'with an invalid content length' do
+    context "with an invalid content length" do
       let(:blob) { create_blob_before_direct_upload byte_size: data.size - 1, checksum: Digest::MD5.base64digest(data) }
 
-      it 'fails to upload' do
-        put blob.service_url_for_direct_upload, params: data, headers: { 'Content-Type' => 'text/plain' }
+      it "fails to upload" do
+        put blob.service_url_for_direct_upload, params: data, headers: { "Content-Type" => "text/plain" }
 
         expect(response).to have_http_status(unprocessable)
         expect(blob.service).not_to exist(blob.key)
       end
     end
 
-    context 'with an invalid token' do
-      it 'returns not found', :aggregate_failures do
+    context "with an invalid token" do
+      it "returns not found", :aggregate_failures do
         get blob.respond_to?(:url) ? blob.url : blob.service_url
         expect(response).to have_http_status(:not_found)
 
-        put engine_url_helpers.update_service_path(encoded_token: 'Invalid token')
+        put engine_url_helpers.update_service_path(encoded_token: "Invalid token")
         expect(response).to have_http_status(:not_found)
       end
     end
 
-    context 'when the integrity check fails' do
-      let(:invalid_file) { create(:active_storage_db_file, data: 'Some other data') }
+    context "when the integrity check fails" do
+      let(:invalid_file) { create(:active_storage_db_file, data: "Some other data") }
 
       before do
         allow(ActiveStorageDB::File).to receive(:find_by).and_return(invalid_file)
       end
 
-      it 'fails to upload' do
-        put blob.service_url_for_direct_upload, params: data, headers: { 'Content-Type' => 'text/plain' }
+      it "fails to upload" do
+        put blob.service_url_for_direct_upload, params: data, headers: { "Content-Type" => "text/plain" }
 
         expect(response).to have_http_status(unprocessable)
       end