belajar 0.1.1

data/lib/belajar/loadable.rb

@@ -0,0 +1,23 @@
+module Belajar
+  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
+          "Belajar::#{class_name}".constantize.new(dir_path)
+        end
+      else
+        Array.new
+      end
+    end
+
+  end
+end

data/lib/belajar/loading/chapters.rb

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

data/lib/belajar/loading/courses.rb

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

data/lib/belajar/loading/units.rb

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

data/lib/belajar/reference_solution.rb

@@ -0,0 +1,18 @@
+module Belajar
+  class ReferenceSolution
+    attr_reader :path
+
+    def initialize(path)
+      @path = Dir[File.join(path, '*solution.rb')].first
+      @code = File.read(@path).strip if @path
+    end
+
+    def code
+      @code.to_s
+    end
+
+    def code_lines
+      code.lines.map(&:chomp)
+    end
+  end
+end

data/lib/belajar/solution.rb

@@ -0,0 +1,53 @@
+module Belajar
+  class Solution
+
+    FILE_SUFFIX = '_solution.rb'
+
+    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_store_state
+    end
+
+    def verify!
+      result = Belajar::Test.new(@unit_path).run(self.code)
+      set_store_state(result.passed?)
+      result
+    end
+
+    def verified?
+      !!@verified
+    end
+
+    def store_key
+      unless @store_key
+        part_path = path.split('/')[-3..-1].join('/').gsub(FILE_SUFFIX, '')
+        @store_key = Storeable.key(part_path, prefix: 'verified')
+      end
+
+      @store_key
+    end
+
+    private
+
+    def solution_path(path)
+      local_path = Belajar.config.solutions_path
+      sub_dirs = Storeable.key(path.split('/')[-3..-2].join('/').gsub(FILE_SUFFIX, ''))
+      file = Storeable.key(File.basename(path)) + FILE_SUFFIX
+
+      File.join(local_path, sub_dirs, file)
+    end
+
+    def set_store_state(verified)
+      @verified = verified
+      QuickStore.store.set(store_key, verified?)
+    end
+
+    def get_store_state
+      QuickStore.store.get(store_key)
+    end
+  end
+end

data/lib/belajar/storeable.rb

@@ -0,0 +1,32 @@
+module Belajar
+  module Storeable
+
+    LEADING_NUMBERS = /^\d+[\_\-\s]+/
+    PART_JOINTS = /[\_\-\s]+/
+
+    class << self
+      def key(text, options = {})
+        separator = QuickStore.config.key_separator
+        prefix = options[:prefix]
+        suffix = clean(options[:suffix])
+        suffixes = options[:suffixes]
+        suffixes_items = suffixes ? suffixes.map { |s| clean(s) }.compact : nil
+
+        [prefix, clean(text), suffix || suffixes_items].compact.join(separator)
+      end
+
+      private
+
+      def clean(text)
+        if text
+          parts = text.to_s.split(QuickStore.config.key_separator).map do |key|
+            key.gsub(LEADING_NUMBERS, '').gsub(PART_JOINTS, '_').downcase
+          end
+
+          parts.join(QuickStore.config.key_separator)
+        end
+      end
+    end
+
+  end
+end

data/lib/belajar/task.rb

@@ -0,0 +1,10 @@
+module Belajar
+  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/belajar/terminal.rb

@@ -0,0 +1,12 @@
+module Belajar
+  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 = File.join(texts_path, "#{file_name.to_s}.txt")
+      (File.exist?(file) ? File.read(file).to_s : '')
+    end
+
+  end
+end

data/lib/belajar/terminal/cli.rb

@@ -0,0 +1,59 @@
+require 'thor'
+
+module Belajar
+  module Terminal
+
+    require_relative 'courses'
+    require_relative 'solutions'
+    require_relative 'setup'
+    require_relative 'output'
+
+    class CLI < Thor
+      include Terminal::Output
+
+      desc 'courses [COMMAND]', 'Handle belajar courses'
+      subcommand 'courses', Terminal::Courses
+
+      desc 'solutions [COMMAND]', 'Handle your solutions'
+      subcommand 'solutions', Terminal::Solutions
+
+      desc 'setup [COMMAND]', 'Change belajar setup'
+      subcommand 'setup', Terminal::Setup
+
+      def self.start
+        Belajar.config.import!
+        super
+      end
+
+      desc 'about', 'About belajar'
+      def about
+        Welcome.about
+      end
+
+      desc 'welcome', 'Setup belajar 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 = Belajar.config.courses_path
+        solutions_path = Belajar.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 belajar to learn Ruby!'
+      def learn
+        courses = Loading::Courses.load(Belajar.config.courses_path)
+        courses.empty? ? Courses.new.list : Belajar.start
+      end
+    end
+
+  end
+end

data/lib/belajar/terminal/courses.rb

@@ -0,0 +1,179 @@
+module Belajar
+  module Terminal
+
+    require 'os'
+    require 'open-uri'
+    require 'zip'
+    require_relative 'output'
+
+    class Courses < Thor
+      include Terminal::Output
+
+      desc 'list', 'List your available belajar courses'
+      def list
+        courses = Loading::Courses.load(Belajar.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 belajar course from [URL]'
+      def download(url = nil, action = 'downloaded')
+        use_initial_course = url.nil? && options[:github].nil?
+        url = GithubClient.master_zip_url(Belajar.config.initial_course) if use_initial_course
+        url = GithubClient.master_zip_url(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 = Belajar.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 = Course.unzip(file_name, github_repo: github)
+
+        if github
+          user_and_repo = url.match(/github.com\/(.*)\/archive\/master.zip/).captures.first
+          store_repo_data(options[:github] || user_and_repo)
+        end
+
+        QuickStore.store.set(course.key(:url), url)
+        QuickStore.store.set(course.key(:updated_at), Time.now.to_s)
+        scaffold_solutions
+
+        say_info "Successfully #{action} the course \"#{course.title}\"!"
+      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
+
+      method_option :all, type: :boolean, aliases: '-a', desc: 'Update all courses'
+      desc 'update [COURSE_NAME] [OPTIONS]', 'Update Daigak courses.'
+      def update(course_name = nil)
+        if options[:all]
+          courses = Loading::Courses.load(Belajar.config.courses_path)
+          courses.each { |course| update_course(course) }
+        elsif course_name
+          path = File.join(Belajar.config.courses_path, course_name)
+
+          unless Dir.exist?(path)
+            print_course_not_available(course_name)
+            return
+          end
+
+          update_course(Course.new(course_name))
+        else
+          system 'belajar course help update'
+        end
+      end
+
+      method_option :all, type: :boolean, aliases: '-a', desc: 'Delete all courses'
+      desc 'delete [COURSE_NAME] [OPTIONS]', 'Delete Belajar courses.'
+      def delete(course_name = nil)
+        if options[:all]
+          get_confirm('Are you shure you want to delete all courses?') do
+            course_dirs = Dir[File.join(Belajar.config.courses_path, '*')]
+
+            course_dirs.each do |dir|
+              FileUtils.remove_dir(dir)
+              QuickStore.store.delete(Storeable.key(File.basename(dir), prefix: 'courses'))
+            end
+
+            say_info "All belajar courses were successfully deleted."
+          end
+        elsif course_name
+          path = File.join(Belajar.config.courses_path, course_name)
+
+          unless Dir.exist?(path)
+            print_course_not_available(course_name)
+            return
+          end
+
+          get_confirm("Are you shure you want to delete the course \"#{course_name}\"?") do
+            FileUtils.remove_dir(path)
+            QuickStore.store.delete(Storeable.key(course_name, prefix: 'courses'))
+            say_info "The course \"#{course_name}\" was successfully deleted."
+          end
+        else
+          system 'belajar courses help delete'
+        end
+      end
+
+      private
+
+      def courses_list_text(courses)
+        if courses.empty?
+          text = Terminal.text :courses_empty
+        else
+          text = [
+            "Available belajar courses:\n",
+            *courses.map { |course| "* #{File.basename(course.path)}\n" }
+          ].join("\n")
+        end
+
+        "#{text}\n#{Terminal.text :hint_course_download}"
+      end
+
+      def store_repo_data(user_and_repo)
+        parts = (user_and_repo ||= Belajar.config.initial_course).split('/')
+        author = parts.first
+        course = parts.second
+
+        course = Course.new(course)
+        QuickStore.store.set(course.key(:author), author)
+        QuickStore.store.set(course.key(:github), user_and_repo)
+      end
+
+      def scaffold_solutions
+        generator = Generator.new
+        generator.prepare
+        generator.scaffold(Belajar.config.courses_path, Belajar.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
+
+      def update_course(course)
+        url = QuickStore.store.get(course.key(:url))
+        github_repo = QuickStore.store.get(course.key(:github))
+        updated = GithubClient.updated?(github_repo)
+
+        if !github_repo || updated
+          download(url, 'updated') if url
+        else
+          say_info "Course \"#{course.title}\" is still up to date."
+        end
+      end
+
+      def print_course_not_available(course_name)
+        text = [
+          "The course \"#{course_name}\" is not available in",
+          "\"#{Belajar.config.courses_path}\".\n",
+        ]
+
+        say_warning text.join("\n")
+
+        unless Loading::Courses.load(Belajar.config.courses_path).empty?
+          Terminal::Courses.new.list
+        end
+      end
+    end
+
+  end
+end

data/lib/belajar/terminal/output.rb

@@ -0,0 +1,78 @@
+require 'thor'
+require 'active_support/concern'
+require 'colorize'
+
+module Belajar
+  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
+
+        def get_confirm(description)
+          say_warning description
+          confirm = get '(yes|no)'
+          yield if confirm == 'yes' && block_given?
+        end
+      end
+    end
+
+  end
+end