daigaku 0.2.0 → 1.0.0

data/spec/daigaku/congratulator_spec.rb

@@ -1,23 +1,26 @@
 require 'spec_helper'
 
 describe Daigaku::Congratulator do
-
-  it "responds to #message" do
+  it 'responds to #message' do
     expect(Daigaku::Congratulator).to respond_to :message
   end
 
-  describe "#message" do
-    it "returns a string" do
+  describe '#message' do
+    it 'returns a string' do
       expect(Daigaku::Congratulator.message).to be_a String
     end
 
-    it "returns a random congratulation method" do
-      messages = 1.upto(10).map { |i| Daigaku::Congratulator.message }
+    it 'returns a random congratulation method' do
+      messages = 1.upto(10).map { |_| Daigaku::Congratulator.message }
       expect(messages.uniq.count).to be > 1
     end
 
-    it "receives the congratulation texts from a Terminal text" do
-      expect(Daigaku::Terminal).to receive(:text).with(:congratulations) { '' }
+    it 'receives the congratulation texts from a Terminal text' do
+      expect(Daigaku::Terminal)
+        .to receive(:text)
+        .with(:congratulations)
+        .and_return('')
+
       Daigaku::Congratulator.message
     end
   end

data/spec/daigaku/course_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Daigaku::Course do
-
   it { is_expected.to respond_to :title }
   it { is_expected.to respond_to :chapters }
   it { is_expected.to respond_to :path }
@@ -22,73 +21,82 @@ describe Daigaku::Course do
 
   subject { Daigaku::Course.new(course_path) }
 
-  it "responds to ::unzip" do
+  it 'responds to .unzip' do
     expect(Daigaku::Course).to respond_to :unzip
   end
 
-  it "has the prescribed title" do
+  it 'has the prescribed title' do
     expect(subject.title).to eq course_titles.first
   end
 
-  it "has the prescribed path" do
+  it 'has the prescribed path' do
     expect(subject.path).to eq course_path
   end
 
-  it "is not started by default" do
-    expect(subject.started?).to be_falsey
+  it 'is not started by default' do
+    expect(subject.started?).to be false
   end
 
-  it "is not mastered by default" do
-    expect(subject.mastered?).to be_falsey
+  it 'is not mastered by default' do
+    expect(subject.mastered?).to be false
   end
 
-  describe "#chapters" do
-    it "loads the prescribed number of chapters" do
+  describe '#chapters' do
+    it 'loads the prescribed number of chapters' do
       expect(subject.chapters.count).to eq available_chapters(course_path).count
     end
 
-    it "lazy-loads the chapters" do
+    it 'lazy-loads the chapters' do
       expect(subject.instance_variable_get(:@chapters)).to be_nil
       subject.chapters
       expect(subject.instance_variable_get(:@chapters)).not_to be_nil
     end
   end
 
-  describe "#started?" do
-    it "returns true if at least one chapter has been started" do
-      allow(subject.chapters.first).to receive(:started?) { true }
+  describe '#started?' do
+    it 'returns true if at least one chapter has been started' do
+      allow(subject.chapters.first).to receive(:started?).and_return(true)
       expect(subject.started?).to be true
     end
 
-    it "returns false if no chapter has been started" do
-      allow_any_instance_of(Daigaku::Chapter).to receive(:started?) { false }
+    it 'returns false if no chapter has been started' do
+      allow_any_instance_of(Daigaku::Chapter)
+        .to receive(:started?)
+        .and_return(false)
+
       expect(subject.started?).to be false
     end
   end
 
-  describe "#mastered?" do
-    it "returns true if all chapters have been mastered" do
-      allow_any_instance_of(Daigaku::Chapter).to receive(:mastered?) { true }
+  describe '#mastered?' do
+    it 'returns true if all chapters have been mastered' do
+      allow_any_instance_of(Daigaku::Chapter)
+        .to receive(:mastered?)
+        .and_return(true)
+
       expect(subject.mastered?).to be true
     end
 
-    it "returns false unless all chapters have been mastered" do
-      allow_any_instance_of(Daigaku::Chapter).to receive(:mastered?) { false }
-      allow(subject.chapters.first).to receive(:mastered?) { true }
+    it 'returns false unless all chapters have been mastered' do
+      allow_any_instance_of(Daigaku::Chapter)
+        .to receive(:mastered?)
+        .and_return(false)
+
+      allow(subject.chapters.first).to receive(:mastered?).and_return(true)
       expect(subject.mastered?).to be false
     end
   end
 
-  describe "#key" do
-    it "returns the courses store key for the given key name" do
-      allow(subject).to receive(:title) { '1-Course title' }
-      key = "courses/course_title/some_key"
+  describe '#key' do
+    it 'returns the courses store key for the given key name' do
+      allow(subject).to receive(:title).and_return('1-Course title')
+      key = 'courses/course_title/some_key'
       expect(subject.key('1-some Key')).to eq key
     end
   end
 
-  describe "#author" do
-    it "returns the author of Github courses form the store" do
+  describe '#author' do
+    it 'returns the author of Github courses form the store' do
       author = 'author'
       QuickStore.store.set(subject.key(:author), author)
 
@@ -97,77 +105,87 @@ describe Daigaku::Course do
     end
   end
 
-  describe "::unzip" do
+  describe '.unzip' do
     before do
       Daigaku.config.courses_path = local_courses_path
-      @zip_file_name = "unzip/repo.zip"
+
+      @zip_file_name = 'unzip/repo.zip'
       @zip_file_path = File.join(courses_basepath, @zip_file_name)
-      @file_content = prepare_download(@zip_file_name)
+      @file_content  = prepare_download(@zip_file_name)
     end
 
     after do
       cleanup_download(@zip_file_name)
       dir = File.dirname(@zip_file_path)
-      FileUtils.rm_r(dir) if Dir.exist?(dir)
+      remove_directory(dir)
     end
 
     def expect_course_dirs_exists_to_be(boolean)
       unit_dirs(course_dir_names.first).each do |chapter_dirs|
         chapter_dirs.each do |dir|
-          path = [dir.split('/')[0..-4], 'unzip', dir.split('/')[-3..-1]].join('/')
+          path = [
+            dir.split('/')[0..-4],
+            'unzip',
+            dir.split('/')[-3..-1]
+          ].join('/')
+
           expect(Dir.exist?(path)).to be boolean
         end
       end
     end
 
-    it "unzips a course zip file" do
+    it 'unzips a course zip file' do
       expect_course_dirs_exists_to_be false
       Daigaku::Course.unzip(@zip_file_path)
       expect_course_dirs_exists_to_be true
     end
 
-    it "returns the unzipped course" do
-      dir = course_dirs.first
-      path = File.join(File.dirname(dir), 'unzip', File.basename(dir))
-      course = Daigaku::Course.new(path)
+    it 'returns the unzipped course' do
+      dir    = course_dirs.first
+      path   = File.join(File.dirname(dir), 'unzip', File.basename(dir))
 
-      expect(Daigaku::Course.unzip(@zip_file_path).to_json).to eql course.to_json
+      actual = Daigaku::Course.unzip(@zip_file_path)
+      expected = Daigaku::Course.new(path)
+
+      expect(actual.path).to eq expected.path
+      expect(actual.title).to eq expected.title
+      expect(actual.author).to eq expected.author
     end
 
-    it "removes the zip file" do
+    it 'removes the zip file' do
       expect(File.exist?(@zip_file_path)).to be true
       Daigaku::Course.unzip(@zip_file_path)
       expect(File.exist?(@zip_file_path)).to be false
     end
 
-    context "with the same course already available:" do
+    context 'with the same course already available' do
       before do
         dir = course_dirs.first
         @path = File.join(File.dirname(dir), 'unzip', File.basename(dir))
         @old_chapter_dir = File.join(@path, 'Old_chapter')
 
-        FileUtils.mkdir_p(@old_chapter_dir)
+        create_directory(@old_chapter_dir)
       end
 
-      it "overwrites all chapters" do
+      it 'overwrites all chapters' do
         expect(Dir.exist?(@old_chapter_dir)).to be true
         Daigaku::Course.unzip(@zip_file_path)
         expect(Dir.exist?(@old_chapter_dir)).to be false
       end
 
-      context "if an errior occurs" do
+      context 'if an error occurs' do
         before do
           allow_any_instance_of(Zip::File)
-            .to receive(:extract) { raise Exception.new }
+            .to receive(:extract) { raise StandardError.new, 'error' }
         end
 
-        it "restores an old state if an error occurs" do
+        it 'restores an old state' do
           Daigaku::Course.unzip(@zip_file_path)
           expect(Dir.exist?(@old_chapter_dir)).to be true
           expect(Dir.exist?("#{@path}_old")).to be false
         end
 
-        it "keeps the zip file if an error occurs" do
+        it 'keeps the zip file' do
           expect(File.exist?(@zip_file_path)).to be true
           Daigaku::Course.unzip(@zip_file_path)
           expect(File.exist?(@zip_file_path)).to be true
@@ -175,12 +193,12 @@ describe Daigaku::Course do
       end
     end
 
-    context "with the github_repo option:" do
+    context 'with the github_repo option:' do
       before { @github_course_dir = prepare_github_course }
-      after { FileUtils.rm_r(@github_course_dir) }
+      after  { remove_directory(@github_course_dir) }
 
-      it "removes the '-master' from the root directory" do
-        zip_file_name = "unzip/repo-master.zip"
+      it 'removes the "-master" from the root directory' do
+        zip_file_name = 'unzip/repo-master.zip'
         zip_file_path = File.join(courses_basepath, zip_file_name)
         prepare_github_download(zip_file_name)
 
@@ -189,7 +207,12 @@ describe Daigaku::Course do
 
         unit_dirs("#{course_dir_names.first}-master").each do |chapter_dirs|
           chapter_dirs.each do |dir|
-            path = [dir.split('/')[0..-4], 'unzip', dir.split('/')[-3..-1]].join('/')
+            path = [
+              dir.split('/')[0..-4],
+              'unzip',
+              dir.split('/')[-3..-1]
+            ].join('/')
+
             expect(Dir.exist?(path)).to be false
           end
         end

data/spec/daigaku/generator_spec.rb

@@ -1,57 +1,57 @@
 require 'spec_helper'
 
 describe Daigaku::Generator do
-
-  it { is_expected.to respond_to :scaffold }
-  it { is_expected.to respond_to :prepare }
-
   subject { Daigaku::Generator.new }
 
   before do
     Daigaku.config.instance_variable_set(:@storage_file, local_storage_file)
   end
 
-  describe "#scaffold" do
-    it "creates blank solution files for all available units" do
+  it { is_expected.to respond_to :scaffold }
+  it { is_expected.to respond_to :prepare }
+
+  describe '#scaffold' do
+    it 'creates blank solution files for all available units' do
       subject.scaffold(courses_basepath, solutions_basepath)
 
       all_solution_file_paths.each do |file_path|
-        expect(File.exist?(file_path)).to be_truthy
+        expect(File.exist?(file_path)).to be true
       end
     end
   end
 
-  describe "#prepare" do
-    context "with an existing solutions_path" do
+  describe '#prepare' do
+    context 'with an existing solutions_path' do
       before do
         Daigaku.configure do |config|
           config.solutions_path = solutions_basepath
-          config.courses_path = local_courses_path
+          config.courses_path   = local_courses_path
         end
 
         subject.prepare
       end
 
-      it "generates a '<basepath>/.daigaku/daigaku.db.yml' file" do
-        expect(File.exist?(local_storage_file)).to be_truthy
+      it 'generates a "<basepath>/.daigaku/daigaku.db.yml" file' do
+        expect(File.exist?(local_storage_file)).to be true
       end
 
-      it "generates a '<basepath>/.daigaku/courses' folder" do
-        expect(Dir.exist?(local_courses_path)).to be_truthy
+      it 'generates a "<basepath>/.daigaku/courses" folder' do
+        expect(Dir.exist?(local_courses_path)).to be true
       end
 
-      it "saves the current config info" do
-        expect(File.exist?(local_storage_file)).to be_truthy
+      it 'saves the current config info' do
+        expect(File.exist?(local_storage_file)).to be true
         expect(QuickStore.store.courses_path).to eq local_courses_path
         expect(QuickStore.store.solutions_path).to eq solutions_basepath
       end
     end
 
-    context "with a missing solutions_path" do
+    context 'with a missing solutions_path' do
       before do
-        FileUtils.rm_r(solutions_basepath) if Dir.exist?(solutions_basepath)
-        base_path = File.dirname(Daigaku.config.courses_path)
-        @solutions_path =  File.join(base_path, 'solutions')
+        remove_directory(solutions_basepath)
+
+        base_path       = File.dirname(Daigaku.config.courses_path)
+        @solutions_path = File.join(base_path, 'solutions')
 
         Daigaku.config.instance_variable_set(:@solutions_path, nil)
         Daigaku.configure { |config| config.courses_path = local_courses_path }
@@ -59,24 +59,23 @@ describe Daigaku::Generator do
         subject.prepare
       end
 
-      it "generates a 'solutions' path on the base directory as the courses" do
+      it 'generates a "solutions" path on the base directory as the courses' do
         expect(Dir.exist?(@solutions_path)).to be_truthy
       end
 
-      it "generates a '<basepath>/.daigaku/daigaku.db.yml' file" do
+      it 'generates a "<basepath>/.daigaku/daigaku.db.yml" file' do
         expect(File.exist?(local_storage_file)).to be_truthy
       end
 
-      it "generates a '<basepath>/.daigaku/courses' folder" do
+      it 'generates a "<basepath>/.daigaku/courses" folder' do
         expect(Dir.exist?(local_courses_path)).to be_truthy
       end
 
-      it "saves the current config info" do
+      it 'saves the current config info' do
         expect(File.exist?(local_storage_file)).to be_truthy
         expect(QuickStore.store.courses_path).to eq local_courses_path
         expect(QuickStore.store.solutions_path).to eq @solutions_path
       end
     end
   end
-
 end

data/spec/daigaku/github_client_spec.rb

@@ -1,19 +1,18 @@
 require 'spec_helper'
 
 describe Daigaku::GithubClient do
-
-  describe "#master_zip_url" do
-    it "returns the url to the master zip file for the given github repo" do
-      url = "https://github.com/a/b/archive/master.zip"
+  describe '#master_zip_url' do
+    it 'returns the url to the master zip file for the given github repo' do
+      url = 'https://github.com/a/b/archive/master.zip'
       expect(Daigaku::GithubClient.master_zip_url('a/b')).to eq url
     end
   end
 
-  describe "#updated_at" do
-    it "fetches the updated_at timestamp from the Github API" do
-      expected_timestamp = "2015-10-21T12:00:00Z"
+  describe '#updated_at' do
+    it 'fetches the updated_at timestamp from the Github API' do
+      expected_timestamp = '2015-10-21T12:00:00Z'
       response = { updated_at: expected_timestamp }.to_json
-      url = "https://api.github.com/repos/a/b"
+      url      = 'https://api.github.com/repos/a/b'
 
       stub_request(:get, url)
         .with(headers: { 'Accept' => '*/*', 'User-Agent' => 'Ruby' })
@@ -25,29 +24,29 @@ describe Daigaku::GithubClient do
     end
   end
 
-  describe "#updated?" do
+  describe '#updated?' do
     before do
-      @received_timestamp = "2015-10-21T12:00:00Z"
+      @received_timestamp = '2015-10-21T12:00:00Z'
       response = { updated_at: @received_timestamp }.to_json
-      url = "https://api.github.com/repos/a/b"
+      url      = 'https://api.github.com/repos/a/b'
 
       stub_request(:get, url)
         .with(headers: { 'Accept' => '*/*', 'User-Agent' => 'Ruby' })
         .to_return(status: 200, body: response, headers: {})
     end
 
-    it "returns true if content was pushed to the Github repo" do
-      QuickStore.store.set('courses/b/updated_at', "2015-10-21T11:59:59Z")
-      expect(Daigaku::GithubClient.updated?('a/b')).to be_truthy
+    it 'returns true if content was pushed to the Github repo' do
+      QuickStore.store.set('courses/b/updated_at', '2015-10-21T11:59:59Z')
+      expect(Daigaku::GithubClient.updated?('a/b')).to be true
     end
 
-    it "returns false if no content was pushed to the Github repo" do
+    it 'returns false if no content was pushed to the Github repo' do
       QuickStore.store.set('courses/b/updated_at', @received_timestamp)
-      expect(Daigaku::GithubClient.updated?('a/b')).to be_falsey
+      expect(Daigaku::GithubClient.updated?('a/b')).to be false
     end
 
-    it "returns false if param is nil" do
-      expect(Daigaku::GithubClient.updated?(nil)).to be_falsey
+    it 'returns false if param is nil' do
+      expect(Daigaku::GithubClient.updated?(nil)).to be false
     end
   end
 end