daigaku 0.2.0 → 1.0.0

data/lib/daigaku/views/courses_menu.rb

@@ -2,9 +2,7 @@ require 'daigaku/views/menu'
 
 module Daigaku
   module Views
-
     class CoursesMenu < Menu
-
       private
 
       def header_text
@@ -14,17 +12,17 @@ module Daigaku
       def interact_with(window)
         while char = window.getch
           case char
-            when KEY_UP
-              @position -= 1
-              broadcast(:reset_menu_position)
-            when KEY_DOWN
-              @position += 1
-              broadcast(:reset_menu_position)
-            when 10 # Enter
-              broadcast(:enter, models[@position])
-              return
-            when 27 # ESC
-              exit
+          when KEY_UP
+            @position -= 1
+            broadcast(:reset_menu_position)
+          when KEY_DOWN
+            @position += 1
+            broadcast(:reset_menu_position)
+          when 10 # Enter
+            broadcast(:enter, models[@position])
+            return
+          when 27 # ESC
+            exit
           end
 
           @position = items.length - 1 if @position < 0
@@ -41,12 +39,11 @@ module Daigaku
         non_empty_courses = models.select { |course| !course.chapters.empty? }
 
         non_empty_courses.map do |course|
-          line = "#{course.title}"
+          line = course.title
           self.items_info <<= [(course.author ? "(by #{course.author})" : '')]
           line
         end
       end
     end
-
   end
 end

data/lib/daigaku/views/main_menu.rb

@@ -1,37 +1,37 @@
+require_relative 'subscriber'
+
 module Daigaku
   module Views
-
+    # Subscription: `first.subscribe(second)` means
+    # first subscribes second on the first's broadcast.
+    # second has to have method that is broadcasted.
     class MainMenu
       include Views
 
-      def initialize
-        courses_menu = Views::CoursesMenu.new
-        chapters_menu = Views::ChaptersMenu.new
-        units_menu = Views::UnitsMenu.new
-        task_view = Views::TaskView.new
+      attr_reader :courses_menu, :chapters_menu, :units_menu, :task_view
 
-        # Subscription: `first.subscribe(second)` means
-        # first subscribes second on the first's broadcast.
-        # second has to have method that is broadcasted.
+      def initialize
+        @courses_menu  = Views::CoursesMenu.new
+        @chapters_menu = Views::ChaptersMenu.new
+        @units_menu    = Views::UnitsMenu.new
+        @task_view     = Views::TaskView.new
 
-        # top down navigation
-        courses_menu.subscribe(chapters_menu, on: :enter)
-        chapters_menu.subscribe(units_menu, on: :enter)
-        units_menu.subscribe(task_view, on: :enter)
+        subscribe_events
+        courses_menu.enter
+      end
 
-        # bottom up navigation
-        chapters_menu.subscribe(courses_menu, on: :reenter)
-        units_menu.subscribe(chapters_menu, on: :reenter)
-        task_view.subscribe(units_menu, on: :reenter)
+      private
 
-        # position reset
-        courses_menu.subscribe(chapters_menu, on: :reset_menu_position)
-        courses_menu.subscribe(units_menu, on: :reset_menu_position)
-        chapters_menu.subscribe(units_menu, on: :reset_menu_position)
+      def subscribe_events
+        subscriber = Subscriber.new(
+          courses_menu:  courses_menu,
+          chapters_menu: chapters_menu,
+          units_menu:    units_menu,
+          task_view:     task_view
+        )
 
-        courses_menu.enter
+        subscriber.subscribe_events!
       end
     end
-
   end
 end

data/lib/daigaku/views/menu.rb

@@ -2,17 +2,18 @@ require 'wisper'
 
 module Daigaku
   module Views
-
     class Menu
       include Views
       include Wisper::Publisher
 
       TOP_BAR_TEXT = [
-        'Use *UP KEY* and *DOWN KEY* for menu navigation',
-        'Enter menu with *RETURN*',
-        'Go back with *BACKSPACE*',
-        'Exit with *ESC*'
-      ].join('  |  ')
+        'Use * 🠕 * and * 🠗 * for menu navigation',
+        'Enter menu with * ⏎ *',
+        'Go back with * ⟵ *',
+        'Exit with *Esc*'
+      ].join('  |  ').freeze
+
+      attr_writer :items_info
 
       def initialize
         @position = 0
@@ -46,44 +47,39 @@ module Daigaku
       def draw(window, active_index = 0)
         window.attrset(A_NORMAL)
         window.setpos(0, 1)
-        window.print_markdown header_text
+        window.print_markdown(header_text)
 
         items.each_with_index do |item, index|
           window.setpos(index + 2, 1)
           window.print_indicator(models[index])
           window.attrset(index == active_index ? A_STANDOUT : A_NORMAL)
-          window.write " #{item.to_s} "
+          window.write " #{item} "
           window.attrset(A_NORMAL)
-          window.write " #{items_info[index].try(:join, ' ')}"
+          window.write " #{items_info[index] && items_info[index].join(' ')}"
         end
 
         window.refresh
       end
 
       def interact_with(window)
-        raise "Please implement the method #interact_with!"
+        raise 'Please implement the method #interact_with!'
       end
 
       def models
-        raise "Please implement the method #models!"
+        raise 'Please implement the method #models!'
       end
 
       def items
-        raise "Please implement the method #items!"
+        raise 'Please implement the method #items!'
       end
 
       def header_text
-        raise "Please implement the method #header_text!"
+        raise 'Please implement the method #header_text!'
       end
 
       def items_info
         @items_info || []
       end
-
-      def items_info=(items_info)
-        @items_info = items_info
-      end
     end
-
   end
 end

data/lib/daigaku/views/splash.rb

@@ -1,14 +1,12 @@
 module Daigaku
   module Views
-
     class Splash
       include Views
 
       def initialize
-        title = "DAIGAKU"
-        subtitle = "Learning the Ruby programming language dead easy."
-
-        panel = default_window
+        title    = 'DAIGAKU'
+        subtitle = 'Learning the Ruby programming language dead easy.'
+        panel    = default_window
 
         lines.times do |line|
           panel.setpos(line, 0)
@@ -43,15 +41,15 @@ module Daigaku
 
       def ruby_ascii_art
         [
-            "  ___________  ",
-            " /.\\  /.\\  /.\\ ",
-            "/___\\/___\\/___\\",
-            " \\  \\  . / . / ",
-            "   \\ \\ ./ ./   ",
-            "    \\\\ / /    ",
-            "      \\./     "
+          '  ___________  ',
+          ' /.\\  /.\\  /.\\ ',
+          '/___\\/___\\/___\\',
+          ' \\  \\  . / . / ',
+          '   \\ \\ ./ ./   ',
+          '    \\\\ / /    ',
+          '      \\./     '
         ]
       end
     end
   end
-end
+end

data/lib/daigaku/views/subscriber.rb

@@ -0,0 +1,38 @@
+module Daigaku
+  module Views
+    class Subscriber
+      attr_reader :courses_menu, :chapters_menu, :units_menu, :task_view
+
+      def initialize(courses_menu:, chapters_menu:, units_menu:, task_view:)
+        @courses_menu  = courses_menu
+        @chapters_menu = chapters_menu
+        @units_menu    = units_menu
+        @task_view     = task_view
+      end
+
+      def subscribe_events!
+        subscribe_top_down_navigation
+        subscribe_bottom_up_navigation
+        subscribe_menu_position_reset
+      end
+
+      def subscribe_top_down_navigation
+        courses_menu.subscribe(chapters_menu, on: :enter)
+        chapters_menu.subscribe(units_menu, on: :enter)
+        units_menu.subscribe(task_view, on: :enter)
+      end
+
+      def subscribe_bottom_up_navigation
+        chapters_menu.subscribe(courses_menu, on: :reenter)
+        units_menu.subscribe(chapters_menu, on: :reenter)
+        task_view.subscribe(units_menu, on: :reenter)
+      end
+
+      def subscribe_menu_position_reset
+        courses_menu.subscribe(chapters_menu, on: :reset_menu_position)
+        courses_menu.subscribe(units_menu, on: :reset_menu_position)
+        chapters_menu.subscribe(units_menu, on: :reset_menu_position)
+      end
+    end
+  end
+end

data/lib/daigaku/views/task_view.rb

@@ -1,41 +1,41 @@
+require 'wisper'
+require 'os'
+
 module Daigaku
   module Views
-    require 'wisper'
-    require 'os'
-
     class TaskView
       include Views
       include Wisper::Publisher
 
       TOP_BAR_TEXT = [
-          'Scroll with *UP KEY* and *DOWN KEY*',
-          'Open solution file with *o*',
-          'Verify solution with *v*',
-          'Clear validation with *c*',
-          'Exit with *ESC*'
-          ].join('  |  ')
+        'Scroll with * 🠕 * and * 🠗 *',
+        'Open solution file with *o*',
+        'Verify solution with *v*',
+        'Clear validation with *c*',
+        'Exit with *Esc*'
+      ].join('  |  ').freeze
 
       def initialize
         @lines = []
-        @top = nil
+        @top   = nil
       end
 
       def enter(course, chapter, unit)
-        @course = course
+        @course  = course
         @chapter = chapter
-        @unit = unit
+        @unit    = unit
 
         @test_result_lines = nil
-        @lines = @unit.task.markdown.lines
-        @top_bar_height = 4
-        @head_height = 2
+        @lines             = @unit.task.markdown.lines
+        @top_bar_height    = 4
+        @head_height       = 2
 
         initialize_window(@lines.count + @top_bar_height + @head_height)
       end
 
       private
 
-      def set_head(window)
+      def print_head(window)
         window.setpos(0, 1)
         window.clear_line
 
@@ -55,7 +55,7 @@ module Daigaku
       def draw(window)
         @top = 0
         window.attrset(A_NORMAL)
-        set_head(window)
+        print_head(window)
 
         @lines.each_with_index do |line, index|
           window.setpos(index + 2, 1)
@@ -67,24 +67,23 @@ module Daigaku
       end
 
       def scroll_up(window)
-        if @top > 0
-          window.scrl(-1)
-          set_head(window)
+        return unless @top > 0
 
-          @top -= 1
-          line = @lines[@top]
+        window.scrl(-1)
+        print_head(window)
 
-          if line
-            window.setpos(2, 1)
-            print_line(window, line, @top)
-          end
-        end
+        @top -= 1
+        line = @lines[@top]
+
+        return unless line
+        window.setpos(2, 1)
+        print_line(window, line, @top)
       end
 
       def scroll_down(window)
         if @top + Curses.lines <= @lines.count + @top_bar_height + @head_height
           window.scrl(1)
-          set_head(window)
+          print_head(window)
 
           @top += 1
           line = @lines[@top + window.maxy - 1]
@@ -125,47 +124,47 @@ module Daigaku
           scrollable = true
 
           case char
-            when 'v' # verify
-              print_test_results(window)
-              return
-            when 'c' # clear
-              reset_screen(window)
-              return
-            when 'o' # open solution file
-              open_editor(@unit.solution.path)
-            when Curses::KEY_DOWN, Curses::KEY_CTRL_N
-              scrollable = scroll_down(window)
-            when Curses::KEY_UP, Curses::KEY_CTRL_P
-              scrollable = scroll_up(window)
-            when Curses::KEY_NPAGE, ?\s  # white space
-              0.upto(window.maxy - 2) do |n|
-                scrolled = scroll_down(window)
-
-                unless scrolled
-                  scrollable = false if n == 0
-                  break
-                end
-              end
-            when Curses::KEY_PPAGE
-              0.upto(window.maxy - 2) do |n|
-                scrolled = scroll_up(window)
-
-                unless scrolled
-                  scrollable = false if n == 0
-                  break
-                end
-              end
-            when Curses::KEY_LEFT, Curses::KEY_CTRL_T
-              while scroll_up(window)
+          when 'v' # verify
+            print_test_results
+            return
+          when 'c' # clear
+            reset_screen
+            return
+          when 'o' # open solution file
+            open_editor(@unit.solution.path)
+          when Curses::KEY_DOWN, Curses::KEY_CTRL_N
+            scrollable = scroll_down(window)
+          when Curses::KEY_UP, Curses::KEY_CTRL_P
+            scrollable = scroll_up(window)
+          when Curses::KEY_NPAGE, '?\s' # white space
+            0.upto(window.maxy - 2) do |n|
+              scrolled = scroll_down(window)
+
+              unless scrolled
+                scrollable = false if n == 0
+                break
               end
-            when Curses::KEY_RIGHT, Curses::KEY_CTRL_B
-              while scroll_down(window)
+            end
+          when Curses::KEY_PPAGE
+            0.upto(window.maxy - 2) do |n|
+              scrolled = scroll_up(window)
+
+              unless scrolled
+                scrollable = false if n == 0
+                break
               end
-            when Curses::KEY_BACKSPACE
-              broadcast(:reenter, @course, @chapter, @unit)
-              return
-            when 27 # ESC
-              exit
+            end
+          when Curses::KEY_LEFT, Curses::KEY_CTRL_T
+            while scroll_up(window)
+            end
+          when Curses::KEY_RIGHT, Curses::KEY_CTRL_B
+            while scroll_down(window)
+            end
+          when Curses::KEY_BACKSPACE
+            broadcast(:reenter, @course, @chapter, @unit)
+            return
+          when 27 # ESC
+            exit
           end
 
           Curses.beep unless scrollable
@@ -184,16 +183,16 @@ module Daigaku
         end
       end
 
-      def print_test_results(window)
-        result = @unit.solution.verify!
-        @test_result_lines = result.summary_lines
+      def print_test_results
+        result             = @unit.solution.verify!
+        @test_result_lines = test_result_lines(result)
 
         if result.passed?
           code_lines = @unit.reference_solution.code_lines
 
           unless code_lines.empty?
             code_lines.map! { |line| "  #{line}" }
-            code_lines.unshift('', "Reference code:", '')
+            code_lines.unshift('', 'Reference code:', '')
           end
 
           @test_result_lines += code_lines
@@ -202,21 +201,40 @@ module Daigaku
         @lines = [''] + @test_result_lines + ['', ''] + @unit.task.markdown.lines
         @examples = result.examples
 
-        @example_heights = @examples.reduce({}) do |hash, example|
-          start = hash.values.reduce(0) { |sum, r| sum += r.count }
+        @example_heights = @examples.each_with_object({}) do |example, hash|
+          start = hash.values.reduce(0) { |sum, results| sum + results.count }
           range = (start..(start + example.message.split("\n").count) + 2)
           hash[hash.keys.count] = range
-          hash
         end
 
-        height = [@lines.count + @top_bar_height + @head_height, Curses.lines].max
+        lines_count = @lines.count + @top_bar_height + @head_height
+        height      = [lines_count, Curses.lines].max
+
         initialize_window(height)
       end
 
-      def reset_screen(window)
+      def test_result_lines(result)
+        lines  = result.summary_lines
+        lines += code_error_lines(@unit.solution.code) unless result.passed?
+        lines
+      end
+
+      def code_error_lines(code)
+        begin
+          eval(code)
+        rescue StandardError, ScriptError => error
+          return error.inspect.gsub(/(\A.*#<|>.*$)/, '').lines.map(&:rstrip)
+        end
+
+        []
+      end
+
+      def reset_screen
         @test_result_lines = nil
-        @lines = @unit.task.markdown.lines
-        height = [@lines.count + @top_bar_height + @head_height, Curses.lines].max
+        @lines             = @unit.task.markdown.lines
+        lines_count        = @lines.count + @top_bar_height + @head_height
+        height             = [lines_count, Curses.lines].max
+
         initialize_window(height)
       end
 
@@ -228,9 +246,8 @@ module Daigaku
       end
 
       def example_index(heights, index)
-        heights.values.index { |range| range.include?(index) }
+        heights.values.index { |range| range.include?(index) }.to_i
       end
     end
-
   end
 end