daigaku 0.0.1

data/lib/daigaku/loadable.rb

@@ -0,0 +1,23 @@
+module Daigaku
+  module Loadable
+
+    require 'active_support/inflector'
+
+    def load(path)
+      if Dir.exist?(path)
+        dirs = Dir.entries(path).select do |entry|
+          !entry.match(/\./)
+        end
+
+        dirs.sort.map do |dir|
+          dir_path = File.join(path, dir)
+          class_name = self.to_s.demodulize.singularize
+          "Daigaku::#{class_name}".constantize.new(dir_path)
+        end
+      else
+        Array.new
+      end
+    end
+
+  end
+end

data/lib/daigaku/loading/chapters.rb

@@ -0,0 +1,9 @@
+module Daigaku
+  module Loading
+
+    class Chapters
+      extend Daigaku::Loadable
+    end
+
+  end
+end

data/lib/daigaku/loading/courses.rb

@@ -0,0 +1,9 @@
+module Daigaku
+  module Loading
+
+    class Courses
+      extend Daigaku::Loadable
+    end
+
+  end
+end

data/lib/daigaku/loading/units.rb

@@ -0,0 +1,9 @@
+module Daigaku
+  module Loading
+
+    class Units
+      extend Daigaku::Loadable
+    end
+
+  end
+end

data/lib/daigaku/reference_solution.rb

@@ -0,0 +1,10 @@
+module Daigaku
+  class ReferenceSolution
+    attr_reader :code, :path
+
+    def initialize(path)
+      @path = Dir[File.join(path, '*solution.rb')].first
+      @code = File.read(@path).strip if @path
+    end
+  end
+end

data/lib/daigaku/solution.rb

@@ -0,0 +1,42 @@
+module Daigaku
+  class Solution
+
+    attr_reader :code, :path, :errors
+
+    def initialize(unit_path)
+      @unit_path = unit_path
+      @path = solution_path(unit_path)
+      @code = File.read(@path).strip if File.file?(@path)
+      @verified = get_database_state
+    end
+
+    def verify!
+      result = Daigaku::Test.new(@unit_path).run(self.code)
+      set_database_state(result.passed?)
+      result
+    end
+
+    def verified?
+      !!@verified
+    end
+
+    private
+
+    def solution_path(path)
+      local_path = Daigaku.config.solutions_path
+      sub_dirs = path.split('/')[-3..-2]
+      file = File.basename(path).gsub(/(\_+|\-+|\.+)/, '_') + '_solution.rb'
+
+      File.join(local_path, sub_dirs, file)
+    end
+
+    def set_database_state(verified)
+      @verified = verified
+      Daigaku.database.set(@path, verified?)
+    end
+
+    def get_database_state
+      Daigaku.database.get(@path)
+    end
+  end
+end

data/lib/daigaku/task.rb

@@ -0,0 +1,10 @@
+module Daigaku
+  class Task
+    attr_reader :markdown, :path
+
+    def initialize(path)
+      @path = Dir[File.join(path, '*.md')].first
+      @markdown = File.read(@path).strip
+    end
+  end
+end

data/lib/daigaku/terminal.rb

@@ -0,0 +1,11 @@
+module Daigaku
+  module Terminal
+
+    # text should be of a width of 70 columns or less
+    def self.text(file_name)
+      texts_path = File.expand_path('../terminal/texts', __FILE__)
+      File.read(File.join(texts_path, "#{file_name.to_s}.txt"))
+    end
+
+  end
+end

data/lib/daigaku/terminal/cli.rb

@@ -0,0 +1,59 @@
+require 'thor'
+
+module Daigaku
+  module Terminal
+
+    require_relative 'courses'
+    require_relative 'solutions'
+    require_relative 'setup'
+    require_relative 'output'
+
+    class CLI < Thor
+      include Terminal::Output
+
+      desc 'courses [COMMAND]', 'Handle daigaku courses'
+      subcommand 'courses', Terminal::Courses
+
+      desc 'solutions [COMMAND]', 'Handle your solutions'
+      subcommand 'solutions', Terminal::Solutions
+
+      desc 'setup [COMMAND]', 'Change daigaku setup'
+      subcommand 'setup', Terminal::Setup
+
+      def self.start
+        Daigaku.config.import!
+        super
+      end
+
+      desc 'about', 'About daigaku'
+      def about
+        Welcome.about
+      end
+
+      desc 'welcome', 'Setup daigaku the first time and learn some important commands.'
+      def welcome
+        Welcome.run
+      end
+
+      desc 'scaffold', 'Scaffold solution files for your courses.'
+      def scaffold
+        generator = Generator.new
+        generator.prepare
+
+        courses_path = Daigaku.config.courses_path
+        solutions_path = Daigaku.config.solutions_path
+
+        generator.scaffold(courses_path, solutions_path)
+
+        say_info "You will find your solution files in\n#{solutions_path}."
+      end
+
+      desc 'learn', 'Go to daigaku to learn Ruby!'
+      def learn
+        courses = Loading::Courses.load(Daigaku.config.courses_path)
+        courses.empty? ? Courses.new.list : Daigaku.start
+      end
+    end
+
+  end
+end

data/lib/daigaku/terminal/courses.rb

@@ -0,0 +1,114 @@
+module Daigaku
+  module Terminal
+
+    require 'os'
+    require 'open-uri'
+    require 'zip'
+    require_relative 'output'
+
+    class Courses < Thor
+      include Terminal::Output
+
+      desc 'list', 'List your available daigaku courses'
+      def list
+        courses = Loading::Courses.load(Daigaku.config.courses_path)
+        say_info courses_list_text(courses)
+      end
+
+      method_option :github,
+                    type: :string,
+                    aliases: '-g',
+                    desc: 'Download Github repository'
+      desc 'download [URL] [OPTIONS]', 'Download a new daigaku course from [URL]'
+      def download(url = nil)
+        use_initial_course = url.nil? && options[:github].nil?
+        url = github_repo(Daigaku.config.initial_course) if use_initial_course
+        url = github_repo(options[:github]) if options[:github]
+
+        url_given = (url =~ /\A#{URI::regexp(['http', 'https'])}\z/)
+        github = use_initial_course || options[:github] || url.match(/github\.com/)
+
+        raise Download::NoUrlError unless url_given
+        raise Download::NoZipFileUrlError unless File.basename(url) =~ /\.zip/
+
+        courses_path = Daigaku.config.courses_path
+        FileUtils.makedirs(courses_path) unless Dir.exist?(courses_path)
+
+        file_name = File.join(courses_path, url.split('/').last)
+
+        File.open(file_name, 'w') { |file| file << open(url).read }
+        course_name = unzip(file_name, github)
+        scaffold_solutions
+
+        say_info "Successfully downloaded the course \"#{course_name}\"!"
+      rescue Download::NoUrlError => e
+        print_download_warning(url, "\"#{url}\" is not a valid URL!")
+      rescue Download::NoZipFileUrlError => e
+        print_download_warning(url, "\"#{url}\" is not a URL of a *.zip file!")
+      rescue Exception => e
+        print_download_warning(url, e.message)
+      ensure
+        FileUtils.rm(file_name) if File.exist?(file_name.to_s)
+      end
+
+      private
+
+      def courses_list_text(courses)
+        if courses.empty?
+          text = Terminal.text :courses_empty
+        else
+          text = [
+            "Available daigaku courses:\n",
+            *courses.map { |course| "* #{File.basename(course.path)}\n" }
+          ].join("\n")
+        end
+
+        "#{text}\n#{Terminal.text :hint_course_download}"
+      end
+
+      def github_repo(user_and_repo)
+        "https://github.com/#{user_and_repo}/archive/master.zip"
+      end
+
+      def unzip(file_path, github = false)
+        target_dir = File.dirname(file_path)
+        course_name = nil
+
+        Zip::File.open(file_path) do |zip_file|
+          zip_file.each do |entry|
+
+            if github
+              first, *others = entry.to_s.split('/')
+              directory = File.join(first.split('-')[0..-2].join('-'), others)
+            else
+              directory = entry.to_s
+            end
+
+            course_name ||= directory.split('/').first.gsub(/_+/, ' ')
+            zip_file.extract(entry, "#{target_dir}/#{directory}") { true }
+          end
+        end
+
+        FileUtils.rm(file_path)
+        course_name
+      end
+
+      def scaffold_solutions
+        generator = Generator.new
+        generator.prepare
+        generator.scaffold(Daigaku.config.courses_path, Daigaku.config.solutions_path)
+      end
+
+      def print_download_warning(url, text)
+        message = [
+          "Error while downloading course from URL \"#{url}\"",
+          "#{text}\n",
+          Terminal.text(:hint_course_download)
+        ].join("\n")
+
+        say_warning message
+      end
+    end
+
+  end
+end

data/lib/daigaku/terminal/output.rb

@@ -0,0 +1,72 @@
+require 'thor'
+require 'active_support/concern'
+require 'colorize'
+
+module Daigaku
+  module Terminal
+
+    module Output
+      extend ActiveSupport::Concern
+
+      included do
+        private
+
+        def say(text)
+          output = text.split("\n").map {|line| "\t#{line}" }.join("\n")
+          $stdout.puts output
+        end
+
+        def empty_line
+          $stdout.puts ''
+        end
+
+        def get(string)
+          $stdout.print "\n\t#{string} "
+          $stdin.gets.strip
+        end
+
+        def say_info(text)
+          say_box(text, ' ℹ', :light_blue)
+        end
+
+        def say_warning(text)
+          say_box(text, '⚠ ', :light_red)
+        end
+
+        def say_box(text, symbol, color)
+          empty_line
+          say line.send(color)
+          empty_line
+
+          indented_text = text.split("\n").join("\n#{' ' * (symbol.length + 1)}")
+          say indented_text.prepend("#{symbol} ").send(color)
+
+          empty_line
+          say line.send(color)
+          empty_line
+        end
+
+        def line(symbol = '-')
+          symbol * 70
+        end
+
+        def get_command(command, description)
+          say description
+
+          loop do
+            cmd = get '>'
+
+            unless cmd == command
+              say "This was something else. Try \"#{command}\"."
+              next
+            end
+
+            system cmd
+            break
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/daigaku/terminal/setup.rb

@@ -0,0 +1,115 @@
+require 'thor'
+
+module Daigaku
+  module Terminal
+
+    require_relative 'output'
+
+    class Setup < Thor
+      include Terminal::Output
+
+      desc 'init', 'Initially setup daigaku paths'
+      def init
+        empty_line
+        say 'Please type the base path in which you want to save your daigaku'
+        say 'files. The "courses" folder and "solutions" folder will be created'
+        say 'automatically.'
+
+        loop do
+          path = get 'path:'
+
+          begin
+            @daigaku_path = File.expand_path("#{path}", Dir.pwd)
+          rescue
+            say_warning "#{path} is no valid path name. Try another!"
+            next
+          end
+
+          say_warning 'Do you want to use the following path as your daigaku base path?'
+          say "\"#{@daigaku_path}\""
+
+          confirmation = get '(yes|no)'
+          break if confirmation.downcase == 'yes'
+
+          empty_line
+          say 'No Problem. Just type another one!'
+        end
+
+        prepare_directories(@daigaku_path)
+      end
+
+      desc 'list', 'List the current daigaku setup'
+      def list
+        say_info "Your current daigaku setup is:\n\n#{Daigaku.config.summary}"
+      end
+
+      desc 'set [OPTIONS]', 'Update the settings of your daigaku environment'
+      method_option :courses_path,
+                    type: :string,
+                    aliases: '-c',
+                    desc: 'Set courses_path directory'
+      method_option :solutions_path,
+                    type: :string,
+                    aliases: '-s',
+                    desc: 'Set solutions_path directory'
+      method_option :paths,
+                    type: :string,
+                    aliases: '-p',
+                    desc: 'Set all daigaku paths to a certain path'
+      def set
+        courses_path = options[:paths] || options[:courses_path]
+        solutions_path = options[:paths] || options[:solutions_path]
+
+        if courses_path.nil? && solutions_path.nil?
+          say_warning "Please specify options when using this command!"
+          say %x{ daigaku setup help set }
+          return
+        end
+
+        update_config(:courses_path, courses_path) if courses_path
+        update_config(:solutions_path, solutions_path) if solutions_path
+
+        Daigaku.config.save
+        list
+      end
+
+      private
+
+      def prepare_directories(path)
+        courses_dir = Daigaku::Configuration::COURSES_DIR
+        courses_path = File.join(path, courses_dir)
+        Daigaku.config.courses_path = courses_path
+
+        solutions_dir = Daigaku::Configuration::SOLUTIONS_DIR
+        solutions_path = File.join(path, solutions_dir)
+
+        if Dir.exist? solutions_path
+          Daigaku.config.solutions_path = solutions_path
+        end
+
+        generator = Daigaku::Generator.new
+        generator.prepare
+
+        text = [
+          "Your Daigaku directory is now set up.\n",
+          "Daigaku created/updated following two paths for you:",
+          courses_path,
+          solutions_path
+        ]
+
+        say_info text.join("\n")
+      end
+
+      def update_config(attribute, value)
+        begin
+          path = File.expand_path(value, Dir.pwd)
+          Daigaku.config.send("#{attribute}=", path)
+        rescue Exception => e
+          say_warning e.message
+        end
+      end
+
+    end
+
+  end
+end