Enforce double quotes for strings

Author: William Tsai

.gitlab-ci.yml

@@ -6,9 +6,22 @@ include:
 stages:
   - test
   - sast_upload
+  - lint
   - rspec
   - publish
 
+rubocop:
+  stage: lint
+  image: ruby:3.4.8
+  tags:
+    - arm64
+  script:
+    - bundle install
+    - bundle exec rubocop
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+    - if: $CI_COMMIT_BRANCH == "master"
+
 rspec:
   stage: rspec
   image: ruby:3.4.8
@@ -17,8 +30,9 @@ rspec:
   script:
     - bundle install
     - rspec spec
-  only:
-    - master
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+    - if: $CI_COMMIT_BRANCH == "master"
 
 to_gem:
   stage: publish

.rubocop.yml

@@ -15,6 +15,10 @@ Layout/LineLength:
 Style/Documentation:
   Enabled: false
 
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
 Metrics/MethodLength:
   Max: 25
 

Gemfile

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 gemspec
 
 group :development, :test do
-  gem 'irb', '~> 1.17.0'
-  gem 'rspec', '~> 3.13.2'
-  gem 'rubocop', '~> 1.85.1'
-  gem 'rubocop-performance', '~> 1.26.1'
+  gem "irb", "~> 1.17.0"
+  gem "rspec", "~> 3.13.2"
+  gem "rubocop", "~> 1.85.1"
+  gem "rubocop-performance", "~> 1.26.1"
 end

error_response.gemspec

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 
 Gem::Specification.new do |s|
-  s.name        = 'error_response'
-  s.version     = File.read('./VERSION.md')
-  s.summary     = 'A tool for API error response'
-  s.description = 'use for error_response'
-  s.authors     = ['Kdan Mobile Software Developer']
-  s.email       = 'dev@kdanmobile.com'
-  s.homepage    = 'https://github.com/kdan-mobile-software-ltd/error_response'
-  s.license     = 'MIT'
-  s.files       = Dir['lib/**/*']
-  s.require_path = ['lib']
-  s.required_ruby_version = '>= 3.0'
+  s.name        = "error_response"
+  s.version     = File.read("./VERSION.md")
+  s.summary     = "A tool for API error response"
+  s.description = "use for error_response"
+  s.authors     = ["Kdan Mobile Software Developer"]
+  s.email       = "dev@kdanmobile.com"
+  s.homepage    = "https://github.com/kdan-mobile-software-ltd/error_response"
+  s.license     = "MIT"
+  s.files       = Dir["lib/**/*"]
+  s.require_path = ["lib"]
+  s.required_ruby_version = ">= 3.0"
   s.metadata = {
-    'source_code_uri' => 'https://github.com/kdan-mobile-software-ltd/error_response',
-    'changelog_uri' => 'https://github.com/kdan-mobile-software-ltd/error_response/blob/master/CHANGELOG.md',
-    'rubygems_mfa_required' => 'true'
+    "source_code_uri" => "https://github.com/kdan-mobile-software-ltd/error_response",
+    "changelog_uri" => "https://github.com/kdan-mobile-software-ltd/error_response/blob/master/CHANGELOG.md",
+    "rubygems_mfa_required" => "true"
   }
 
-  s.add_dependency 'activesupport', '~> 7.2.3.1'
+  s.add_dependency "activesupport", "~> 7.2.3.1"
 end

lib/error_response.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'yaml'
-require 'net/http'
-require 'uri'
+require "yaml"
+require "net/http"
+require "uri"
 
-require 'error_response/configuration'
-require 'error_response/helper'
-require 'error_response/request_error'
+require "error_response/configuration"
+require "error_response/helper"
+require "error_response/request_error"
 
 module ErrorResponse
   class << self
@@ -27,16 +27,16 @@ def all
     def to_hash(key)
       return {} unless yaml_hash.key?(key.to_s)
 
-      yaml_hash[key.to_s].merge({ 'error_key' => key.to_s })
+      yaml_hash[key.to_s].merge({ "error_key" => key.to_s })
     end
 
     def to_api(key, message = nil)
       json = deep_dup(yaml_hash)
-      json = json[key.to_s] || { 'error_code' => 500_000, 'error_message' => key.to_s }
-      json['error_key'] = key.to_s
-      json['error_message'] += ": #{message}" unless message.nil?
+      json = json[key.to_s] || { "error_code" => 500_000, "error_message" => key.to_s }
+      json["error_key"] = key.to_s
+      json["error_message"] += ": #{message}" unless message.nil?
       {
-        status: parse_status(json['error_code']),
+        status: parse_status(json["error_code"]),
         json: json
       }
     end
@@ -47,10 +47,10 @@ def yaml_hash
       return @hash unless @hash.nil?
 
       settings = YAML.safe_load_file(configuration.yaml_config_path, permitted_classes: permitted_classes, aliases: true)
-      local_array = settings['source']['local']
+      local_array = settings["source"]["local"]
       local_hash = local_array.nil? ? {} : local_array.map { |path| YAML.safe_load_file(path, permitted_classes: permitted_classes, aliases: true) }.inject(&:merge)
 
-      remote_array = settings['source']['remote']
+      remote_array = settings["source"]["remote"]
       remote_hash = remote_array.nil? ? {} : remote_array.map { |url| build_yaml(url) }.inject(&:merge)
 
       @hash = local_hash.merge(remote_hash)

lib/error_response/configuration.rb

@@ -5,7 +5,7 @@ class Configuration
     attr_accessor :yaml_config_path
 
     def initialize
-      @yaml_config_path = ENV['YAML_CONFIG_PATH'] || 'config/error_response.yml'
+      @yaml_config_path = ENV["YAML_CONFIG_PATH"] || "config/error_response.yml"
     end
   end
 end

lib/error_response/helper.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'active_support/concern'
+require "active_support/concern"
 
 module ErrorResponse
   module Helper

spec/error_response_spec.rb

@@ -1,72 +1,72 @@
 # frozen_string_literal: true
 
-require './lib/error_response'
+require "./lib/error_response"
 
 RSpec.describe ErrorResponse do
-  describe '#yaml_hash' do
-    it 'should fetch data from local' do
+  describe "#yaml_hash" do
+    it "should fetch data from local" do
       result = ErrorResponse.to_api(:resource_not_found)
-      expect(result[:json]['error_message']).to eq 'resource not found'
-      expect(result[:json]['error_code']).to eq 404_001
+      expect(result[:json]["error_message"]).to eq "resource not found"
+      expect(result[:json]["error_code"]).to eq 404_001
     end
 
-    it 'should fetch data from remote' do
+    it "should fetch data from remote" do
       result = ErrorResponse.to_api(:bad_request_2)
-      expect(result[:json]['error_message']).to eq 'bad request 2'
-      expect(result[:json]['error_code']).to eq 400_002
+      expect(result[:json]["error_message"]).to eq "bad request 2"
+      expect(result[:json]["error_code"]).to eq 400_002
     end
   end
 
-  describe '#to_api' do
-    it 'should return correspond hash when key existed' do
+  describe "#to_api" do
+    it "should return correspond hash when key existed" do
       hash = {
         status: 400,
         json: {
-          'error_code' => 400_001,
-          'error_message' => 'bad request 1',
-          'error_key' => 'bad_request_1'
+          "error_code" => 400_001,
+          "error_message" => "bad request 1",
+          "error_key" => "bad_request_1"
         }
       }
       result = ErrorResponse.to_api(:bad_request_1)
       expect(result).to eq hash
     end
 
-    it 'should return personalized hash when key not existed' do
+    it "should return personalized hash when key not existed" do
       hash = {
         status: 500,
         json: {
-          'error_code' => 500_000,
-          'error_message' => 'internal_error: something went wrong',
-          'error_key' => 'internal_error'
+          "error_code" => 500_000,
+          "error_message" => "internal_error: something went wrong",
+          "error_key" => "internal_error"
         }
       }
-      result = ErrorResponse.to_api(:internal_error, 'something went wrong')
+      result = ErrorResponse.to_api(:internal_error, "something went wrong")
       expect(result).to eq hash
     end
   end
 
-  describe '#to_hash' do
-    it 'should return hash when key existed' do
+  describe "#to_hash" do
+    it "should return hash when key existed" do
       hash = {
-        'error_code' => 400_001,
-        'error_message' => 'bad request 1',
-        'error_key' => 'bad_request_1'
+        "error_code" => 400_001,
+        "error_message" => "bad request 1",
+        "error_key" => "bad_request_1"
       }
       result = ErrorResponse.to_hash(:bad_request_1)
       expect(result).to eq hash
     end
 
-    it 'should return hash when key existed in remote source' do
+    it "should return hash when key existed in remote source" do
       hash = {
-        'error_code' => 400_002,
-        'error_message' => 'bad request 2',
-        'error_key' => 'bad_request_2'
+        "error_code" => 400_002,
+        "error_message" => "bad request 2",
+        "error_key" => "bad_request_2"
       }
       result = ErrorResponse.to_hash(:bad_request_2)
       expect(result).to eq hash
     end
 
-    it 'should return {} when key not existed' do
+    it "should return {} when key not existed" do
       result = ErrorResponse.to_hash(:some_error)
       empty_hash = {}
       expect(result).to eq empty_hash