mygithug 0.5.1

data/lib/githug/cli.rb

@@ -0,0 +1,121 @@
+require 'thor'
+require 'githug'
+module Githug
+  class CLI < Thor
+
+
+    default_task :play
+
+    desc :play, "Initialize the game"
+
+    def play
+      UI.word_box("Githug")
+      make_directory!
+      Game.new.play_level
+    end
+
+    desc :test, "Test a level from a file path"
+    method_option :errors, :type => :boolean, :default => false
+
+    def test(path)
+      UI.word_box("Githug")
+      make_directory!
+      level = Level.load_from_file(path)
+      Game.new.test_level(level, options[:errors])
+    end
+
+    desc :hint, "Get a hint for the current level"
+
+    def hint
+      if level = load_level
+        level.show_hint
+      end
+    end
+
+    desc :reset, "Reset the current level"
+    long_desc <<-LONGDESC
+      `githug reset` will reset the current level. You can optionally specify a
+      LEVEL parameter which will reset the game to a specific level. For
+      example:
+
+      > $ githug reset merge_squash   # or $ githug reset 47
+
+      Will reset githug to level '#47: merge_squash'
+    LONGDESC
+    def reset(path = nil)
+      level = load_level(path)
+      UI.word_box("Githug")
+      if level
+        UI.puts("resetting level")
+        level.setup_level
+        level.full_description
+      else
+        UI.error("Level does not exist")
+      end
+    end
+
+    desc :levels, "List all of the levels"
+
+    def levels
+      list_with_numbers = Level.list.each_with_index.map do |name, index|
+        "##{index + 1}: #{name}"
+      end
+      UI.puts(list_with_numbers)
+    end
+
+    no_tasks do
+
+      def load_level(path = nil)
+        return load_level_from_profile unless path
+        return load_level_from_number(path.to_i) if path.to_i.to_s == path
+        return load_level_from_name(path) if Level.list.include?(path)
+        Level.load_from_file(path)
+      end
+
+      def load_level_from_number(number)
+        level_name = number >= 1 ? Level.list[number - 1] : nil
+        return load_level_from_name(level_name)
+      end
+
+      def load_level_from_name(name)
+        profile = Profile.load
+        profile.set_level(name)
+        Level.load(name)
+      end
+
+      def load_level_from_profile
+        profile = Profile.load
+        Level.load(profile.level)
+      end
+
+
+      def make_directory!
+        return if File.basename(Dir.pwd) == "git_hug"
+        check_githug_directory!
+        prompt_githug_directory!
+        make_githug_directory!
+      end
+
+      def check_githug_directory!
+        if File.exists?("./git_hug")
+          UI.puts "Please change into the git_hug directory"
+          exit
+        end
+      end
+
+      def prompt_githug_directory!
+        unless UI.ask("No githug directory found, do you wish to create one?")
+          UI.puts("Exiting")
+          exit
+        end
+      end
+
+      def make_githug_directory!
+        Dir.mkdir("./git_hug")
+        Dir.chdir("git_hug")
+      end
+
+    end
+
+  end
+end

data/lib/githug/extensions/grit/ruby1.9.rb

@@ -0,0 +1,21 @@
+class String
+  if self.method_defined?(:ord)
+    def getord(offset); self[offset].ord; end
+  else
+    alias :getord :[]
+  end
+
+  unless self.method_defined?(:b)
+    if self.method_defined?(:force_encoding)
+      def b; self.dup.force_encoding(Encoding::ASCII_8BIT); end
+    else
+      def b; self.dup; end
+    end
+  end
+end
+
+if Object.const_defined?(:PACK_IDX_SIGNATURE)
+  Object.send(:remove_const, :PACK_IDX_SIGNATURE)
+end
+
+PACK_IDX_SIGNATURE = "\377tOc".b

data/lib/githug/game.rb

@@ -0,0 +1,57 @@
+module Githug
+  class Game
+
+    attr_accessor :profile
+
+    def initialize
+      @profile = Profile.load
+    end
+
+    def play_level
+      solve = true
+      if profile.level.nil?
+        UI.puts("Welcome to Githug!")
+        solve = false
+        level_bump
+      else
+        level = Level.load(profile.level)
+        if solve && level
+          if level.solve
+            UI.success "Congratulations, you have solved the level!"
+            level_bump
+          else
+            UI.error "Sorry, this solution is not quite right!"
+            profile.current_attempts += 1
+            profile.save
+
+            if (profile.current_attempts > 2 && profile.current_attempts % 3 == 0)
+              UI.error "Don't forget you can type `githug hint` for a hint and `githug reset` to reset the current level."
+            end
+
+            UI.puts level.full_description
+          end
+        end
+      end
+    end
+
+    def test_level(level, errors = nil)
+      UI.puts level.full_description
+      method = :solve
+      method = :test if errors
+      if level.send(method)
+        UI.success "Valid solution"
+      else
+        UI.error "Invalid solution"
+      end
+    end
+
+    def level_bump
+      profile.level_bump
+      if level = Level.load(profile.level)
+        UI.puts(level.full_description)
+        level.setup_level
+      end
+    end
+
+  end
+end

data/lib/githug/level.rb

@@ -0,0 +1,135 @@
+module Githug
+  class Level
+    include UI
+
+    # LEVELS = [nil, "init", "config", "alias", "alias2", "add", "commit", "clone",
+    #           "clone_to_folder", "ignore", "include", "status",
+    #           "number_of_files_committed", "rm", "rm_cached", "stash", "rename",
+    #           "restructure", "log", "tag", "push_tags", "commit_amend",
+    #           "commit_in_future", "reset", "reset_soft", "checkout_file", "remote",
+    #           "remote_url", "pull", "remote_add", "push", "diff", "blame", "branch",
+    #           "checkout", "checkout_tag", "checkout_tag_over_branch", "branch_at",
+    #           "delete_branch", "push_branch", "merge", "fetch", "rebase", "rebase_onto", "repack", "cherry-pick",
+    #           "grep", "rename_commit", "squash", "merge_squash", "reorder", "bisect",
+    #           "stage_lines", "find_old_branch", "revert", "restore", "conflict",
+    #           "submodule","contribute"]
+
+    LEVELS = [nil, "clone", "alias_st", "alias_lg", "config", "log", 
+      "add", "commit", "ignore", "stash", "unstash",
+       "pull",  "pull_rebase", "conflict", "rebase_conflict", "push_branch",
+       "fetch", "revert", "merge", "cherry-pick",
+      "congratulation"
+    ]
+
+    attr_accessor :level_no, :level_path, :level_name
+
+    class << self
+
+      def load(level_name)
+        path = "#{File.dirname(__FILE__)}/../../levels/#{level_name}.rb"
+        setup(path)
+      end
+
+      def load_from_file(path)
+        setup(path)
+      end
+
+      def list
+        return LEVELS - [nil]
+      end
+
+      def setup(path)
+        level_path = path.chomp(File.extname(path))
+        level = self.new
+
+        return false unless File.exists?(path)
+
+        level.instance_eval(File.read(path))
+        level.level_name = File.basename(path, File.extname(path))
+        level.level_no = LEVELS.index(level.level_name) || 1
+        level.level_path = level_path
+        level
+      end
+
+    end
+
+    def init_from_level
+      FileUtils.cp_r("#{level_path}/.", ".")
+      FileUtils.mv(".githug", ".git")
+    end
+
+    def difficulty(num)
+      @difficulty = num
+    end
+
+    def description(description)
+      @description = description
+    end
+
+    def solution(&block)
+      singleton = class << self; self end
+      singleton.send :define_method, :_solution, &block
+    end
+
+    def setup(&block)
+      @setup = block
+    end
+
+    def hint(&hint)
+      @hint = hint
+    end
+
+    def hints(hints)
+      @hints = hints
+    end
+
+    def full_description
+      UI.puts
+      UI.puts "Name: #{level_name}"
+      UI.puts "Level: #{level_no}"
+      UI.puts "Difficulty: #{"*"*@difficulty}"
+      UI.puts
+      UI.puts @description
+      UI.puts
+    end
+
+    def setup_level
+      repo.reset
+      @setup.call if @setup
+    end
+
+    def repo(location = "")
+      @repo ||= Repository.new(location)
+    end
+
+    def solve
+      _solution
+    rescue
+      false
+    end
+
+    def test
+      _solution
+    end
+
+    def show_hint
+      UI.word_box("Githug")
+      profile = Profile.load
+      current_hint_index = profile.current_hint_index
+      if @hints
+        puts @hints[current_hint_index]
+        if current_hint_index < @hints.size - 1
+          profile.current_hint_index += 1
+          profile.save
+        else
+          profile.current_hint_index = 0
+          profile.save
+        end
+      elsif @hint
+        @hint.call
+      else
+        UI.puts("No hints available for this level.")
+      end
+    end
+  end
+end

data/lib/githug/profile.rb

@@ -0,0 +1,80 @@
+require 'yaml'
+module Githug
+  class Profile
+    PROFILE_FILE = ".profile.yml"
+
+    attr_accessor :settings
+
+    class << self
+      def load
+        self.new(settings)
+      end
+
+      private
+
+      def settings
+        return defaults unless File.exists?(PROFILE_FILE)
+        defaults.merge(YAML::load(File.open(PROFILE_FILE)))
+      end
+
+      def defaults
+        {
+          :level => nil,
+          :current_attempts => 0,
+          :current_hint_index => 0,
+          :current_levels => [],
+          :completed_levels => []
+        }
+      end
+
+    end
+
+
+    def method_missing(method, *args, &block)
+      if method.to_s.end_with?("=")
+        method = method.to_s.chop.to_sym
+        return settings[method] = args[0] if settings.include?(method)
+      end
+      return(settings[method]) if settings.include?(method)
+      super
+    end
+
+    def initialize(settings)
+      @settings = settings
+    end
+
+    def save
+      File.open(PROFILE_FILE, 'w') do |out|
+        YAML.dump(settings, out)
+      end
+    end
+
+    def set_level(name)
+      settings[:level] = name
+      reset!
+      save
+    end
+
+    def level_bump
+      settings[:completed_levels] << level
+      settings[:current_levels] = levels
+      set_level(next_level)
+    end
+
+    private
+
+    def levels
+      Level::LEVELS
+    end
+
+    def next_level
+      (levels - settings[:completed_levels]).first || levels.last
+    end
+
+    def reset!
+      settings[:current_attempts] = 0
+      settings[:current_hint_index] = 0
+    end
+
+  end
+end

data/lib/githug/repository.rb

@@ -0,0 +1,48 @@
+module Githug
+  class Repository
+
+    attr_accessor :grit
+
+    def initialize(location = ".")
+      @grit = Grit::Repo.new(location)
+    rescue Grit::InvalidGitRepositoryError
+      @grit = nil
+    end
+
+    def reset
+      dont_delete = ["..", ".", ".profile.yml"]
+      if File.basename(Dir.pwd) == "git_hug"
+        Dir.entries(Dir.pwd).each do |file|
+          FileUtils.rm_rf(file) unless dont_delete.include?(file)
+        end
+      end
+      create_gitignore
+    end
+
+    def create_gitignore
+      Dir.chdir("git_hug") if File.exists?("./git_hug")
+      File.open(".gitignore", "w") do |file|
+        file.puts(".profile.yml")
+        file.puts(".gitignore")
+      end
+    end
+
+    def valid?
+      !@grit.nil?
+    end
+
+    # Initialize a Git repo. If the repo already exists, do nothing.
+    def init(location = ".")
+      @grit = Grit::Repo.init(location)
+    end
+
+    def method_missing(method, *args, &block)
+      if @grit && @grit.respond_to?(method)
+        return @grit.send(method, *args, &block)
+      end
+      super
+    end
+
+
+  end
+end

data/lib/githug/ui.rb

@@ -0,0 +1,59 @@
+module Githug
+  module UI
+
+    class << self
+
+      attr_accessor :out_stream, :in_stream
+
+      @out_stream = STDOUT
+      @in_stream = STDIN
+
+      def puts(string = "")
+        out_stream.puts(string)
+      end
+
+      def print(string)
+        out_stream.print(string)
+      end
+
+      def gets
+        in_stream.gets
+      end
+
+      def word_box(string,width=80,char='*')
+        puts char*width
+        puts "#{char}#{string.center(width-2)}#{char}"
+        puts char*width
+      end
+
+      def request(msg)
+        print("#{msg} ")
+        gets.chomp
+      end
+
+      def ask(msg)
+        request("#{msg} [yn] ") == 'y'
+      end
+
+      def colorize(text, color_code)
+        return puts text if ENV['OS'] && ENV['OS'].downcase.include?("windows")
+        puts "#{color_code}#{text}\033[0m"
+      end
+
+      def error(text)
+        colorize(text, "\033[31m")
+      end
+
+      def success(text)
+        colorize(text, "\033[32m")
+      end
+
+    end
+
+    def method_missing(method, *args, &block)
+      return UI.send(method, *args) if UI.methods(false).include?(method.to_s) || UI.methods(false).include?(method)
+      super
+    end
+
+  end
+end

data/lib/githug/version.rb

@@ -0,0 +1,3 @@
+module Githug
+  VERSION = "0.5.1"
+end

data/lib/githug.rb

@@ -0,0 +1,16 @@
+require 'grit'
+
+require "githug/extensions/grit/ruby1.9"
+
+
+require "githug/version"
+
+require 'githug/ui'
+require 'githug/game'
+require 'githug/profile'
+require 'githug/level'
+require 'githug/repository'
+
+Githug::UI.in_stream = STDIN
+Githug::UI.out_stream = STDOUT
+STDIN.sync = true

data/mygithug.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "githug/version"
+
+Gem::Specification.new do |s|
+  s.name        = "mygithug"
+  s.version     = Githug::VERSION
+  s.authors     = ["Gary Rennie & Mei Xuesong"]
+  s.email       = ["meixuesong@gmail.com"]
+  s.homepage    = "https://github.com/meixuesong/githug"
+  s.summary     = %q{An interactive way to learn git in your workplace.}
+  s.description = %q{An interactive way to learn git.}
+
+  s.rubyforge_project = "mygithug"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec", "~>2.8.0"
+
+  s.add_dependency "grit", "~>2.3.0"
+  s.add_dependency "thor", "~>0.14.6"
+  s.add_dependency "rake", "<11"
+end

data/spec/githug/cli_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+require 'githug/cli'
+
+describe Githug::CLI do
+
+  before(:each) do
+    game = mock.as_null_object
+    Githug::Game.stub(:new).and_return(game)
+  end
+
+  it "prints the logo" do
+    Githug::UI.should_receive(:word_box).with("Githug")
+    subject.stub(:make_directory!)
+    subject.play
+  end
+
+  it "creates a directory if one does not exist" do
+    Githug::UI.stub(:ask).and_return(true)
+    Dir.should_receive(:mkdir).with("./git_hug")
+    Dir.should_receive(:chdir).with("git_hug")
+    subject.make_directory!
+  end
+
+  it "does not create a directory if you are in the game directory" do
+    Dir.stub(:pwd).and_return("/home/git_hug")
+    Githug::UI.should_not_receive(:ask)
+    subject.make_directory!
+  end
+
+  it "exits if the user selects no" do
+    Githug::UI.stub(:ask).and_return(false)
+    lambda {subject.prompt_githug_directory!}.should raise_error(SystemExit)
+  end
+
+  it "prompts to change into the directory if it exists" do
+    File.stub(:exists?).and_return(true)
+    Githug::UI.should_receive(:puts).with("Please change into the git_hug directory")
+    lambda {subject.check_githug_directory!}.should raise_error(SystemExit)
+  end
+
+  describe "#test" do
+    it "performs a test run of the level" do
+      level = mock
+      game = mock
+      subject.stub(:make_directory!)
+      Githug::Level.should_receive(:load_from_file).with("/foo/bar/test/level.rb").and_return(level)
+      Githug::Game.stub(:new).and_return(game)
+      game.should_receive(:test_level).with(level, anything)
+      subject.test("/foo/bar/test/level.rb")
+    end
+  end
+
+  describe "level methods" do
+
+    let(:level) { mock }
+    let(:profile) { mock }
+
+    before(:each) do
+      profile.stub(:level).and_return(1)
+      Githug::Profile.stub(:load).and_return(profile)
+      Githug::Level.stub(:load).and_return(level)
+      Githug::Level.stub(:load_from_file).with("/foo/bar/level.rb").and_return(level)
+    end
+
+    it "calls the hint method on the level" do
+      level.should_receive(:show_hint)
+      subject.hint
+    end
+
+    describe "#reset" do
+
+
+      it "resets the current level" do
+        level.should_receive(:setup_level)
+        level.should_receive(:full_description)
+        Githug::UI.should_receive(:word_box).with("Githug")
+        Githug::UI.should_receive(:puts).with("resetting level")
+        subject.reset
+      end
+
+      it "does not reset if the level cannot be loaded" do
+        Githug::Level.stub(:load).and_return(false)
+        level.should_not_receive(:setup_level)
+        level.should_not_receive(:full_description)
+        Githug::UI.should_receive(:error).with("Level does not exist")
+        subject.reset
+      end
+
+      it "resets the level with a level name" do
+        level.should_receive(:setup_level)
+        level.should_receive(:full_description)
+        profile = mock
+        Githug::Profile.stub(:load).and_return(profile)
+        profile.should_receive(:set_level).with("add")
+        Githug::Level.should_receive(:load).with("add").and_return(level)
+        Githug::UI.should_receive(:word_box).with("Githug")
+        Githug::UI.should_receive(:puts).with("resetting level")
+        subject.reset("add")
+      end
+
+      it "resets the level with a level number" do
+        level.should_receive(:setup_level)
+        level.should_receive(:full_description)
+        profile = mock
+        Githug::Profile.stub(:load).and_return(profile)
+        profile.should_receive(:set_level).with("rename_commit")
+        Githug::Level.should_receive(:load).with("rename_commit").and_return(level)
+        Githug::UI.should_receive(:word_box).with("Githug")
+        Githug::UI.should_receive(:puts).with("resetting level")
+        subject.reset("45")
+      end
+
+      it "resets the level with a path" do
+        level.should_receive(:setup_level)
+        level.should_receive(:full_description)
+        Githug::UI.should_receive(:word_box).with("Githug")
+        Githug::UI.should_receive(:puts).with("resetting level")
+        subject.reset("/foo/bar/level.rb")
+      end
+    end
+
+  end
+
+  describe "#levels" do
+
+    it "prints the levels and their numbers" do
+      Githug::Level.stub(:list).and_return(["commit", "add"])
+      Githug::UI.should_receive(:puts).with(["#1: commit", "#2: add"])
+      subject.levels
+    end
+  end
+
+end