daigaku 0.2.0 → 1.0.0

data/spec/daigaku/loading/chapters_spec.rb

@@ -1,14 +1,13 @@
 require 'spec_helper'
 
 describe Daigaku::Loading::Chapters do
-
   let(:subjects) { Daigaku::Loading::Chapters.load(course_dirs.first) }
 
-  it "has the prescribed number of chapters" do
+  it 'has the prescribed number of chapters' do
     expect(subjects.count).to eq available_chapters(course_dirs.first).count
   end
 
-  it "loads the available chapters" do
+  it 'loads the available chapters' do
     subjects.each_with_index do |chapter, index|
       expect(chapter.title).to eq chapter_titles[index]
     end

data/spec/daigaku/loading/courses_spec.rb

@@ -1,14 +1,13 @@
 require 'spec_helper'
 
 describe Daigaku::Loading::Courses do
-
   let(:subjects) { Daigaku::Loading::Courses.load(courses_basepath) }
 
-  it "has the prescribed number of courses" do
+  it 'has the prescribed number of courses' do
     expect(subjects.count).to eq available_courses.count
   end
 
-  it "loads the available courses" do
+  it 'loads the available courses' do
     subjects.each_with_index do |course, index|
       expect(course.title).to eq course_titles[index]
     end

data/spec/daigaku/loading/units_spec.rb

@@ -1,21 +1,20 @@
 require 'spec_helper'
 
 describe Daigaku::Loading::Units do
-
-  let(:course_name) { course_dir_names.first }
+  let(:course_name)  { course_dir_names.first }
   let(:chapter_path) { chapter_dirs(course_name).first }
   let(:chapter_name) { File.basename(chapter_path) }
 
   let(:subjects) { Daigaku::Loading::Units.load(chapter_path) }
 
-  it "has the prescribed number of units" do
+  it 'has the prescribed number of units' do
     units_count = available_units(course_name, chapter_name).count
     expect(subjects.count).to eq units_count
   end
 
-  it "loads the available units" do
+  it 'loads the available units' do
     subjects.each_with_index do |unit, index|
       expect(unit.title).to eq unit_titles[index]
     end
   end
-end
+end

data/spec/daigaku/markdown/ruby_doc_spec.rb

@@ -1,18 +1,15 @@
 require 'spec_helper'
 
 describe Daigaku::Markdown::RubyDoc do
-
-  [:parse].each do |class_method|
-    it "responds to #{class_method}" do
-      expect(Daigaku::Markdown::RubyDoc).to respond_to class_method
-    end
+  it 'responds to .parse' do
+    expect(Daigaku::Markdown::RubyDoc).to respond_to :parse
   end
 
   def parse(text)
     Daigaku::Markdown::RubyDoc.parse(text)
   end
 
-  describe '::parse' do
+  describe '.parse' do
     context 'for a text containing a core doc markup' do
       let(:base_url) { "http://ruby-doc.org/core-#{RUBY_VERSION}" }
 
@@ -56,6 +53,15 @@ describe Daigaku::Markdown::RubyDoc do
         expect(parse(markdown)).to eq "#{base_url}/Enumerator/Lazy.html#method-i-flat_map"
       end
 
+      it 'returns the right link for an instance method not starting with word characters' do
+        markdown = '(ruby-doc core: Array#<<)'
+        expect(parse(markdown)).to eq "#{base_url}/Array.html#method-i-3C-3C"
+      end
+
+      it 'returns the right link for an instance method with regex characters' do
+        markdown = '(ruby-doc core: Array#any?)'
+        expect(parse(markdown)).to eq "#{base_url}/Array.html#method-i-any-3F"
+      end
     end
 
     context 'for a text containing a stdlib doc markup' do

data/spec/daigaku/reference_solution_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Daigaku::ReferenceSolution do
-
   it { is_expected.to respond_to :code }
   it { is_expected.to respond_to :path }
   it { is_expected.to respond_to :code_lines }
@@ -13,27 +12,26 @@ describe Daigaku::ReferenceSolution do
 
   subject { Daigaku::ReferenceSolution.new(unit_path) }
 
-  it "has the prescribed path" do
+  it 'has the prescribed path' do
     path = File.join(unit_path, reference_solution_name)
     expect(subject.path).to eq path
   end
 
-  describe "#code" do
-    it "has the prescribed code" do
+  describe '#code' do
+    it 'has the prescribed code' do
       expect(subject.code).to eq solution_content
     end
 
-    it "returns an empty string if the code is not available" do
+    it 'returns an empty string if the code is not available' do
       subject.instance_variable_set(:@code, nil)
-      expect(subject.code).to eq ""
+      expect(subject.code).to eq ''
     end
   end
 
-
-  describe "#code_lines" do
-    it "returns the code split into lines" do
+  describe '#code_lines' do
+    it 'returns the code split into lines' do
       lines = ['muffin = "sweet"', 'hamburger = "mjummy"']
-      allow(subject).to receive(:code) { lines.join("\n") }
+      allow(subject).to receive(:code).and_return(lines.join("\n"))
 
       expect(subject.code_lines).to eq lines
     end

data/spec/daigaku/solution_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Daigaku::Solution do
-
   it { is_expected.to respond_to :code }
   it { is_expected.to respond_to :path }
   it { is_expected.to respond_to :verify! }
@@ -14,39 +13,39 @@ describe Daigaku::Solution do
   end
 
   let(:solution_path) { all_solution_file_paths.first }
-  let(:unit_path) { all_unit_dirs.first }
+  let(:unit_path)     { all_unit_dirs.first }
 
   subject { Daigaku::Solution.new(unit_path) }
 
-  it "has the prescribed solution path from the given unit path" do
+  it 'has the prescribed solution path from the given unit path' do
     expect(subject.path).to eq solution_path
   end
 
-  it "has the prescribed code" do
+  it 'has the prescribed code' do
     expect(subject.code).to eq solution_content
   end
 
-  it "loads the verified state from the store on creation" do
+  it 'loads the verified state from the store on creation' do
     Daigaku::Solution.new(unit_path).verify!
     solution = Daigaku::Solution.new(unit_path)
 
     expect(solution).to be_verified
   end
 
-  describe "#store_key" do
-    it "returns the appropriate key string for the solution" do
-      key = "verified/course_a/chapter_a/unit_a"
+  describe '#store_key' do
+    it 'returns the appropriate key string for the solution' do
+      key = 'verified/course_a/chapter_a/unit_a'
       expect(subject.store_key).to eq key
     end
   end
 
-  context "Verification" do
-    describe "#verify!" do
-      it "returns a TestResult" do
+  context 'Verification' do
+    describe '#verify!' do
+      it 'returns a TestResult' do
         expect(subject.verify!).to be_a Daigaku::TestResult
       end
 
-      it "sets @verified true if Test passed" do
+      it 'sets @verified true if Test passed' do
         QuickStore.store.set(subject.store_key, false)
         solution = Daigaku::Solution.new(unit_path)
 
@@ -55,32 +54,32 @@ describe Daigaku::Solution do
         expect(solution.instance_variable_get(:@verified)).to be_truthy
       end
 
-      it "sets the solution's state in the store to verified if passed" do
+      it 'sets the solution’s state in the store to verified if passed' do
         subject.verify!
         mastered = QuickStore.store.get(subject.store_key)
 
         expect(mastered).to be_truthy
       end
 
-      it "sets the solution's state in the store to unverified unless passed" do
-        subject.instance_variable_set(:@code, 'puts "I ❤ Daigaku!"')
+      it 'sets the solution’s state in the store to unverified unless passed' do
+        allow(File).to receive(:read).and_return('puts "I ❤ Daigaku!"')
+        QuickStore.store.set(subject.store_key, true)
+
         subject.verify!
         mastered = QuickStore.store.get(subject.store_key)
-
         expect(mastered).to be_falsey
       end
     end
 
-    describe "#verified?" do
-      it "is false by default" do
-        expect(subject.verified?).to be_falsey
+    describe '#verified?' do
+      it 'is false by default' do
+        expect(subject.verified?).to be false
       end
 
-      it "returns true if #verify! passed" do
+      it 'returns true if #verify! passed' do
         subject.verify!
-        expect(subject.verified?).to be_truthy
+        expect(subject.verified?).to be true
       end
     end
   end
-
 end

data/spec/daigaku/storeable_spec.rb

@@ -1,35 +1,37 @@
 require 'spec_helper'
 
 describe Daigaku::Storeable do
-
-  it "responds to ::key" do
+  it 'responds to .key' do
     expect(Daigaku::Storeable).to respond_to :key
   end
 
-  describe '::key' do
-    it "creates a store key from the given string" do
+  describe '.key' do
+    it 'creates a store key from the given string' do
       key = Daigaku::Storeable.key('1-_Raw content-Title')
       expect(key).to eq 'raw_content_title'
     end
 
-    it "creates a cleaned up store key from a given path string" do
+    it 'creates a cleaned up store key from a given path string' do
       key = Daigaku::Storeable.key('path/to/the/1-_Raw content string')
       expect(key).to eq 'path/to/the/raw_content_string'
     end
 
-    it "creates a prefixed key when a prefix option is given" do
+    it 'creates a prefixed key when a prefix option is given' do
       key = Daigaku::Storeable.key('1-_Raw content-Title', prefix: 'courses')
       expect(key).to eq 'courses/raw_content_title'
     end
 
-    it "creates a suffixed key if a suffix option is given" do
+    it 'creates a suffixed key if a suffix option is given' do
       key = Daigaku::Storeable.key('1-_Raw content-Title', suffix: '1-author')
       expect(key).to eq 'raw_content_title/author'
     end
 
-    it "creates a multi suffixed key if a suffixes option is given" do
-      key = Daigaku::Storeable.key('1-_Raw content-Title', suffixes: ['meta', '1-author'] )
+    it 'creates a multi suffixed key if a suffixes option is given' do
+      suffixes = ['meta', '1-author']
+      title    = '1-_Raw content-Title'
+      key      = Daigaku::Storeable.key(title, suffixes: suffixes)
+
       expect(key).to eq 'raw_content_title/meta/author'
     end
   end
-end
+end

data/spec/daigaku/task_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Daigaku::Task do
-
   it { is_expected.to respond_to :markdown }
   it { is_expected.to respond_to :path }
 
@@ -12,12 +11,12 @@ describe Daigaku::Task do
 
   subject { Daigaku::Task.new(unit_path) }
 
-  it "has the prescribed path" do
+  it 'has the prescribed path' do
     path = File.join(unit_path, task_name)
     expect(subject.path).to eq path
   end
 
-  it "has the prescribed markdown" do
+  it 'has the prescribed markdown' do
     expect(subject.markdown).to eq task_file_content
   end
-end
+end

data/spec/daigaku/terminal/cli_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
 describe Daigaku::Terminal::CLI do
+  before { suppress_print_out }
 
   it { is_expected.to be_a Thor }
   it { is_expected.to respond_to :about }
@@ -11,40 +12,47 @@ describe Daigaku::Terminal::CLI do
   it { is_expected.to respond_to :solutions }
   it { is_expected.to respond_to :setup }
 
-  describe "#learn" do
-    it "starts the daigaku terminal app if there are courses" do
-      allow(Daigaku::Loading::Courses).to receive(:load) { [1] }
-      allow(Daigaku).to receive(:start) { true }
-      expect(Daigaku).to receive(:start)
+  describe '#learn' do
+    before { allow(Daigaku).to receive(:start).and_return(true) }
 
-      subject.learn
+    context 'if there are courses' do
+      before do
+        allow(Daigaku::Loading::Courses).to receive(:load).and_return([1])
+      end
+
+      it 'starts the daigaku terminal app' do
+        expect(Daigaku).to receive(:start)
+        subject.learn
+      end
     end
 
-    it "does not start the daigaku terminal app if there are no courses" do
-      suppress_print_out
-      allow(Daigaku::Loading::Courses).to receive(:load) { [] }
-      allow(Daigaku).to receive(:start) { true }
-      expect(Daigaku).not_to receive(:start)
+    context 'if there are no courses' do
+      before do
+        allow(Daigaku::Loading::Courses).to receive(:load).and_return([])
+      end
 
-      subject.learn
+      it 'does not start the daigaku terminal app' do
+        expect(Daigaku).not_to receive(:start)
+        subject.learn
+      end
     end
   end
 
-  describe "#welcome" do
-    it "runs the welcome routine" do
-      allow(Daigaku::Terminal::Welcome).to receive(:run) { true }
+  describe '#welcome' do
+    it 'runs the welcome routine' do
+      allow(Daigaku::Terminal::Welcome).to receive(:run).and_return(true)
       expect(Daigaku::Terminal::Welcome).to receive(:run).once
-
       subject.welcome
     end
   end
 
-  describe "#scaffold" do
-    it "runs the scaffolding" do
-      allow($stdout).to receive(:puts) {}
-      allow_any_instance_of(Daigaku::Generator).to receive(:scaffold) { true }
-      expect_any_instance_of(Daigaku::Generator).to receive(:scaffold).once
+  describe '#scaffold' do
+    it 'runs the scaffolding' do
+      allow_any_instance_of(Daigaku::Generator)
+        .to receive(:scaffold)
+        .and_return(true)
 
+      expect_any_instance_of(Daigaku::Generator).to receive(:scaffold).once
       subject.scaffold
     end
   end

data/spec/daigaku/terminal/courses_spec.rb

@@ -1,102 +1,104 @@
 require 'spec_helper'
 
 describe Daigaku::Terminal::Courses do
-
   before { suppress_print_out }
 
   it { is_expected.to be_a Thor }
 
-  describe "commands" do
-    [:list, :download].each do |method|
-      it { is_expected.to respond_to method }
-    end
+  describe 'commands' do
+    it { is_expected.to respond_to :list }
+    it { is_expected.to respond_to :download }
   end
 
-  describe "#download" do
+  describe '#download' do
     before do
       Daigaku.config.courses_path = local_courses_path
 
-      @zip_file_name = "repo.zip"
-      @file_content = prepare_download(@zip_file_name)
-      @url = "https://example.com/#{@zip_file_name}"
+      @zip_file_name = 'repo.zip'
+      @file_content  = prepare_download(@zip_file_name)
+      @url           = "https://example.com/#{@zip_file_name}"
 
       stub_request(:get, @url)
-        .with(headers: {
-          'Accept' => '*/*',
-          'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
-          'User-Agent' => 'Ruby'
-          })
-        .to_return(status: 200, body: @file_content, headers: {})
-
-      stub_request(:get, "https://api.github.com/repos/daigaku-ruby/Get_started_with_Ruby")
+        .with(
+          headers: {
+            'Accept' => '*/*',
+            'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+            'User-Agent' => 'Ruby'
+          }
+        ).to_return(status: 200, body: @file_content, headers: {})
+
+      stub_request(:get, 'https://api.github.com/repos/daigaku-ruby/Get_started_with_Ruby')
         .with(headers: { 'Accept' => '*/*', 'User-Agent' => 'Ruby' })
-        .to_return(status: 200, body: "{}", headers: {})
+        .to_return(status: 200, body: '{}', headers: {})
     end
 
     after { cleanup_download(@zip_file_name) }
 
-    it "downloads the file from a given url" do
-      expect{ subject.download(@url) }.not_to raise_error
+    it 'downloads the file from a given url' do
+      expect { subject.download(@url) }.not_to raise_error
     end
 
-    it "uses Courses.unzip to unzip the course" do
+    it 'uses Courses.unzip to unzip the course' do
       expect(Daigaku::Course).to receive(:unzip).once
       subject.download(@url)
     end
 
-    it "creates a new courses folder in the daigaku courses directory" do
+    it 'creates a new courses folder in the daigaku courses directory' do
       target_path = File.join(Daigaku.config.courses_path, File.basename(course_dirs.first))
       dirs = Dir[File.join(Daigaku.config.courses_path, '**')]
       expect(dirs.include?(target_path)).to be_truthy
     end
 
-    it "raises an error if param is no url" do
+    it 'raises an error if param is no url' do
       expect(subject).to receive(:say_warning)
       subject.download('no-url')
     end
 
-    it "raises an error if param is no url to a zip file" do
+    it 'raises an error if param is no url to a zip file' do
       expect(subject).to receive(:say_warning)
       subject.download('http://exmaple.com/something-else')
     end
 
-    describe "stores download data:" do
+    describe 'stores download data:' do
       before do
-        @github_url = "https://github.com/user/course_a/archive/master.zip"
+        @github_url = 'https://github.com/user/course_a/archive/master.zip'
 
         stub_request(:get, @github_url)
-          .with(headers: {
-            'Accept' => '*/*',
-            'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
-            'User-Agent' => 'Ruby'
-            })
-          .to_return(status: 200, body: @file_content, headers: {})
-
-        stub_request(:get, "https://api.github.com/repos/course_a/repo")
+          .with(
+            headers: {
+              'Accept' => '*/*',
+              'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+              'User-Agent' => 'Ruby'
+            }
+          ).to_return(status: 200, body: @file_content, headers: {})
+
+        stub_request(:get, 'https://api.github.com/repos/course_a/repo')
           .with(headers: { 'Accept' => '*/*', 'User-Agent' => 'Ruby' })
-          .to_return(status: 200, body: "{}", headers: {})
+          .to_return(status: 200, body: '{}', headers: {})
       end
 
-      it "stores the course's author for courses from Github" do
+      it 'stores the course’s author for courses from Github' do
         subject.download(@github_url)
         store_key = 'courses/course_a/author'
         expect(QuickStore.store.get(store_key)).to eq 'user'
       end
 
-      it "stores the course's repo for courses from Github" do
+      it 'stores the course’s repo for courses from Github' do
         subject.download(@github_url)
         store_key = 'courses/course_a/github'
         expect(QuickStore.store.get(store_key)).to eq 'user/course_a'
       end
 
-      it "stores the downloading timestamp" do
+      it 'stores the downloading timestamp' do
         time = Time.now
-        allow(Time).to receive(:now) { time }
+        allow(Time).to receive(:now).and_return(time)
         subject.download(@url)
-        expect(QuickStore.store.get('courses/course_a/updated_at')).to eq time.to_s
+
+        updated_at = QuickStore.store.get('courses/course_a/updated_at')
+        expect(updated_at).to eq time.to_s
       end
 
-      it "stores the course's download url" do
+      it 'stores the course’s download url' do
         subject.download(@url)
         expect(QuickStore.store.get('courses/course_a/url')).to eq @url
       end
@@ -107,44 +109,46 @@ describe Daigaku::Terminal::Courses do
     before do
       Daigaku.config.courses_path = local_courses_path
 
-      @zip_file_name = "repo.zip"
-      @file_content = prepare_download(@zip_file_name)
-      @url = "https://example.com/#{@zip_file_name}"
+      @zip_file_name = 'repo.zip'
+      @file_content  = prepare_download(@zip_file_name)
+      @url           = "https://example.com/#{@zip_file_name}"
 
       stub_request(:get, @url)
-        .with(headers: {
-          'Accept' => '*/*',
-          'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
-          'User-Agent' => 'Ruby'
-          })
-        .to_return(status: 200, body: @file_content, headers: {})
-
-      stub_request(:get, "https://api.github.com/repos/daigaku-ruby/Get_started_with_Ruby")
+        .with(
+          headers: {
+            'Accept' => '*/*',
+            'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+            'User-Agent' => 'Ruby'
+          }
+        ).to_return(status: 200, body: @file_content, headers: {})
+
+      stub_request(:get, 'https://api.github.com/repos/daigaku-ruby/Get_started_with_Ruby')
         .with(headers: { 'Accept' => '*/*', 'User-Agent' => 'Ruby' })
-        .to_return(status: 200, body: "{}", headers: {})
+        .to_return(status: 200, body: '{}', headers: {})
 
-      allow(subject).to receive(:download) { true }
-      allow(Daigaku::GithubClient).to receive(:updated?) { |attr| true }
+      allow(subject).to receive(:download).and_return(true)
+      allow(Daigaku::GithubClient).to receive(:updated?).and_return(true)
     end
 
     after { cleanup_download(@zip_file_name) }
 
-    it "updates a course that is not from Github on each call" do
+    it 'updates a course that is not from Github on each call' do
       url = 'https://example.com/repo.zip'
       expect(subject).to receive(:download).with(url, 'updated').once
       subject.update('Course_A')
     end
 
-    it "updates a course from Github if there are new contents" do
-      url = "https://github.com/user/repo/archive/master.zip"
+    it 'updates a course from Github if there are new contents' do
+      url = 'https://github.com/user/repo/archive/master.zip'
 
       stub_request(:get, url)
-        .with(headers: {
-          'Accept' => '*/*',
-          'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
-          'User-Agent' => 'Ruby'
-          })
-        .to_return(status: 200, body: @file_content, headers: {})
+        .with(
+          headers: {
+            'Accept' => '*/*',
+            'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+            'User-Agent' => 'Ruby'
+          }
+        ).to_return(status: 200, body: @file_content, headers: {})
 
       QuickStore.store.set('courses/course_a/url', url)
 
@@ -152,17 +156,18 @@ describe Daigaku::Terminal::Courses do
       subject.update('Course_A')
     end
 
-    it "does not update a course from Github if there are no new contents" do
-      allow(Daigaku::GithubClient).to receive(:updated?) { false }
-      url = "https://github.com/user/repo/archive/master.zip"
+    it 'does not update a course from Github if there are no new contents' do
+      allow(Daigaku::GithubClient).to receive(:updated?).and_return(false)
+      url = 'https://github.com/user/repo/archive/master.zip'
 
       stub_request(:get, url)
-        .with(headers: {
-          'Accept' => '*/*',
-          'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
-          'User-Agent' => 'Ruby'
-          })
-        .to_return(status: 200, body: @file_content, headers: {})
+        .with(
+          headers: {
+            'Accept' => '*/*',
+            'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+            'User-Agent' => 'Ruby'
+          }
+        ).to_return(status: 200, body: @file_content, headers: {})
 
       QuickStore.store.set('courses/course_a/url', url)
       QuickStore.store.set('courses/course_a/github', 'user/repo')
@@ -171,7 +176,7 @@ describe Daigaku::Terminal::Courses do
       subject.update('Course_A')
     end
 
-    it "updates all courses if --all option is given" do
+    it 'updates all courses if --all option is given' do
       file_content = prepare_download(@zip_file_name, multiple_courses: true)
 
       stub_request(:get, @url)
@@ -183,7 +188,7 @@ describe Daigaku::Terminal::Courses do
           }
         ).to_return(status: 200, body: file_content, headers: {})
 
-      allow(subject).to receive(:options) { { all: true } }
+      allow(subject).to receive(:options).and_return(all: true)
       allow(subject).to receive(:download).exactly(course_dirs.count).times
 
       subject.update
@@ -198,49 +203,49 @@ describe Daigaku::Terminal::Courses do
       allow(subject).to receive(:get).and_return('yes')
     end
 
-    describe "confirmation" do
-      it "is nessecary to delete all courses" do
-        allow(subject).to receive(:options) { { all: true } }
+    describe 'confirmation' do
+      it 'is nessecary to delete all courses' do
+        allow(subject).to receive(:options).and_return(all: true)
         expect(subject).to receive(:get_confirm)
         subject.delete
       end
 
-      it "is nessecary to delete a certain course" do
+      it 'is nessecary to delete a certain course' do
         expect(subject).to receive(:get_confirm)
         subject.delete(course_dir_names.first)
       end
     end
 
-    context "when confirmed:" do
-      it "deletes the given course" do
+    context 'when confirmed:' do
+      it 'deletes the given course' do
         expect(Dir.exist?(@course_path)).to be_truthy
         subject.delete(course_dir_names.first)
         expect(Dir.exist?(@course_path)).to be_falsey
       end
 
-      it "deletes all courses with option --all" do
-        allow(subject).to receive(:options) { { all: true } }
+      it 'deletes all courses with option --all' do
+        allow(subject).to receive(:options).and_return(all: true)
         expect(Dir.exist?(@course_path)).to be_truthy
         subject.delete
 
         course_dirs.each do |dir|
-          expect(Dir.exist?(dir)).to be_falsey
+          expect(Dir.exist?(dir)).to be false
         end
       end
     end
 
-    context "when not confirmed:" do
+    context 'when not confirmed:' do
       before { allow(subject).to receive(:get).and_return('no') }
 
-      it "does not delete the given course" do
+      it 'does not delete the given course' do
         expect(Dir.exist?(@course_path)).to be_truthy
         subject.delete(course_dir_names.first)
         expect(Dir.exist?(@course_path)).to be_truthy
       end
 
-      it "does not delete all courses" do
-        allow(subject).to receive(:options) { { all: true } }
-        expect(Dir.exist?(@course_path)).to be_truthy
+      it 'does not delete all courses' do
+        allow(subject).to receive(:options).and_return(all: true)
+        expect(Dir.exist?(@course_path)).to be true
         subject.delete
 
         course_dirs.each do |dir|
@@ -249,29 +254,30 @@ describe Daigaku::Terminal::Courses do
       end
     end
 
-    describe "status information" do
-      it "is printed when a certain course was deleted" do
+    describe 'status information' do
+      it 'is printed when a certain course was deleted' do
         expect(subject).to receive(:say_info)
         subject.delete(course_dir_names.first)
       end
 
-      it "is printed when all courses were deleted" do
-        allow(subject).to receive(:options) { { all: true } }
+      it 'is printed when all courses were deleted' do
+        allow(subject).to receive(:options).and_return(all: true)
         expect(subject).to receive(:say_info)
         subject.delete
       end
     end
 
-    describe "QuickStore data" do
-      it "is deleted for a certain course" do
+    describe 'QuickStore data' do
+      it 'is deleted for a certain course' do
         key = Daigaku::Storeable.key(course_dir_names.first, prefix: 'courses')
         QuickStore.store.set(key, 'some value')
         subject.delete(course_dir_names.first)
+
         expect(QuickStore.store.get(key)).to be_nil
       end
 
-      it "is deleted for all courses when option --all is set" do
-        allow(subject).to receive(:options) { { all: true } }
+      it 'is deleted for all courses when option --all is set' do
+        allow(subject).to receive(:options).and_return(all: true)
 
         keys = course_dir_names.map do |course_name|
           Daigaku::Storeable.key(course_name, prefix: 'courses')
@@ -283,10 +289,9 @@ describe Daigaku::Terminal::Courses do
 
         subject.delete
 
-        course_dir_names.each_with_index do |course_name, index|
+        course_dir_names.each_with_index do |_, index|
           expect(QuickStore.store.get(keys[index])).to be_nil
         end
-
       end
     end
   end