twit 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 85fc88fe59a3282afb1f4e29af583408a35a3f29
-  data.tar.gz: a30902725f73eeeb3ca2b84666ef23908292e265
+  metadata.gz: 987a48bc9202726f4c82223a921b870ff5e17b9a
+  data.tar.gz: 4c8e445811d5ad416ceaa6f8f934cb0657a531d1
 SHA512:
-  metadata.gz: e82495bbc0018af33c6f33ae5ea9e14ebedd0a35c95ee6435fd6a0d0c227162dd76ebf93e70ab3f76687c481fd91d9979edf8024e50121da5c9da098b1d41812
-  data.tar.gz: 4a295fe77e361dd9769a72fe10494c50d9be7dcc4c6a854a5c2bfbf944ab59a6075e8d9e1e5229eb22ee8b33efab87a5e7e6c38034b1f7b4fdcd670b89a4ab51
+  metadata.gz: eeda8ecd67d2080b1a96b3887b47065016f80bc537f21ee3660d6feddc1490198eff2369920a139d7daf1e98ba1428ca9974803ed39363809e74509ab0761eb0
+  data.tar.gz: c4913cd65bd75856cb39712542d6076de37085246a0049b10fdedae3ff20a160228a0618703197a947ba4d6c7419490cdf6f4248836ee3e4499b810c976bad71

data/.gitignore

@@ -19,3 +19,4 @@ bin
 *~
 .*.swp
 Session.vim
+.DS_Store

data/.travis.yml

@@ -0,0 +1,13 @@
+# Travis-CI Build for twit
+# see travis-ci.org for details
+
+language: ruby
+
+rvm:
+  - 1.9.3
+  - 2.0.0
+
+script:
+  - git config --global user.name 'The twit tests are as fragile as rugged'
+  - git config --global user.email 'fragile@tests.com'
+  - bundle exec rake

data/README.markdown

@@ -1,7 +1,105 @@
 # Twit: training wheels for Git
 
+[![Build Status](https://travis-ci.org/Pringley/twit.png)](https://travis-ci.org/Pringley/twit)
+
+Twit is an accessible version-control system based on the widely popular
+[Git](http://git-scm.com) program.
+
+## Installation
+
+To install, simply run:
+
+    gem install twit
+
+(On some systems, this may require `sudo`.)
+
+## Usage
+
+Version control allows you to keep track of **changes** to a project over time.
+
+### Example: roll back with `rewind`
+
+Bob is working on an essay for English class. He creates a folder called
+`myessay` and wants to track his changes.
+
+First, he needs to turn that folder into a version-controlled **repository**.
+This is done with the `init` command:
+
+    cd myessay
+    twit init
+
+Then, Bob writes an initial draft of his essay in `myessay/essay.txt`. He can
+then take a snapshot of his first draft using:
+
+    twit save
+
+Each time he makes some edits to the paper, he runs `twit save` again.
+
+One day, he decides to restructure the essay entirely. He makes several `save`s
+with his big changes, deleting large amounts of text.
+
+The next day he realizes that his restructuring effort was a huge mistake and
+wants to recover the way his essay used to be. With version control, you can
+roll back to any previous save point you've marked with `save`.
+
+Bob uses `rewind` to go back three `save`s ago:
+
+    twit rewind 3
+
+**Note:** using version control and frequent `save`s has a few benefits over
+simply making a bunch of copies of your folder. One such benefit is space --
+Twit (and its backend Git) only saves *changes* to your repository rather than
+copying the entire thing. If you have a project with big files, this can save a
+lot of hard disk space. Also, just typing `twit save` is faster than copying,
+pasting, and renaming your new folder with some sort of label so you can find
+it later. This encourages you to make more checkpoints, which gives you more
+points to roll back to.
+
+### Example: using branches for a computer science class
+
+**Branches** are like bookmarks at different save points. They allow you to
+quickly switch between different versions of your repository.
+
+In his computer science class, Bob has a three-part computer lab assignment. In
+the first part, he must write a program, and in the second and third parts, he
+must modify the program he wrote in two different ways.
+
+Bob creates a folder called `cslab` and initializes it as a repository.
+
+    cd cslab
+    twit init
+
+He completes the first part of the assignment. He now uses `saveas` to create a
+new branch containing his completed part one code.
+
+    twit saveas part1
+
+He then works on part two. Once that's working, he can create *another* branch:
+
+    twit saveas part2
+
+Now, he has a problem -- the code he wrote for part two is making it really
+hard to finish part three! That's okay -- it's easy to switch back to the part
+one branch.
+
+    twit open part1
+
+Now the repository is reverted back to the way it was in part one. (The part
+two code is still saved in the `part2` branch -- it's just stored elsewhere for
+now.)
+
+From the part one code, Bob can finish the thirt part and run
+
+    twit saveas part3
+
+Now there are three branches: `part1`, `part2`, and `part3`. Any of them can be
+accessed with `twit open`, so Bob can easily show the professor his work.
+
+## Motivation (written for programmers)
+
 Twit is a wrapper for [Git](http://git-scm.com) that abstracts concepts that
-many newcomers find tedious or confusing.
+many newcomers find tedious or confusing (at the cost of significant
+flexibility).
 
 When explaining version control to newcomers, the benefits are often unclear
 amid the complicated rules and syntax of a powerful tool like Git. Twit aims to
@@ -11,39 +109,45 @@ version control system.
 For example, you can say that "version control allows you to save snapshots of
 your project history." However, in order to do this, you need to understand
 Git's two-step stage-then-commit workflow, with all its corner cases regarding
-new/deleted/moved files.
+new/deleted/moved files. `git commit -a` ignores new files, `git add .` won't
+stage file deletions, etc -- even `git add --all` has to be run from the root
+of the working tree.
 
 Instead, Twit exposes a simple command to create a new commit with a snapshot
 of the repository:
 
     twit save
 
-This stages any changes (including new files and deletions) and creates a
+This stages *all* changes (including new files and deletions) and creates a
 commit, prompting the user for a commit message if needed.
 
 To create a new branch (and save any changes to the new branch as well):
 
     twit saveas my_new_branch
 
+If the user forgets to supply the branch argument and just uses `twit saveas`,
+the CLI will nicely prompt them for a new branch name.
+
 This quick-and-easy approach allows a new user to get started using version
 control right away, without having to learn Git's minutiae.
 
 However, this simple program is **not** meant to replace Git for the power
 user. The interface was designed to be user-friendly at the cost of
-flexibility. If you are a programmer, you should probably just buckle down and
-[learn git](http://gitref.org). Instead, Twit serves as an introduction to
-version control for users that would probably never learn Git, like writers or
+flexibility.
+
+Git has a staging area for a reason -- atomic commits are important. Using
+`twit save` will almost certainly result in commits with batches of changes
+mangled together. *That's okay.* Twit isn't for professionals -- it's Git for
+your mother to write a book, or for non-coders to add documentation to an open
+source project. Best of all, **the repository is still Git underneath**, so
+people can transition easily.
+
+If you are a programmer, you should probably just buckle down and [learn
+git](http://gitref.org). Instead, Twit serves as an introduction to version
+control for users that would probably never learn Git, like writers or
 students.
 
-## Installation
-
-To install, simply run:
-
-    gem install twit
-
-(On some systems, this may require `sudo`.)
-
-## Usage
+## Command Reference
 
 ### `init` -- create a new repository
 
@@ -51,7 +155,7 @@ To install, simply run:
 
 Initialize a new git repository in the current directory.
 
-Equivalent to: `git init`
+Similar to: `git init`
 
 ### `save` -- commit all new changes to the current branch
 
@@ -61,28 +165,30 @@ Take a snapshot of all files in the directory.
 
 Any changes on the working tree will be committed to the current branch.
 
-Equivalent to: `git add --all && git commit -m <DESCRIBE_CHANGES>`
+Similar to: `git add --all && git commit -m <DESCRIBE_CHANGES>`
 
 ### `saveas` -- commit all new changes to a new branch
 
     twit saveas [NEW_BRANCH] [DESCRIBE_CHANGES]
 
-Equivalent to: `git checkout -b <NEW_BRANCH>` then `twit save`
+Similar to: `git checkout -b <NEW_BRANCH>` then `twit save`
 
 ### `open` -- open another branch
 
     twit open [BRANCH]
 
-Equivalent to: `git checkout <branch>`
+Similar to: `git checkout <branch>`
+
+Note: you can't use `twit open` to checkout a lone commit in detached HEAD
+mode.
 
-### `include` -- incorperate changes from another branch
+### `rewind` -- permanently rewind a branch
 
-    twit include [OTHER_BRANCH]
+    twit rewind [AMOUNT]
 
-Incorperate changes from another branch, but do not save them yet. (The user
-can resolve any conflicts and then run `twit save` themselves.)
+**Permanently** move a branch back AMOUNT saves.
 
-Equivalent to: `git merge --no-ff --no-commit [OTHER_BRANCH]`
+Similar to: `git reset --hard HEAD~<amount>`
 
 ### `discard` -- permanently delete unsaved changes
 
@@ -90,13 +196,13 @@ Equivalent to: `git merge --no-ff --no-commit [OTHER_BRANCH]`
 
 **Permanently** delete any unsaved changes to the current branch. Be careful!
 
-Equivalent to: `git reset --hard`
+Similar to: `git reset --hard`
 
 ### `list` -- show all branches
 
     twit list
 
-Equivalent to: `git branch`
+Similar to: `git branch`
 
 ## API
 

data/Rakefile

@@ -1 +1,6 @@
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+task :default => [:spec]
+
+RSpec::Core::RakeTask.new

data/exe/twit-gui

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'twit/gui'
+Twit::GUI.main

data/lib/twit.rb

@@ -2,7 +2,7 @@ require "twit/version"
 require "twit/repo"
 require "twit/error"
 
-require 'open3'
+require "rugged"
 
 # This module exposes twit commands as methods.
 module Twit
@@ -27,12 +27,8 @@ module Twit
       return
     end
 
-    Dir.chdir dir do
-      stdout, stderr, status = Open3.capture3 "git init"
-      if status != 0
-        raise Error, stderr
-      end
-    end
+    Rugged::Repository.init_at(dir)
+
     Repo.new dir
   end
 
@@ -41,17 +37,12 @@ module Twit
   # If no argument is supplied, use the working directory.
   def self.is_repo? dir = nil
     dir ||= Dir.getwd
-    Dir.chdir dir do
-      stdout, stderr, status = Open3.capture3 "git status"
-      if status != 0
-        if /Not a git repository/.match stderr
-          return false
-        else
-          raise Error, stderr
-        end
-      end
-      return true
+    begin
+      root = Rugged::Repository.discover(dir)
+    rescue Rugged::RepositoryError
+      return false
     end
+    return true
   end
 
   # See {Twit::Repo#save}.
@@ -74,14 +65,9 @@ module Twit
     self.repo.open branch
   end
 
-  # See {Twit::Repo#include}.
-  def self.include branch
-    self.repo.include branch
-  end
-
-  # See {Twit::Repo#include_into}.
-  def self.include_into branch
-    self.repo.include_into branch
+  # See {Twit::Repo#rewind}.
+  def self.rewind amount
+    self.repo.rewind amount
   end
 
   # See {Twit::Repo#list}.

data/lib/twit/cli.rb

@@ -1,5 +1,6 @@
 require 'thor'
 require 'twit'
+require 'twit/gui'
 
 module Twit
 
@@ -52,7 +53,7 @@ module Twit
           Twit.saveas branch, message
         rescue InvalidParameter => e
           if /already exists/.match e.message
-            say "Cannot saveas to existing branch. See \"twit help include_into\""
+            say "Cannot saveas to existing branch. Try a git merge!"
           else
             say "Error: #{e.message}"
           end
@@ -95,43 +96,38 @@ module Twit
     end
 
     desc "include", "Integrate changes from another branch"
-    # See {Twit::Repo#include}.
+    # Deprecated: use git merge instead.
     def include other_branch = nil
-      while other_branch.nil? || other_branch.strip == ""
-        other_branch = ask "Please enter the name of the branch to pull changes from:"
-      end
-      begin
-        @success = Twit.include other_branch
-      rescue Error => e
-        say "Error: #{e.message}"
-        return
-      end
-      if @success
-        say "Changes from #{other_branch} successfully included into #{Twit.current_branch}."
-        say "Use \"twit save\" to save them."
-      else
-        say "Conflicts detected! Fix them, then use \"twit save\" to save the changes."
-      end
+      say "This function has been deprecated."
+      say "Use git merge instead!"
     end
 
     desc "include_into", "Integrate changes into another branch"
-    # See {Twit::Repo#include}.
+    # Deprecated: use git merge instead.
     def include_into other_branch = nil
-      while other_branch.nil? || other_branch.strip == ""
-        other_branch = ask "Please enter the name of the branch to push changes into:"
-      end
+      say "This function has been deprecated."
+      say "Use git merge instead!"
+    end
+
+    desc "rewind", "PERMANTENTLY rewind branch to a previous commit"
+    # See {Twit::Repo#rewind}.
+    def rewind amount
       begin
-        @original = Twit.current_branch
-        @success = Twit.include_into other_branch
+        unless Twit.nothing_to_commit?
+          return if no? "You have unsaved changes to your branch. Proceed?"
+        end
+        say "This branch will be rewound by #{amount} save points."
+        if yes? "Would you like to save a copy of these last #{amount} points?"
+          oldbranch = Twit.current_branch
+          newbranch = ask "Enter name for the copy branch:"
+          Twit.saveas newbranch
+          Twit.open oldbranch
+        elsif no? "These #{amount} changes may be lost forever! Are you sure?"
+          return
+        end
+        Twit.rewind amount.to_i
       rescue Error => e
         say "Error: #{e.message}"
-        return
-      end
-      if @success
-        say "Changes from #{@original} successfully included into #{other_branch}."
-        say "Use \"twit save\" to save them."
-      else
-        say "Conflicts detected! Fix them, then use \"twit save\" to save the changes."
       end
     end
 
@@ -139,12 +135,28 @@ module Twit
     # See {Twit::Repo#discard}.
     def discard
       begin
+        say "All changes since last save will be reverted."
+        if yes? "Would you like to copy the changes in a different branch instead?"
+          oldbranch = Twit.current_branch
+          newbranch = ask "Enter name for the copy branch:"
+          Twit.saveas newbranch
+          Twit.open oldbranch
+          return
+        elsif no? "These changes will be lost forever! Are you sure?"
+          return
+        end
         Twit.discard
       rescue Error => e
         say "Error: #{e.message}"
       end
     end
 
+    desc "gui", "Start Twit's graphical user interface"
+    # See {Twit::GUI}.
+    def gui
+      Twit::GUI.main
+    end
+
   end
 
 end

data/lib/twit/error.rb

@@ -10,6 +10,9 @@ module Twit
   # Raised when trying to commit nothing.
   class NothingToCommitError < Error; end
 
+  # Raised when trying to operate on a repository with unsaved changes.
+  class UnsavedChanges < Error; end
+
   # Raised when a command receives an invalid parameter.
   class InvalidParameter < Error; end
 

data/lib/twit/gui.rb

@@ -0,0 +1,10 @@
+require 'twit'
+
+module Twit::GUI
+
+  def main
+    puts "GUI not yet implemented."
+  end
+
+  module_function :main
+end

data/lib/twit/repo.rb

@@ -1,4 +1,4 @@
-require 'open3'
+require 'rugged'
 require 'twit/error'
 
 module Twit
@@ -16,60 +16,69 @@ module Twit
     # raise {Twit::NotARepositoryError}.
     def initialize root = nil
       if root.nil?
-        stdout, stderr, status = Open3.capture3 "git rev-parse --show-toplevel"
-        if status != 0
-          case stderr
-          when /Not a git repository/
-            raise NotARepositoryError
-          else
-            raise Error, stderr
-          end
+        begin
+          root = Rugged::Repository.discover(Dir.getwd)
+        rescue Rugged::RepositoryError
+          raise NotARepositoryError
         end
-        root = stdout.strip
       end
-      @root = root
+      @git = Rugged::Repository.new(root)
+      @root = @git.workdir
     end
 
     # Update the snapshot of the current directory.
     def save message
-      Dir.chdir @root do
-        cmd = "git add --all && git commit -m \"#{message}\""
-        stdout, stderr, status = Open3.capture3 cmd
-        if status != 0
-          if /nothing to commit/.match stdout
-            raise NothingToCommitError
-          elsif /Not a git repository/.match stderr
-            raise NotARepositoryError
-          else
-            raise Error, stderr
-          end
-        end
-      end
+      raise NothingToCommitError if nothing_to_commit?
+      @git.index.add_all
+      @git.index.write
+      usr = {name: @git.config['user.name'],
+             email: @git.config['user.email'],
+             time: Time.now}
+      opt = {}
+      opt[:tree] = @git.index.write_tree
+      opt[:author] = usr
+      opt[:committer] = usr
+      opt[:message] = message
+      opt[:parents] = unless @git.empty?
+                        begin
+                          [@git.head.target].compact
+                        rescue Rugged::ReferenceError
+                          []
+                        end
+                      else [] end
+      opt[:update_ref] = 'HEAD'
+      Rugged::Commit.create(@git, opt)
     end
 
     # Save the current state of the repository to a new branch.
     def saveas newbranch, message = nil
       message ||= "Create new branch: #{newbranch}"
-      # First, create the new branch and switch to it.
-      Dir.chdir @root do
-        cmd = "git checkout -b \"#{newbranch}\""
-        stdout, stderr, status = Open3.capture3 cmd
-        if status != 0
-          case stderr
-          when /not a valid branch name/
-            raise InvalidParameter, "#{newbranch} is not a valid branch name"
-          when /already exists/
-            raise InvalidParameter, "#{newbranch} already exists"
-          when /Not a git repository/
-            raise NotARepositoryError
-          else
-            raise Error, stderr
-          end
+      begin
+        if @git.empty?
+          # For an empty repo, we can "create a new branch" by setting HEAD to
+          # a symbolic reference to the new branch. Then, the next commit will
+          # create that branch (instead of master).
+          Rugged::Reference.create(@git, 'HEAD',
+               "refs/heads/#{newbranch}", true)
+        else
+          # For a non-empty repo, we just create a new branch and switch to it.
+          branch = @git.create_branch newbranch
+          @git.head = branch.canonical_name
+        end
+      rescue Rugged::ReferenceError => error
+        case error.message
+        when /is not valid/
+          raise InvalidParameter, "#{newbranch} is not a valid branch name"
+        when /already exists/
+          raise InvalidParameter, "#{newbranch} already exists"
+        else
+          raise Error, "Internal Rugged error: #{error.message}"
         end
       end
+
       # Next, save any working changes.
       begin
-        Twit.save message
+        save message
       rescue NothingToCommitError
         # New changes are not required for saveas.
       end
@@ -77,127 +86,51 @@ module Twit
 
     # Return an Array of branches in the repo.
     def list
-      Dir.chdir @root do
-        cmd = "git branch"
-        stdout, stderr, status = Open3.capture3 cmd
-        if status != 0
-          case stderr
-          when /Not a git repository/
-            raise NotARepositoryError
-          else
-            raise Error, stderr
-          end
-        end
-        return stdout.split.map { |s|
-          # Remove trailing/leading whitespace and astericks
-          s.sub('*', '').strip
-        }.reject { |s|
-          # Drop elements created due to trailing newline
-          s.size == 0
-        }
-      end
+      Rugged::Branch.each_name(@git, :local).to_a
     end
 
     # Return the current branch.
     def current_branch
-      Dir.chdir @root do
-        cmd = "git rev-parse --abbrev-ref HEAD"
-        stdout, stderr, status = Open3.capture3 cmd
-        if status != 0
-          case stderr
-          when /unknown revision/
-            raise Error, "could not determine branch of repo with no commits"
-          when /Not a git repository/
-            raise NotARepositoryError
-          else
-            raise Error, stderr
-          end
-        end
-        return stdout.strip
+      ref = Rugged::Reference.lookup(@git, 'HEAD').resolve
+      if not ref.branch?
+        raise Error, "Not currently on a branch."
       end
+      ref.name.split('/').last
     end
 
     # Open a branch.
     def open branch
-      Dir.chdir @root do
-        cmd = "git checkout \"#{branch}\""
-        stdout, stderr, status = Open3.capture3 cmd
-        if status != 0
-          case stderr
-          when /Not a git repository/
-            raise NotARepositoryError
-          when /pathspec '#{branch}' did not match any/
-            raise InvalidParameter, "#{branch} does not exist"
-          else
-            raise Error, stderr
-          end
-        end
-      end
+      ref = Rugged::Branch.lookup(@git, branch)
+      raise InvalidParameter, "#{branch} is not a branch" if ref.nil?
+      @git.head = ref.canonical_name
+      @git.reset('HEAD', :hard)
     end
 
     # Clean the working directory (permanently deletes changes!!!).
     def discard
-      Dir.chdir @root do
-        # First, add all files to the index. (Otherwise, we won't discard new
-        # files.) Then, hard reset to revert to the last saved state.
-        cmd = "git add --all && git reset --hard"
-        stdout, stderr, status = Open3.capture3 cmd
-        if status != 0
-          case stderr
-          when /Not a git repository/
-            raise NotARepositoryError
-          else
-            raise Error, stderr
-          end
-        end
-      end
-    end
-
-    # Incorperate changes from another branch, but do not commit them.
-    #
-    # Return true if the merge was successful without conflicts; false if there
-    # are conflicts.
-    def include other_branch
-      Dir.chdir @root do
-        cmd = "git merge --no-ff --no-commit \"#{other_branch}\""
-        stdout, stderr, status = Open3.capture3 cmd
-        if status != 0
-          if /Not a git repository/.match stderr
-            raise NotARepositoryError
-          elsif /Automatic merge failed/.match stdout
-            return false
-          else
-            raise Error, stderr
-          end
-        end
-      end
-      return true
+      # First, add all files to the index. (Otherwise, we won't discard new
+      # files.) Then, hard reset to revert to the last saved state.
+      @git.index.add_all
+      @git.index.write
+      @git.reset('HEAD', :hard)
     end
 
-    # Reverse of {Twit::Repo#include} -- incorperate changes from the current
-    # branch into another.
-    def include_into other_branch
-      original_branch = current_branch
-      open other_branch
-      include(original_branch)
+    # Create a new branch at the specified commit id (may permanently lose
+    # commits!!!).
+    def rewind amount
+      raise UnsavedChanges unless nothing_to_commit?
+      raise ArgumentError, "Expected integer amount" unless amount.is_a? Integer
+      @git.index.add_all
+      @git.index.write
+      @git.reset("HEAD~#{amount}", :hard)
     end
 
     # Return true if there is nothing new to commit.
     def nothing_to_commit?
-      Dir.chdir @root do
-        cmd = "git status"
-        stdout, stderr, status = Open3.capture3 cmd
-        if status != 0
-          case stderr
-          when /Not a git repository/
-            raise NotARepositoryError
-          else
-            raise Error, stderr
-          end
-        end
-        # Check if status indicates nothing to commit
-        return /nothing to commit/.match stdout
+      @git.status do |file, status|
+        return false unless status.empty?
       end
+      return true
     end
 
   end

data/lib/twit/version.rb

@@ -1,4 +1,4 @@
 module Twit
   # Gem version
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/twit/repo_spec.rb

@@ -28,6 +28,7 @@ describe Twit::Repo do
     end
 
     it "works with a directory argument" do
+      `git init #{@tmpdir}` # only works on initialized repo
       repo = Twit::Repo.new @tmpdir
       expect_root repo.root
     end
@@ -271,84 +272,25 @@ describe Twit::Repo do
 
   end
 
-  describe "#include" do
-
+  describe "#rewind" do
     include_context "temp repo"
 
-    shared_examples "simple merge" do
-      it "will create a merge commit" do
-        expect(`git status`).to include('All conflicts fixed but you are still merging')
-      end
-    end
-
-    context "fast-forward merge" do
-      before do
-        # First commit to master
-        File.open("foo", 'w') { |f| f.write("bar\n") }
-        @repo.save "add foo"
-        # Next commit to feature
-        File.open("spam", 'w') { |f| f.write("eggs\n") }
-        @repo.saveas "feature"
-        @repo.open "master"
-        @mergestatus = @repo.include "feature"
-      end
-      include_examples "simple merge"
-    end
-
-    context "no-conflict merge" do
-      before do
-        # First commit to master
-        File.open("foo", 'w') { |f| f.write("bar\n") }
-        @repo.save "add foo"
-        # Next commit to feature
-        File.open("spam", 'w') { |f| f.write("eggs\n") }
-        @repo.saveas "feature"
-        # Add something else to master
-        @repo.open "master"
-        File.open("else", 'w') { |f| f.write("continued\n") }
-        @repo.save "continue work"
-        @mergestatus = @repo.include "feature"
-      end
-      include_examples "simple merge"
+    before do
+      # Create two commits.
+      File.open("spam", 'w') { |f| f.write("first\n") }
+      @repo.save "first commit"
+      @first_id = `git rev-parse HEAD`.strip
+      File.open("spam", 'w') { |f| f.write("second\n") }
+      @repo.save "second commit"
+      @second_id = `git rev-parse HEAD`.strip
+      # Rewind to the first.
+      @repo.rewind 1
     end
 
-    context "conflict merge" do
-      before do
-        # First commit to master
-        File.open("foo", 'w') { |f| f.write("bar\n") }
-        @repo.save "add foo"
-        # Next commit to feature
-        File.open("spam", 'w') { |f| f.write("eggs\n") }
-        @repo.saveas "feature"
-        # Conflicting commit to master
-        @repo.open "master"
-        File.open("spam", 'w') { |f| f.write("spam\n") }
-        @repo.save "continue work"
-        @mergestatus = @repo.include "feature"
-      end
-      it "returns false for conflicts" do
-        expect(@mergestatus).to be_false
-      end
+    it "sets HEAD to the first commit" do
+      expect(`git rev-parse HEAD`.strip).to eq(@first_id)
     end
 
   end
 
-  describe "#include_into" do
-    include_context "temp repo"
-    it "calls current_branch, open, and include" do
-      current_branch = "feature"
-      other_branch = "master"
-
-      @repo.stub(:current_branch) { current_branch }
-      @repo.stub(:open)
-      @repo.stub(:include) { |branch| true }
-
-      @repo.include_into other_branch
-
-      expect(@repo).to have_received(:current_branch)
-      expect(@repo).to have_received(:open).with(other_branch)
-      expect(@repo).to have_received(:include).with(current_branch)
-    end
-  end
-
 end

data/spec/twit_spec.rb

@@ -106,21 +106,12 @@ describe Twit do
     end
   end
 
-  describe "::include" do
+  describe "::rewind" do
     include_context "stub repo"
     it "passes to default Repo object" do
-      branch = "my_branch"
-      expect(@repo).to receive(:include).with(branch)
-      Twit.include branch
-    end
-  end
-
-  describe "::include_into" do
-    include_context "stub repo"
-    it "passes to default Repo object" do
-      branch = "my_branch"
-      expect(@repo).to receive(:include_into).with(branch)
-      Twit.include_into branch
+      amount = 1
+      expect(@repo).to receive(:rewind).with(amount)
+      Twit.rewind amount
     end
   end
 

data/twit.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency "thor"
+  spec.add_runtime_dependency "rugged"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: twit
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Ben Pringle
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2013-08-14 00:00:00.000000000 Z
+date: 2013-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -24,6 +24,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rugged
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -85,24 +99,27 @@ email:
 - ben.pringle@gmail.com
 executables:
 - twit
+- twit-gui
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- .travis.yml
 - Gemfile
 - IDEAS.txt
 - LICENSE.txt
 - README.markdown
 - Rakefile
 - exe/twit
+- exe/twit-gui
 - lib/twit.rb
 - lib/twit/cli.rb
 - lib/twit/error.rb
+- lib/twit/gui.rb
 - lib/twit/repo.rb
 - lib/twit/version.rb
 - spec/spec_helper.rb
-- spec/twit/cli_spec.rb
 - spec/twit/repo_spec.rb
 - spec/twit_spec.rb
 - twit.gemspec
@@ -126,13 +143,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.2
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: Training wheels for Git
 test_files:
 - spec/spec_helper.rb
-- spec/twit/cli_spec.rb
 - spec/twit/repo_spec.rb
 - spec/twit_spec.rb
 has_rdoc: 

data/spec/twit/cli_spec.rb

@@ -1,55 +0,0 @@
-require "twit/cli"
-
-describe Twit::CLI do
-
-  before do
-    @cli = Twit::CLI.new
-
-    # Mock out Twit library to avoid accidentally clobbering anything during
-    # testing.
-    stub_const("Twit", double('Twit'))
-  end
-
-  describe "init" do
-    context "is not repo" do
-      before do
-        Twit.stub(:'is_repo?') { false }
-      end
-      it "calls Twit.init" do
-        expect(Twit).to receive(:init)
-        @cli.invoke :init
-      end
-    end
-  end
-
-  describe "save" do
-    context "need to commit" do
-      before do
-        Twit.stub(:'nothing_to_commit?') { false }
-      end
-      it "calls Twit.save" do
-        message = "my test commit message"
-        expect(Twit).to receive(:save).with(message)
-        @cli.invoke :save, [message]
-      end
-    end
-  end
-
-  describe "saveas" do
-    it "calls Twit.saveas" do
-      Twit.stub(:'nothing_to_commit?') { false }
-      branch = "my_branch"
-      message = "my test commit message"
-      expect(Twit).to receive(:saveas).with(branch, message)
-      @cli.invoke :saveas, [branch, message]
-    end
-  end
-
-  describe "discard" do
-    it "calls Twit.discard" do
-      expect(Twit).to receive(:discard)
-      @cli.invoke :discard
-    end
-  end
-
-end