cic-tools 0.0.1.alpha1

data/lib/commands/track.rb

@@ -0,0 +1,3 @@
+require_relative 'track/command'
+require_relative 'track/exercise'
+require_relative 'track/learning_track'

data/lib/commands/track/command.rb

@@ -0,0 +1,68 @@
+require 'octokit'
+require 'netrc'
+require 'yaml'
+require 'uri'
+require_relative 'errors'
+require_relative 'helpers'
+
+module Commands
+  module Track
+    class Command < Thor
+      attr_reader :tracks, :tracks_yaml, :api_endpoint
+
+      def initialize(args = [],
+                     options = {},
+                     config = {},
+                     api_endpoint = Octokit::Default::API_ENDPOINT,
+                     tracks_yaml = "#{__dir__}/../../../../../../tracks/tracks.yml")
+        super(args, options, config)
+
+        @tracks_yaml = tracks_yaml
+
+        @api_endpoint = api_endpoint
+        raise TracksFileNotFoundError.new(path: tracks_yaml) unless File.exist?(tracks_yaml)
+
+        @tracks = load_tracks(YAML.safe_load(File.read(tracks_yaml))['tracks'])
+      end
+
+      desc 'list', 'get a list of available learning tracks'
+
+      def list
+        Dir.chdir(tracks_dir) do
+          track_names = tracks.keys
+          say "Available Tracks:\n #{track_names.join("\n")}"
+        end
+      end
+
+      desc 'start TRACK_NAME', 'start a track'
+      option :fork, desc: 'the account/repo of your fork'
+      def start(track_name)
+        Dir.chdir(tracks_dir) do
+          setup!(track_name)
+
+          project = create_project("Learn #{track_name}")
+
+          columns = create_columns(project.id, %w[TODO in-progress done])
+
+          create_exercises(columns['TODO'], track_name)
+
+          say ok "Project '#{project.name}' created: #{project.html_url}"
+        end
+      rescue StandardError => e
+        raise error_for(e)
+      end
+
+      no_commands do
+        include Helpers
+        include Commandline::Output
+
+        def error_for(error)
+          mapped_errors = { Octokit::Unauthorized => CredentialsError,
+                            Octokit::InvalidRepository => InvalidForkFormatError }
+
+          mapped_errors[error.class] || error
+        end
+      end
+    end
+  end
+end

data/lib/commands/track/errors.rb

@@ -0,0 +1,57 @@
+module Commands
+  module Track
+    class NetrcMissingError < Thor::Error
+      def initialize
+        super '.netrc file missing. Add a .netrc file to your home folder with your github credentials in it'
+      end
+    end
+
+    class InvalidForkFormatError < Thor::Error
+      def initialize
+        super 'Fork option container invalid characters. Check you have typed it correctly.'
+      end
+    end
+
+    class MissingCredentialsError < Thor::Error
+      def initialize(host)
+        super ".netrc does not container credentials for #{host}"
+      end
+
+      def ==(other)
+        to_s == other.to_s
+      end
+    end
+
+    class CredentialsError < Thor::Error
+      def initialize
+        super "Authorisation failed. Check the fork you're targeting and the credentials in your .netrc"
+      end
+    end
+
+    class RepoIsNotForkError < Thor::Error
+      def initialize(fork)
+        super "#{fork} is not a fork. Please for the CIC repo and try again"
+      end
+
+      def ==(other)
+        to_s == other.to_s
+      end
+    end
+
+    class TrackNotFoundError < Thor::Error
+      def initialize(track_name:, track_names:)
+        super "Track #{track_name} not found.\nPlease choose from:#{track_names.join("\n")}"
+      end
+
+      def ==(other)
+        to_s == other.to_s
+      end
+    end
+
+    class TracksFileNotFoundError < Thor::Error
+      def initialize(path:)
+        super "Tracks file not found at: #{path}"
+      end
+    end
+  end
+end

data/lib/commands/track/exercise.rb

@@ -0,0 +1,52 @@
+module Commands
+  module Track
+    class Exercise
+      attr_reader :track, :name, :path
+
+      def initialize(track:, name:, path:)
+        @track = track
+        @name = name
+        @path = path
+      end
+
+      def detail
+        "#{preamble}[Click here](../tree/master/#{path}) to read the #{name} exercise"
+      end
+
+      def validate
+        raise ArgumentError, name_error_msg unless name
+        raise ArgumentError, path_error_msg unless File.exist?(path)
+
+        true
+      end
+
+      def ==(other)
+        name == other.name && path == other.path
+      end
+
+      def path_error_msg
+        "Exercise: #{name} - not found at path: #{path}"
+      end
+
+      def name_error_msg
+        'Name not given for exercise'
+      end
+
+      private
+
+      def preamble
+        return '' unless File.exist?(preamble_path)
+
+        "#{File.read(preamble_path)}\n"
+      end
+
+      def preamble_path
+        "#{track}/#{to_snake_case(name)}.md"
+      end
+
+      def to_snake_case(string)
+        string.downcase.gsub(/\s+/, '_')
+      end
+    end
+  end
+end

data/lib/commands/track/helpers.rb

@@ -0,0 +1,101 @@
+module Commands
+  module Track
+    module Helpers
+      private
+
+      def build_track(track)
+        LearningTrack.new(track['name']).tap do |learning_track|
+          track['exercises'].each do |exercise|
+            name, path = exercise.flatten.to_a
+            learning_track.exercise(name: name, path: path)
+          end
+
+          learning_track.validate
+        end
+      end
+
+      def create_columns(project_id, names)
+        {}.tap do |columns|
+          names.each do |name|
+            columns[name] = create_column(project_id, name)
+          end
+        end
+      end
+
+      def create_column(project_id, name)
+        github_client.create_project_column(project_id, name, default_projects_options)
+      end
+
+      def create_exercises(todo_column, track_name)
+        exercises(track_name).each do |exercise|
+          issue = github_client.create_issue(fork, exercise.name, exercise.detail, labels: '')
+
+          options = default_projects_options.merge(content_id: issue.id, content_type: 'Issue')
+          github_client.create_project_card(todo_column.id, options)
+        end
+      end
+
+      def create_project(board_name)
+        github_client.create_project(fork, board_name, default_projects_options)
+      end
+
+      def default_projects_options
+        { accept: 'application/vnd.github.inertia-preview+json' }
+      end
+
+      def enable_issues
+        github_client.edit_repository(fork, has_issues: true)
+      end
+
+      def exercises(track_name)
+        tracks[track_name].exercises.reverse
+      end
+
+      def fork
+        options[:fork]
+      end
+
+      def github_client
+        @github_client ||= begin
+          options = { netrc: true, api_endpoint: api_endpoint }
+          Octokit::Client.new(options).tap do |client|
+            raise NetrcMissingError unless File.exist?(client.netrc_file)
+
+            host = URI(client.api_endpoint).host
+            raise MissingCredentialsError, host unless Netrc.read(client.netrc_file)[host]
+          end
+        end
+      end
+
+      def load_tracks(hash)
+        {}.tap do |tracks|
+          hash.each do |track|
+            tracks[build_track(track).name] = build_track(track)
+          end
+        end
+      end
+
+      def track_exists?(track_name)
+        tracks.key?(track_name)
+      end
+
+      def track_names
+        tracks.keys
+      end
+
+      def tracks_dir
+        File.dirname(File.expand_path(tracks_yaml))
+      end
+
+      def setup!(track_name)
+        raise TrackNotFoundError.new(track_name: track_name, track_names: track_names) unless track_exists?(track_name)
+
+        repo = github_client.repo(fork)
+
+        raise RepoIsNotForkError, fork unless repo['fork'] == true
+
+        enable_issues
+      end
+    end
+  end
+end

data/lib/commands/track/learning_track.rb

@@ -0,0 +1,23 @@
+module Commands
+  module Track
+    class LearningTrack
+      attr_reader :name, :exercises
+      def initialize(name)
+        @name = name
+        @exercises = []
+      end
+
+      def exercise(name:, path:)
+        exercises << Exercise.new(track: self.name, name: name, path: path)
+      end
+
+      def validate
+        exercises.each(&:validate)
+      end
+
+      def ==(other)
+        name == other.name && exercises == other.exercises
+      end
+    end
+  end
+end

data/lib/utils/commandline.rb

@@ -0,0 +1,53 @@
+require 'colorize'
+require 'open3'
+require 'io/wait'
+require_relative 'commandline/return'
+require_relative 'commandline/output'
+
+module Commandline
+  def capture_output(io, silent: true)
+    StringIO.new.tap do |store|
+      Thread.new do
+        while (line = io.getc)
+          store.write(line.dup)
+          print line unless silent || ENV['SILENT']
+        end
+      end
+    end
+  end
+
+  def run(command, dir: nil, silent: true)
+    options = {}
+    options[:chdir] = dir if dir
+    stdin, stdout, stderr, thread = Open3.popen3("bash -lc '#{command}'", options)
+    stderr_output = capture_output(stderr, silent: silent)
+    stdout_output = capture_output(stdout, silent: silent)
+
+    wait_for_thread(thread)
+
+    [stdin, stdout, stderr].each(&:close)
+
+    Return.new(stdout: stdout_output.string, stderr: stderr_output.string, exit_code: thread.value.exitstatus)
+  end
+
+  # TODO: - think about how to bring the run and execute methods together or give more differentiating names
+  def execute(*commands, fail_message:, pass_message:)
+    fail = false
+    commands.each do |command|
+      result = run command
+      say result.stdout
+      next unless result.error?
+
+      fail = true
+      say result.stderr
+      say error fail_message
+    end
+    say ok pass_message unless fail
+  end
+
+  private
+
+  def wait_for_thread(thread)
+    sleep 1 while thread.alive?
+  end
+end

data/lib/utils/commandline/output.rb

@@ -0,0 +1,31 @@
+module Commandline
+  module Output
+    def output
+      @output ||= STDOUT
+    end
+
+    def say(msg)
+      output.puts msg unless ENV['SILENT']
+    end
+
+    def ok(text)
+      prefix(text, '[OK] ').green
+    end
+
+    def error(text)
+      prefix(text, '[ERROR] ').red
+    end
+
+    def prefix(text, prefix)
+      lines = text.lines
+      message = "#{prefix}#{lines[0].strip}\n"
+      lines[1..-1].each_with_index do |line, index|
+        line = line.strip.chomp
+        line = line.rjust(line.length + prefix.size)
+
+        message << (index.zero? ? line : line.prepend("\n"))
+      end
+      message
+    end
+  end
+end

data/lib/utils/commandline/return.rb

@@ -0,0 +1,37 @@
+module Commandline
+  class Return
+    attr_reader :stdout, :stderr, :exit_code
+
+    def initialize(stdout:, stderr:, exit_code:)
+      @stdout = normalise(stdout)
+      @stderr = normalise(stderr)
+      @exit_code = exit_code
+    end
+
+    def error?
+      exit_code != 0
+    end
+
+    def to_s
+      <<~OUTPUT
+        EXIT CODE: #{exit_code}
+
+        STDOUT:
+        #{stdout}
+
+        STDERR:
+        #{stderr}
+      OUTPUT
+    end
+
+    def ==(other)
+      other.to_s == to_s
+    end
+
+    private
+
+    def normalise(string)
+      string.chomp.strip
+    end
+  end
+end

data/lib/utils/docker.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'commandline'
+require 'json'
+module Docker
+  class Error < StandardError
+    include Commandline::Output
+    def initialize(msg)
+      super error(msg)
+    end
+  end
+
+  include Commandline
+
+  def container_id(container_name)
+    id = docker(%(container ps -q --filter "name=#{container_name}")).stdout
+    id.empty? ? raise(Error, "container with name #{container_name} does not exist") : id
+  end
+
+  def docker_exec(command)
+    system "docker exec #{command}"
+  end
+
+  def docker(command)
+    command = "docker #{command}"
+    run(command).tap do |output|
+      raise(Error, "Failed to run: #{command}\n#{output}") if output.error?
+    end
+  end
+end