daigaku 0.0.1

data/lib/daigaku/window.rb

@@ -0,0 +1,160 @@
+require 'curses'
+
+module Daigaku
+  class Window < Curses::Window
+
+    COLOR_TEXT = Curses::COLOR_YELLOW         unless defined? COLOR_TEXT
+    COLOR_TEXT_EMPHASIZE = Curses::COLOR_CYAN unless defined? COLOR_TEXT_EMPHASIZE
+    COLOR_HEADING = Curses::COLOR_WHITE       unless defined? COLOR_HEADING
+    COLOR_RED = Curses::COLOR_BLUE            unless defined? COLOR_RED
+    COLOR_GREEN = Curses::COLOR_MAGENTA       unless defined? COLOR_GREEN
+    COLOR_YELLOW = Curses::COLOR_RED          unless defined? COLOR_YELLOW
+
+    BACKGROUND = Curses::COLOR_WHITE          unless defined? BACKGROUND
+    FONT = Curses::COLOR_BLACK                unless defined? FONT
+    FONT_HEADING = Curses::COLOR_MAGENTA      unless defined? FONT_HEADING
+    FONT_EMPHASIZE = Curses::COLOR_BLUE       unless defined? FONT_EMPHASIZE
+    RED = Curses::COLOR_RED                   unless defined? RED
+    GREEN = Curses::COLOR_GREEN               unless defined? GREEN
+    YELLOW = Curses::COLOR_YELLOW             unless defined? YELLOW
+
+    def initialize(height = Curses.lines, width = Curses.cols, top = 0, left = 0)
+      super(height, width, top, left)
+      init_colors
+    end
+
+    def write(text, color = COLOR_TEXT, text_decoration = Curses::A_NORMAL )
+      self.attron(Curses.color_pair(color) | text_decoration) { self << text.to_s }
+    end
+
+    def emphasize(text, text_decoration = Curses::A_NORMAL)
+      write(text, Window::COLOR_TEXT_EMPHASIZE, text_decoration)
+    end
+
+    def heading(text, text_decoration = Curses::A_UNDERLINE)
+      write(text, Window::COLOR_HEADING, text_decoration)
+    end
+
+    def red(text, text_decoration = Curses::A_NORMAL, options = {})
+      colored(text, Window::COLOR_RED, text_decoration, options)
+    end
+
+    def yellow(text, text_decoration = Curses::A_NORMAL, options = {})
+      colored(text, Window::COLOR_YELLOW, text_decoration, options)
+    end
+
+    def green(text, text_decoration = Curses::A_NORMAL, options = {})
+      colored(text, Window::COLOR_GREEN, text_decoration, options)
+    end
+
+    def colored(text, color, text_decoration = Curses::A_NORMAL, options = {})
+      if options[:full_line]
+        clear_line(
+          color: color,
+          text_decoration: Curses::A_STANDOUT,
+          start_pos: 1,
+          end_pos: maxx - 2
+        )
+
+        prefix = ' '
+      end
+
+      write("#{prefix}#{text}", color, text_decoration)
+    end
+
+    # clear_line(options =  {})
+    # options: [:color, :text_decoration, :start_pos, :end_pos]
+    def clear_line(options = {})
+      color = options[:color] || COLOR_TEXT
+      text_decoration = options[:text_decoration] || Curses::A_NORMAL
+      start = options[:start_pos] || 0
+      stop = options[:end_pos] || maxx
+
+      x = curx
+      setpos(cury, start)
+      write(' ' * (stop - 1), color, text_decoration)
+      setpos(cury, x)
+      refresh
+    end
+
+    def print_indicator(object, text = ' ', text_decoration = Curses::A_STANDOUT)
+      if object.respond_to?(:mastered?) && object.respond_to?(:started?)
+        if object.mastered?
+          green(text, text_decoration)
+          write ' '
+        elsif object.started?
+          yellow(text, text_decoration)
+          write ' '
+        else
+          red(text, text_decoration)
+          write ' '
+        end
+      elsif object.respond_to?(:mastered?)
+        if object.mastered?
+          green(text, text_decoration)
+          write ' '
+        else
+          red(text, text_decoration)
+          write ' '
+        end
+      end
+    end
+
+    def print_markdown(text)
+      clear_line
+
+      h1 = /^\#{1}[^#]+/    # '# heading'
+      h2 = /^\#{2}[^#]+/    # '## sub heading'
+      bold = /(\*[^*]*\*)/  # '*text*'
+      line = /^-{3,}/        # '---' vertical line
+      code = /(\`*\`)/    # '`code line`'
+
+      case text
+        when h1
+          heading(text.gsub(/^#\s?/, ''))
+        when h2
+          text_decoration = Curses::A_UNDERLINE | Curses::A_NORMAL
+          emphasize(text.gsub(/^##\s?/, ''), text_decoration)
+        when bold || code
+          emphasized = false
+          highlighted = false
+
+          text.chars.each do |char|
+            if char == '*'
+              emphasized = !emphasized
+              next
+            end
+
+            if char == '`'
+              highlighted = !highlighted
+              next
+            end
+
+            if emphasized
+              emphasize(char)
+            elsif highlighted
+              red(char)
+            else
+              write(char)
+            end
+          end
+        when line
+          write('-' * (Curses.cols - 2))
+        else
+          write(text)
+      end
+    end
+
+    protected
+
+    def init_colors
+      Curses.start_color
+      Curses.init_pair(COLOR_TEXT, FONT, BACKGROUND)
+      Curses.init_pair(COLOR_TEXT_EMPHASIZE, FONT_EMPHASIZE, BACKGROUND)
+      Curses.init_pair(COLOR_HEADING, FONT_HEADING, BACKGROUND)
+      Curses.init_pair(COLOR_RED, RED, BACKGROUND)
+      Curses.init_pair(COLOR_GREEN, GREEN, BACKGROUND)
+      Curses.init_pair(COLOR_YELLOW, YELLOW, BACKGROUND)
+    end
+  end
+end

data/spec/daigaku/chapter_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Daigaku::Chapter do
+
+  it { is_expected.to respond_to :title }
+  it { is_expected.to respond_to :units }
+  it { is_expected.to respond_to :path }
+
+  it { is_expected.to respond_to :mastered? }
+  it { is_expected.to respond_to :started? }
+
+  let(:chapter_path) { chapter_dirs(course_dir_names.first).first }
+
+  before(:all) do
+    prepare_solutions
+    Daigaku.config.solutions_path = solutions_basepath
+  end
+
+  subject { Daigaku::Chapter.new(chapter_path) }
+
+  it "has the prescribed title" do
+    expect(subject.title).to eq chapter_titles.first
+  end
+
+  it "has the prescribed path" do
+    expect(subject.path).to eq chapter_path
+  end
+
+  it "is not started by default" do
+    expect(subject.started?).to be_falsey
+  end
+
+  it "is not mastered by default" do
+    expect(subject.mastered?).to be_falsey
+  end
+
+  describe "#units" do
+    it "loads the prescribed number of units" do
+      course_name = course_dir_names.first
+      chapter_name = File.basename(chapter_path)
+      units_count = available_units(course_name, chapter_name).count
+      expect(subject.units.count).to eq units_count
+    end
+
+    it "lazy-loads the units" do
+      expect(subject.instance_variable_get(:@units)).to be_nil
+      subject.units
+      expect(subject.instance_variable_get(:@units)).not_to be_nil
+    end
+  end
+
+  describe "#started?" do
+    it "returns true if at least one unit has been verified" do
+      allow(subject.units.first).to receive(:mastered?) { true }
+      expect(subject.started?).to be true
+    end
+
+    it "returns false if no unit has been verified" do
+      allow_any_instance_of(Daigaku::Unit).to receive(:mastered?) { false }
+      expect(subject.started?).to be false
+    end
+  end
+
+  describe "#mastered?" do
+    it "returns true if all units have been verified" do
+      subject.units.each { |unit| unit.solution.verify! }
+      expect(subject.mastered?).to be true
+    end
+
+    it "returns false unless all units have been verified" do
+      allow_any_instance_of(Daigaku::Unit).to receive(:mastered?) { false }
+      allow(subject.units.first).to receive(:mastered?) { true }
+      expect(subject.mastered?).to be false
+    end
+  end
+end

data/spec/daigaku/configuration_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+
+describe Daigaku::Configuration do
+
+  subject { Daigaku::Configuration.send(:new) }
+
+  it { is_expected.to respond_to :solutions_path }
+  it { is_expected.to respond_to :solutions_path= }
+  it { is_expected.to respond_to :courses_path }
+  it { is_expected.to respond_to :courses_path= }
+  it { is_expected.to respond_to :storage_file }
+  it { is_expected.to respond_to :save }
+  it { is_expected.to respond_to :import! }
+  it { is_expected.to respond_to :summary }
+
+  before do
+    subject.instance_variable_set(:@storage_file, local_storage_file)
+  end
+
+  describe "#courses_path" do
+    it "returns the appropriate initial local courses path" do
+      courses_path = File.expand_path('~/.daigaku/courses', __FILE__)
+      expect(subject.courses_path).to eq courses_path
+    end
+
+    it "returns the appropriate set courses path" do
+      subject.courses_path = local_courses_path
+      expect(subject.courses_path).to eq local_courses_path
+    end
+  end
+
+  describe "#solutions_path=" do
+    it "raises an error if the given path is no existent dir" do
+      expect { subject.solutions_path = "no/existent/dir" }
+        .to raise_error(Daigaku::ConfigurationError)
+    end
+  end
+
+  describe "#solutions_path" do
+    it "raises an error if not set" do
+      expect { subject.solutions_path }
+        .to raise_error(Daigaku::ConfigurationError)
+    end
+
+    it "returns the solutions path if set" do
+      subject.solutions_path = test_basepath
+      expect { subject.solutions_path }.not_to raise_error
+    end
+  end
+
+  describe "#storage_path" do
+    it "returns the appropriate path to the storge file" do
+      expect(subject.storage_file).to eq local_storage_file
+    end
+  end
+
+  describe "#save" do
+    it "saves the configured courses path to the daigaku database" do
+      subject.courses_path = local_courses_path
+      subject.save
+
+      expect(Daigaku::Database.courses_path).to eq local_courses_path
+    end
+
+    it "saves the configured solution_path to the daigaku database" do
+      path = File.join(test_basepath, 'test_solutions')
+      FileUtils.makedirs(path)
+      subject.solutions_path = path
+      subject.save
+
+      expect(Daigaku::Database.solutions_path).to eq path
+    end
+
+    it "does not save the storage file path" do
+      subject.save
+      expect(Daigaku::Database.storage_file).to be_nil
+    end
+  end
+
+  describe "#import!" do
+    context "with non-existent daigaku database entries:" do
+      before  do
+        FileUtils.rm(local_storage_file) if File.exist?(local_storage_file)
+      end
+
+      it "uses the default configuration" do
+        Daigaku::Database.courses_path = nil
+        Daigaku::Database.solutions_path = nil
+        subject.instance_variable_set(:@courses_path, local_courses_path)
+
+        loaded_config = subject.import!
+
+        expect(loaded_config.courses_path).to eq local_courses_path
+        expect { loaded_config.solutions_path }
+          .to raise_error Daigaku::ConfigurationError
+      end
+    end
+
+    context "with existing daigaku database file:" do
+      it "returns a Daigaku::Configuration" do
+        expect(subject.import!).to be_a Daigaku::Configuration
+      end
+
+      it "loads the daigaku database entries into the configuration" do
+        wanted_courses_path = "/courses/path"
+        wanted_solutions_path = solutions_basepath
+        temp_solutions_path = File.join(solutions_basepath, 'temp')
+        FileUtils.makedirs(wanted_solutions_path)
+        FileUtils.makedirs(temp_solutions_path)
+
+        # save wanted settings
+        subject.courses_path = wanted_courses_path
+        subject.solutions_path = wanted_solutions_path
+        subject.save
+
+        # overwrite in memory settings
+        subject.courses_path = '/some/other/path/'
+        subject.solutions_path = temp_solutions_path
+
+        # fetch stored settings
+        subject.import!
+        expect(File.exist?(local_storage_file)).to be_truthy
+        expect(subject.courses_path).to eq wanted_courses_path
+        expect(subject.solutions_path).to eq wanted_solutions_path
+      end
+    end
+  end
+
+  describe '#summary' do
+    before do
+      subject.courses_path = "wanted/courses/path"
+      subject.solutions_path = solutions_basepath
+      @summary = subject.summary
+    end
+
+    it "returns a string" do
+      expect(@summary).to be_a String
+    end
+
+    it "returns a string with all properties but @configuration_file" do
+      expect(@summary.lines.count).to eq subject.instance_variables.count - 1
+    end
+
+    it "returns a string including the courses path" do
+      expect(@summary =~ /courses path/).to be_truthy
+    end
+
+    it "returns a string including the courses path" do
+      expect(@summary =~ /solutions path/).to be_truthy
+    end
+  end
+
+  describe '#initial_course' do
+    it {  is_expected.to respond_to :initial_course }
+
+    it "returns the initial course github repo partial path" do
+      expect(subject.initial_course).to eq 'daigaku-ruby/Get_started_with_Ruby'
+    end
+  end
+
+end

data/spec/daigaku/course_spec.rb

@@ -0,0 +1,75 @@
+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 }
+  it { is_expected.to respond_to :author }
+  it { is_expected.to respond_to :link }
+
+  it { is_expected.to respond_to :mastered? }
+  it { is_expected.to respond_to :started? }
+
+  let(:course_path) { course_dirs.first }
+
+  before(:all) do
+    prepare_solutions
+    Daigaku.config.solutions_path = solutions_basepath
+  end
+
+  subject { Daigaku::Course.new(course_path) }
+
+  it "has the prescribed title" do
+    expect(subject.title).to eq course_titles.first
+  end
+
+  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
+  end
+
+  it "is not mastered by default" do
+    expect(subject.mastered?).to be_falsey
+  end
+
+  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
+      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 }
+      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 }
+      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 }
+      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 }
+      expect(subject.mastered?).to be false
+    end
+  end
+end