daigaku 0.2.0 → 1.0.0

data/spec/daigaku/terminal/output_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Daigaku::Terminal::Output do
-
   subject do
     require 'thor'
     class Test < Thor
@@ -30,61 +29,64 @@ describe Daigaku::Terminal::Output do
     end
   end
 
-  describe "::say" do
-    it "prints the prescribed output to the $stdout" do
-      line = "line"
+  describe '.say' do
+    it 'prints the prescribed output to the $stdout' do
+      line = 'line'
       expect($stdout).to receive(:puts).with("\t#{line}")
       subject.send(:say, line)
     end
 
-    it "adds the line start in case of multiline inputs" do
-      lines = "first line\nsecond line\nthird line\n"
-      out_lines = lines.split("\n").map {|l| "\t#{l}" }.join("\n")
+    it 'adds the line start in case of multiline inputs' do
+      lines     = "first line\nsecond line\nthird line\n"
+      out_lines = lines.split("\n").map { |l| "\t#{l}" }.join("\n")
+
       expect($stdout).to receive(:puts).with(out_lines)
       subject.send(:say, lines)
     end
   end
 
-  describe "::empty_line" do
-    it "prints an empty line to the $stdout" do
+  describe '.empty_line' do
+    it 'prints an empty line to the $stdout' do
       expect($stdout).to receive(:puts).with('')
       subject.send(:empty_line)
     end
   end
 
-  describe "::get" do
-    it "prints a string to $stdout to get a line on $stdin" do
-      printed = 'printed'
-      received = 'received'
+  describe '.get' do
+    let(:text) { 'printed' }
+
+    it 'prints a string to $stdout to get a line on $stdin' do
+      allow($stdin).to receive(:gets).and_return('received')
 
-      allow($stdin).to receive(:gets) { received }
-      expect($stdout).to receive(:print).with("\n\t#{printed} ")
+      expect($stdout).to receive(:print).with("\n\t#{text} ")
       expect($stdin).to receive(:gets)
-      subject.send(:get, printed)
+      subject.send(:get, text)
     end
   end
 
-  describe "::say_info" do
-    it "prints the prescribed output to the $stdout" do
-      line = "line"
-      expect($stdout).to receive(:puts).exactly(4).times.with("")
+  describe '.say_info' do
+    let(:line) { 'line' }
+
+    it 'prints the prescribed output to the $stdout' do
+      expect($stdout).to receive(:puts).exactly(4).times.with('')
       expect($stdout).to receive(:puts).with("\t" + " ℹ #{line}".light_blue)
-      expect($stdout).to receive(:puts).twice.times.with("\t" + ('-' * 70).light_blue)
+      expect($stdout).to receive(:puts).twice.with("\t" + ('-' * 70).light_blue)
       subject.send(:say_info, line)
     end
   end
 
-  describe "::say_warning" do
-    it "prints the prescribed output to the $stdout" do
-      line = "line"
-      expect($stdout).to receive(:puts).exactly(4).times.with("")
+  describe '.say_warning' do
+    let(:line) { 'line' }
+
+    it 'prints the prescribed output to the $stdout' do
+      expect($stdout).to receive(:puts).exactly(4).times.with('')
       expect($stdout).to receive(:puts).with("\t" + "⚠  #{line}".light_red)
-      expect($stdout).to receive(:puts).twice.times.with("\t" + ('-' * 70).light_red)
+      expect($stdout).to receive(:puts).twice.with("\t" + ('-' * 70).light_red)
       subject.send(:say_warning, line)
     end
   end
 
-  describe "::get_command" do
+  describe '.get_command' do
     before do
       @correct_command = 'correct command'
       @description = 'description'
@@ -92,27 +94,30 @@ describe Daigaku::Terminal::Output do
       allow(Kernel).to receive(:system) { '' }
     end
 
-    it "prints a description" do
+    it 'prints a description' do
       expect($stdout).to receive(:puts).once.with("\t#{@description}")
       subject.send(:get_command, @correct_command, @description)
     end
 
-    it "gets a command from the $stdin" do
+    it 'gets a command from the $stdin' do
       expect($stdin).to receive(:gets)
       subject.send(:get_command, @correct_command, @description)
     end
 
-    context "with the right command typed in:" do
-      it "gets a specified command from the user" do
+    context 'with the right command typed in' do
+      it 'gets a specified command from the user' do
         subject.send(:get_command, @correct_command, @description)
       end
     end
 
-    context "with a wrong command typed  in:" do
-      it "writes a hint" do
+    context 'with a wrong command typed in' do
+      it 'writes a hint' do
         wrong_command = 'wrong command'
         error = "This was something else. Try \"#{@correct_command}\"."
-        allow($stdin).to receive(:gets).and_return(wrong_command, @correct_command)
+
+        allow($stdin)
+          .to receive(:gets)
+          .and_return(wrong_command, @correct_command)
 
         expect($stdout).to receive(:puts).once.with("\t#{error}")
         subject.send(:get_command, @correct_command, @description)
@@ -120,29 +125,29 @@ describe Daigaku::Terminal::Output do
     end
   end
 
-  describe "::get_confirm" do
+  describe '.get_confirm' do
     before do
       @description = 'description'
       allow($stdin).to receive(:gets).and_return('yes')
     end
 
-    it "prints a warning with the given description" do
+    it 'prints a warning with the given description' do
       expect(subject).to receive(:say_warning).once.with(@description)
       subject.send(:get_confirm, @description)
     end
 
-    it "gets a command from the $stdin" do
+    it 'gets a command from the $stdin' do
       expect($stdin).to receive(:gets)
       subject.send(:get_confirm, @description)
     end
 
-    it "takes a block to run when confirmed" do
+    it 'takes a block to run when confirmed' do
       allow(subject).to receive(:mocked_method).and_return('mocked method')
       expect(subject).to receive(:mocked_method)
       subject.send(:get_confirm, @description) { subject.mocked_method }
     end
 
-    it "does not run the given block if not confirmed" do
+    it 'does not run the given block if not confirmed' do
       allow(subject).to receive(:get).and_return('no')
       expect(subject).not_to receive(:mocked_method)
       subject.send(:get_confirm, @description) { subject.mocked_method }

data/spec/daigaku/terminal/setup_spec.rb

@@ -1,10 +1,8 @@
 require 'spec_helper'
 
 describe Daigaku::Terminal::Setup do
-
   it { is_expected.to be_a Thor }
   it { is_expected.to respond_to :list }
   it { is_expected.to respond_to :set }
   it { is_expected.to respond_to :init }
-
-end
+end

data/spec/daigaku/terminal/solutions_spec.rb

@@ -1,8 +1,6 @@
 require 'spec_helper'
 
 describe Daigaku::Terminal::Solutions do
-
   it { is_expected.to be_a Thor }
   it { is_expected.to respond_to :open }
-
 end

data/spec/daigaku/terminal/welcome_spec.rb

@@ -1,12 +1,10 @@
 require 'spec_helper'
 
 describe Daigaku::Terminal::Welcome do
-
   [:run, :about].each do |method|
     it "has the singleton method ::#{method}" do
       singleton_methods = Daigaku::Terminal::Welcome.singleton_methods
       expect(singleton_methods.include?(method)).to be_truthy
     end
   end
-
 end

data/spec/daigaku/terminal_spec.rb

@@ -1,24 +1,22 @@
 require 'spec_helper'
 
 describe Daigaku::Terminal do
-
   it { is_expected.to respond_to :text }
 
-  describe "::text" do
-    it "loads a text from a file in the terminal/texts" do
+  describe '.text' do
+    it 'loads a text from a file in the terminal/texts' do
       text = Daigaku::Terminal.text(:welcome)
       expect(text).to be_a String
     end
 
-    it "returns an empty string if the file does not exist" do
+    it 'returns an empty string if the file does not exist' do
       text = Daigaku::Terminal.text(:non_existent_text)
       expect(text).to eq ''
     end
 
-    it "returns an empty string if the file has no content" do
-      allow(File).to receive(:read) { '' }
+    it 'returns an empty string if the file has no content' do
+      allow(File).to receive(:read).and_return('')
       expect(Daigaku::Terminal.text(:congratulations)).to eq ''
     end
   end
-
 end

data/spec/daigaku/test_example_spec.rb

@@ -1,31 +1,34 @@
 require 'spec_helper'
 
 describe Daigaku::TestExample do
+  subject { Daigaku::TestExample.new(description: '', status: '') }
 
-    it { is_expected.to respond_to :description }
-    it { is_expected.to respond_to :status }
-    it { is_expected.to respond_to :message }
+  it { is_expected.to respond_to :description }
+  it { is_expected.to respond_to :status }
+  it { is_expected.to respond_to :message }
 
-  context "when passed:" do
+  context 'when passed' do
     let(:description) { test_passed_json_parsed[:examples].first[:description] }
-    let(:status) { test_passed_json_parsed[:examples].first[:status] }
+    let(:status)      { test_passed_json_parsed[:examples].first[:status] }
 
-    subject { Daigaku::TestExample.new(description: description, status: status) }
+    subject do
+      Daigaku::TestExample.new(description: description, status: status)
+    end
 
-    it "has the prescribed description" do
+    it 'has the prescribed description' do
       expect(subject.description).to eq description
     end
 
-    it "has the prescribed status" do
+    it 'has the prescribed status' do
       expect(subject.status).to eq status
     end
 
-    it "has the prescribed message" do
+    it 'has the prescribed message' do
       expect(subject.message).to eq example_passed_message
     end
   end
 
-  context "when failed:" do
+  context 'when failed' do
     let(:description) { test_failed_json_parsed[:examples].first[:description] }
     let(:status) { test_failed_json_parsed[:examples].first[:status] }
     let(:message) { test_failed_json_parsed[:examples].first[:exception][:message] }
@@ -38,17 +41,16 @@ describe Daigaku::TestExample do
       )
     end
 
-    it "has the prescribed description" do
+    it 'has the prescribed description' do
       expect(subject.description).to eq description
     end
 
-    it "has the prescribed status" do
+    it 'has the prescribed status' do
       expect(subject.status).to eq status
     end
 
-    it "has the prescribed message" do
+    it 'has the prescribed message' do
       expect(subject.message).to eq message
     end
   end
-
 end

data/spec/daigaku/test_result_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Daigaku::TestResult do
-
   subject { Daigaku::TestResult.new(test_passed_json) }
 
   it { is_expected.to respond_to :example_count }
@@ -11,55 +10,53 @@ describe Daigaku::TestResult do
   it { is_expected.to respond_to :summary }
   it { is_expected.to respond_to :summary_lines }
 
-  context "with passed input:" do
-
+  context 'with passed input' do
     subject { Daigaku::TestResult.new(test_passed_json) }
 
-    it "is marked passed" do
-      expect(subject.passed?).to be_truthy
+    it 'is marked passed' do
+      expect(subject.passed?).to be true
     end
 
-    it "has a default summary" do
+    it 'has a default summary' do
       expect(subject.summary).to include test_passed_summary
     end
   end
 
-  context "with failed input:" do
-
+  context 'with failed input' do
     subject { Daigaku::TestResult.new(test_failed_json) }
 
-    it "is not marked passed" do
-      expect(subject.passed?).to be_falsey
+    it 'is not marked passed' do
+      expect(subject.passed?).to be false
     end
 
-    it "has the prescribed example count" do
+    it 'has the prescribed example count' do
       example_count = test_failed_json_parsed[:summary][:example_count]
       expect(subject.example_count).to eq example_count
     end
 
-    it "has the prescribed failure count" do
+    it 'has the prescribed failure count' do
       failure_count = test_failed_json_parsed[:summary][:failure_count]
       expect(subject.failure_count).to eq failure_count
     end
 
-    describe "#examples" do
-      it "returns the prescribed number of examples" do
+    describe '#examples' do
+      it 'returns the prescribed number of examples' do
         examples_count = test_failed_json_parsed[:examples].count
         expect(subject.examples.count).to eq examples_count
       end
 
-      it "returns examples of type Daigaku::TestExample" do
+      it 'returns examples of type Daigaku::TestExample' do
         subject.examples.each do |example|
           expect(example).to be_a Daigaku::TestExample
         end
       end
 
-      it "return examples with the prescribed info" do
+      it 'return examples with the prescribed info' do
         subject.examples.each_with_index do |example, index|
           description = test_failed_json_parsed[:examples][index][:full_description]
-          status = test_failed_json_parsed[:examples][index][:status]
-          exception = test_failed_json_parsed[:examples][index][:exception]
-          message = exception ? exception[:message] : example_passed_message
+          status      = test_failed_json_parsed[:examples][index][:status]
+          exception   = test_failed_json_parsed[:examples][index][:exception]
+          message     = exception ? exception[:message] : example_passed_message
 
           expect(example.description).to eq description
           expect(example.status).to eq status
@@ -68,8 +65,8 @@ describe Daigaku::TestResult do
       end
     end
 
-    describe "#summary" do
-      it "returns a string having all example infos" do
+    describe '#summary' do
+      it 'returns a string having all example infos' do
         subject.examples.each do |example|
           expect(subject.summary).to include example.description
           expect(subject.summary).to include example.message
@@ -79,13 +76,12 @@ describe Daigaku::TestResult do
     end
   end
 
-  describe "#summary_lines" do
-    it "returns the summary split into lines" do
-      lines = ['This', 'is', 'summary', 'for', 'a', 'test']
+  describe '#summary_lines' do
+    it 'returns the summary split into lines' do
+      lines = %w(This is a summary for a test)
       allow(subject).to receive(:summary) { lines.join("\n") }
 
       expect(subject.summary_lines).to eq lines
     end
   end
-
 end

data/spec/daigaku/test_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Daigaku::Test do
-
   it { is_expected.to respond_to :path }
   it { is_expected.to respond_to :run }
 
@@ -15,34 +14,34 @@ describe Daigaku::Test do
 
   subject { Daigaku::Test.new(unit_path) }
 
-  it "has the appropriate path" do
+  it 'has the appropriate path' do
     expect(subject.path).to eq test_path
   end
 
-  describe "#run" do
+  describe '#run' do
     before do
-      course_name = course_dir_names.first
+      course_name  = course_dir_names.first
       chapter_name = chapter_dir_names.first
-      unit_name = unit_dir_names.first
+      unit_name    = unit_dir_names.first
+
       @code = available_solution(course_name, chapter_name, unit_name).code
     end
 
-    it "returns a Daigaku::TestResult" do
+    it 'returns a Daigaku::TestResult' do
       expect(subject.run(@code)).to be_a Daigaku::TestResult
     end
 
-    context "when passing" do
-      it "returns a passing result" do
+    context 'when passing' do
+      it 'returns a passing result' do
         expect(subject.run(@code).passed?).to be_truthy
       end
     end
 
-    context "when failing" do
-      it "returns a failing result" do
-        code = "print 'BYE WORLD'"
+    context 'when failing' do
+      it 'returns a failing result' do
+        code = 'print "BYE WORLD"'
         expect(subject.run(code).passed?).to be_falsey
       end
     end
   end
-
 end