nit 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 553741b0650ad5eba01775f8cda663d3aedf8ca0
-  data.tar.gz: 9041785b1191731540185990574b2dc3bb3978a9
+  metadata.gz: ad661b2510762a5a197158e53996a4b5c48443dc
+  data.tar.gz: c7a40b75bb9e2e1a0f15929fd478f08637ee635f
 SHA512:
-  metadata.gz: ff8ad770fa0d4022b6712c890128d420e23bb0cefa50445e77a3bf9b895178822e308433ba955de777925d98f475e059e0b26944dff9f7d26074ae60855696d7
-  data.tar.gz: 0aa20962038881633ce12558f12a0025b5377ed313fa539ca59992a8105320239ffa427730e8e587d3b067847556fdf4735d30aac1a052fc16fc8827527a64e1
+  metadata.gz: 2a53d6fcaee8a35a8c37614e211179e6b9c1c56d7501e21a6ae4a07e2bcf8b6175ea6520476eeeb964d788996e5a56177faf65a334d8a3505104ffcf6b59f304
+  data.tar.gz: 2a9103e438303f1cdeb3e46fd1f01d1fa8c3bef9c38766e499db0c53325d3ac5c7b9c268c3267425dcad071e50f59283957ffbbd60faec657fbff153833c085a

data/CHANGES.md

@@ -0,0 +1,4 @@
+## 0.0.3
+
+* Some bug fixes.
+* Allow passing arbitrary git arguments to all nit commands, like `nit commit -m "awesome work" abc"

data/README.md

@@ -46,9 +46,25 @@ First of all, it shows you the current branch in bold.
 
 Secondly, the status screen renders a file index for each file which can be used on the command-line.
 
-Indexes per default are characters on the right-hand side of the filename. This can be configured, in case you prefer digits. You can also have the indexes prepended to the filename.
+Indexes per default are characters on the right-hand side of the filename.
 
-However, scientific studies with `nit` over the last 18 years have proven that characters instead of digits are faster to reach when typing. Also, indexes _appended_ to the filename make them easier to read when deciding what to commit.
+```shell
+#	modified:   on_stage.rb  [a]
+```
+
+This can be configured, in case you prefer digits.
+
+```shell
+#	modified:   on_stage.rb  [0]
+```
+
+You can also have the indexes prepended to the filename.
+
+```shell
+#	modified:   [a] on_stage.rb
+```
+
+Learn [more](https://github.com/apotonick/nit#alternative-indexing).
 
 ## Commit
 
@@ -154,6 +170,12 @@ Will figure out the current branch and run
 git push origin <current branch>
 ```
 
+Note that `pull` and `push` accept command-line options, so this will push your tags as well, if you're releasing.
+
+```shell
+nit push --tags
+```
+
 ## Pull
 
 The same works for `nit pull`.
@@ -165,7 +187,7 @@ You can use nit's index interpolation for any git command.
 
 ```shell
 nit diff ab
-``
+```
 
 
 ## Manual Configuration
@@ -202,6 +224,8 @@ Nap in the park.
 index_renderer = "PrependIndexRenderer"
 ```
 
+However, scientific studies with `nit` over the last 18 years have proven that characters instead of digits are faster to reach when typing. Also, indexes _appended_ to the filename make them easier to read when deciding what to commit.
+
 ## Extending Nit
 
 Extending nit with your own commands can be done either with gems or by placing the extensions into your `.nit` directory. This will be implemented and documented soon.

data/Thorfile

@@ -12,6 +12,7 @@ class Default < Thor
     Rake::Task["build"].execute
   end
 
+  # sometimes gem install pkg/nit-0.x.x works.
   desc "install", "Build and install nit-#{Nit::VERSION}.gem into system gems"
   def install
     Rake::Task["install"].execute

data/lib/nit/app.rb

@@ -1,11 +1,14 @@
 require "thor"
 require "nit/files"
 require "nit/lines"
-require "nit/status"
-require "nit/commit"
 require "nit/config"
-require "nit/ignore"
-
+require "nit/command"
+require "nit/command/status"
+require "nit/command/commit"
+require "nit/command/ignore"
+require "nit/command/push"
+require "nit/command/pull"
+require "nit/command/dynamic"
 
 
 # TODO:
@@ -23,42 +26,36 @@ module Nit
     default_command(:status)
 
     desc "status", "bla"
-    def status
-      puts Status.new(config).call
+    def status(*args)
+      puts Command::Status.new(config).call(args)
     end
 
     desc "commit", "blubb"
     def commit(*args)
-      puts Commit.new(config).call(`git status`, args)
+      puts Command::Commit.new(config).call(args)
     end
 
     desc "ignore", "blubb"
     def ignore(*args)
-      puts Ignore.new(config).call(`git status`, args)
+      puts Command::Ignore.new(config).call(args)
     end
 
     desc "unignore", "blubb"
     def unignore(*args)
-      puts Unignore.new(config).call(`git status`, args)
+      puts Command::Unignore.new(config).call(args)
     end
 
-
     desc "pull", "pull from current branch at origin"
-    def pull
-      `git pull origin #{current_branch}`
+    def pull(*args)
+      puts Command::Pull.new(config).call(args)
     end
 
     desc "push", "push to current branch at origin"
-    def push
-      `git push origin #{current_branch}`
+    def push(*args)
+      puts Command::Push.new(config).call(args)
     end
 
   private
-    def current_branch
-      output = `git branch`
-      branch = output.match(/\* (.+)/)[1].strip
-    end
-
     def config
       @config ||= Config.new # TODO: eventually pass path.
     end
@@ -69,11 +66,8 @@ module Nit
 
     #class DynamicCommand < Thor::DynamicCommand
     Thor::DynamicCommand.class_eval do # see https://github.com/erikhuda/thor/pull/358
-      def run(app, indexes)
-        command = self.name
-        state   = Status::State.new(`git status`, app.send(:config))
-
-        puts `git #{command} #{state.files.list(indexes)}`
+      def run(app, args)
+        puts Command::Dynamic.new(app.send(:config), name).call(args)
       end
     end
   end

data/lib/nit/command.rb

@@ -0,0 +1,38 @@
+module Nit
+  class Command
+    def initialize(config)
+      @config = config
+    end
+
+    def call(args, original=`git status`)
+      state = Status::State.new(original, @config)
+
+      indexes, args = process_args(args)
+
+      process(state, indexes, args)
+    end
+
+  private
+    def process_args(args)
+      ArgsProcessor.new(@config).call(args)
+    end
+
+    class ArgsProcessor
+      def initialize(config)
+      end
+
+      def call(thor_args)
+        args    = []
+        indexes = []
+
+        thor_args.reverse.each do |arg|
+          next unless arg.size == 1 or arg =~ /^\w+$/
+          indexes << arg
+        end
+
+
+        [indexes.reverse, thor_args-indexes]
+      end
+    end
+  end
+end

data/lib/nit/{commit.rb → command/commit.rb}

@@ -1,7 +1,7 @@
-module Nit
+class Nit::Command
   class Commit < Status
-    def process(state, indexes)
-      system "git add #{state.files.list(indexes)} && git commit"
+    def process(state, indexes, args)
+      system "git add #{state.files.list(indexes)} && git commit #{args.join(" ")}"
     end
   end
 end

data/lib/nit/command/dynamic.rb

@@ -0,0 +1,14 @@
+module Nit
+  class Command
+    class Dynamic < Command
+      def initialize(config, name)
+        super(config)
+        @command = name
+      end
+
+      def process(state, indexes, args)
+        `git #{@command} #{args.join(" ")} #{state.files.list(indexes)}`
+      end
+    end
+  end
+end

data/lib/nit/command/ignore.rb

@@ -0,0 +1,38 @@
+module Nit
+  class Command
+    class Ignore < Status
+      def initialize(*)
+        super
+        @ignores = Files.new(@config.ignored_files, @config.indexer)
+      end
+      attr_reader :ignores
+
+    private
+      def process(state, indexes, args)
+        return show if indexes.size == 0
+
+        file_list = state.files.evaluate(indexes).compact
+
+        @config.ignored_files=(@config.ignored_files + file_list)
+      end
+
+      def show
+        return if ignores.size == 0
+
+        output = "Ignored files:\n"
+        ignores.each { |f| output << "[#{ignores.index(f)}] #{f}\n" }
+
+        output
+      end
+    end
+
+    class Unignore < Ignore
+    private
+      def process(state, indexes, args)
+        file_list = state.ignored.evaluate(indexes).compact
+
+        @config.ignored_files=(@config.ignored_files - file_list.map(&:to_s)) # FIXME: make this work with strings and File instances.
+      end
+    end
+  end
+end

data/lib/nit/command/pull.rb

@@ -0,0 +1,8 @@
+class Nit::Command
+  class Pull < Push
+  private
+    def command
+      "pull"
+    end
+  end
+end

data/lib/nit/command/push.rb

@@ -0,0 +1,20 @@
+module Nit
+  class Command
+    class Push < Command
+      def call(args, original=`git branch`)
+        branch = current_branch_for(original)
+
+        system("git #{command} origin #{branch} #{args.join(" ")}")
+      end
+
+    private
+      def command
+        "push"
+      end
+
+      def current_branch_for(screen)
+        screen.match(/\* (.+)/)[1].strip
+      end
+    end
+  end
+end

data/lib/nit/command/status.rb

@@ -0,0 +1,90 @@
+module Nit
+  class Command
+    class Status < Command
+      # Encapsulates the process of computing the file index from `git status`.
+      class State # DISCUSS: alternative names: Screen, ScreenState, FileIndexes?
+        # TODO: test me.
+        def initialize(screen_state, config)
+          @screen = Lines.new(screen_state)
+
+          @files, @ignored = files_for(screen, config)
+        end
+        attr_reader :files, :ignored, :screen
+
+      private
+        def files_for(screen, config)
+          files = screen.files
+
+          ignored = [] # TODO: that must be implemented by Files.
+          files.delete_if { |f| config.ignored_files.include?(f.path) ? ignored << f : false }
+
+          [Files.new(files, config.indexer), Files.new(ignored, config.indexer)]
+        end
+      end
+
+
+      def initialize(config)
+        super
+        extend config.index_renderer
+      end
+
+    private
+      def process(state, indexes, args)
+        files, screen, ignored = state.files, state.screen, state.ignored
+
+        files.each do |file| # TODO: should we have redundant file patterns here? it is better readable, thou.
+          ln = file.line
+          i  = files.index(file)
+
+          if ln.match(screen.file_patterns[:modified])
+            process_modified(i, file, ln)
+          elsif ln.match(screen.file_patterns[:new])
+            process_new(i, file, ln)
+          end
+        end
+
+        # TODO: should be pluggable:
+        ignore_files(screen, ignored)
+        bold_branch(screen)
+
+        screen.to_s
+      end
+
+      module AppendIndexRenderer
+        def process_modified(i, file, line)
+          line << "  [#{i}]"
+        end
+
+        def process_new(*args)
+          process_modified(*args)
+        end
+      end
+
+      module PrependIndexRenderer
+        def process_modified(i, file, line)
+          line.sub!("#\tmodified:", "#\tmodified: [#{i}] ")
+        end
+
+        def process_new(i, file, line)
+          line.sub!("#\t", "#\t [#{i}] ")
+        end
+      end
+
+
+      def bold_branch(lines)
+        lines.find(/# On branch (.+)/) do |ln, matches|
+          line = "# On branch \033[1m#{matches[1]}\033[22m"
+          ln.replace(line)
+        end
+      end
+
+      def ignore_files(screen, ignored)
+        return unless ignored.size > 0
+
+        ignored.each { |f| f.line.delete  }
+        screen << "#"
+        screen << "#   Ignored files: #{ignored.size}"
+      end
+    end
+  end
+end

data/lib/nit/config.rb

@@ -64,7 +64,7 @@ module Nit
 
     def index_renderer
       const = file.read("index_renderer") || "AppendIndexRenderer"
-      Nit::Status.const_get(const)
+      Nit::Command::Status.const_get(const)
     end
 
     def index_renderer=(value)

data/lib/nit/files.rb

@@ -1,6 +1,6 @@
 module Nit
   class Files < Array
-    def initialize(arr=[], indexer=IntegerIndexer)
+    def initialize(arr=[], indexer=IntegerIndexer) # FIXME: make 2nd arg obligatory.
       super(arr)
       extend indexer
     end

data/lib/nit/version.rb

@@ -1,3 +1,3 @@
 module Nit
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/test/commands_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+class CommandsTest < MiniTest::Spec
+  let (:config) { Nit::Config.new }
+  let (:cmd_obj) { Nit::Command.const_get(klass).new(config) }
+  let (:cmd) { cmd_obj.tap do |obj|
+    obj.instance_eval do
+      def system(string); string; end
+    end
+  end }
+
+
+  describe "push" do
+    let (:klass) { "Push" }
+    let (:screen) { "* master\n" }
+
+    it { cmd.call([], screen).must_equal("git push origin master ") }
+    it { cmd.call(["--tags"], screen).must_equal("git push origin master --tags") }
+  end
+
+  describe "pull" do
+    let (:klass) { "Pull" }
+    let (:screen) { "* master\n" }
+
+    it { cmd.call([], screen).must_equal("git pull origin master ") }
+    it { cmd.call(["--tags"], screen).must_equal("git pull origin master --tags") }
+  end
+
+  describe "commit" do
+    let (:klass) { "Commit" }
+    let (:screen) { output }
+
+    it "also ignores files when commiting" do
+      config.ignored_files = ["new.rb", "brandnew.rb", "staged.rb"] # TODO: make this more generic.
+
+      cmd.call(["b"], output).must_equal "git add ../lib/new.rb && git commit "
+    end
+
+    it { cmd.call(["-m", '"awesome work"', "b"], output).must_equal "git add ../lib/new.rb && git commit -m \"awesome work\"" }
+
+    # TODO: test nit commit -a
+  end
+end
+
+class ArgsProcessorTest < MiniTest::Spec
+  let (:config) { Nit::Config.new }
+  subject { Nit::Command::ArgsProcessor.new(config) }
+
+  it { subject.call([]).must_equal [[], []] }
+  it { subject.call(["-a"]).must_equal [[], ["-a"]] }
+  it { subject.call(["-a", "-m", '"message"', "abc"]).must_equal [["abc"], ["-a", "-m", '"message"']] }
+  it { subject.call(["-m", '"message"', "a", "b"]).must_equal [["a", "b"], ["-m", '"message"']] }
+end

data/test/config_test.rb

@@ -11,5 +11,5 @@ class ConfigTest < MiniTest::Spec
     subject.indexer.must_equal Nit::Files::CharIndexer
   end
 
-  it { subject.index_renderer.must_equal Nit::Status::AppendIndexRenderer }
+  it { subject.index_renderer.must_equal Nit::Command::Status::AppendIndexRenderer }
 end

data/test/ignore_test.rb

@@ -1,36 +1,35 @@
 require 'test_helper'
 
 class IgnoreTest < StatusTest
-  let (:config) { cfg = Nit::Config.new; cfg.indexer = "IntegerIndexer"; cfg }
-
+  let (:config) { Nit::Config.new }
   after do
     config.send(:file).rm!
   end
 
   it "ignores invalid indexes" do
-    Nit::Ignore.new(config).call(output, [100])
+    Nit::Command::Ignore.new(config).call(["z"], output)
     config.ignored_files.must_equal []
   end
 
   it "what" do
     config.ignored_files.must_equal []
 
-    Nit::Ignore.new(config).call(output, [0,1])
+    Nit::Command::Ignore.new(config).call(["ab"], output)
 
     config.ignored_files.must_equal ["on_stage.rb", "staged.rb"]
   end
 
   describe "ignore (no arguments)" do
     it "blanks when nothing ignored" do
-      Nit::Ignore.new(config).call(output, []).must_equal nil
+      Nit::Command::Ignore.new(config).call([], output).must_equal nil
     end
 
     it "shows ignored files" do
-      Nit::Ignore.new(config).call(output, [1])
+      Nit::Command::Ignore.new(config).call(["b"], output)
 
-      Nit::Ignore.new(config).call(output, []).must_equal <<-EOF
+      Nit::Command::Ignore.new(config).call([], output).must_equal <<-EOF
 Ignored files:
-[0] staged.rb
+[a] staged.rb
 EOF
 # FIXME: why is <<- not working?
     end
@@ -38,8 +37,8 @@ EOF
 
   describe "unignore 1 2" do
     it "what" do
-      Nit::Ignore.new(config).call(output, [0,1])
-      Nit::Unignore.new(config).call(output, [1])
+      Nit::Command::Ignore.new(config).call(["ab"], output)
+      Nit::Command::Unignore.new(config).call(["b"], output)
       config.ignored_files.must_equal ["on_stage.rb"]
     end
   end

data/test/nit_test.rb

@@ -35,8 +35,10 @@ class DynamicCommandTest < NitTest
   end
 end
 
-class DiffTest < NitTest
+class ArbitraryGitCommandsTest < NitTest
   it { nit(" diff b").must_match "a\/staged.rb" }
+
+  it { nit(" diff --raw b").must_equal ":100644 100644 e69de29... 0000000... M\tstaged.rb\n" }
 end
 
 class NitWithCharIndexerTest < NitTest

data/test/status_test.rb

@@ -8,30 +8,12 @@ class StatusTest < MiniTest::Spec
     end
   end
 
-  let (:output) do <<-EOF
-    # On branch master
-    # Changes not staged for commit:
-    #   (use "git add <file>..." to update what will be committed)
-    #   (use "git checkout -- <file>..." to discard changes in working directory)
-    #
-    #\tmodified:   on_stage.rb
-    #\tmodified:   staged.rb
-    #
-    # Untracked files:
-    #   (use "git add <file>..." to include in what will be committed)
-    #
-    #\tbrandnew.rb
-    #\tnew.rb
-    #\t../lib/new.rb
-    no changes added to commit (use "git add" and/or "git commit -a")
-    EOF
-  end
-  subject { Nit::Status.new(config) }
+  subject { Nit::Command::Status.new(config) }
 
 
   describe "indexing" do
     it "numbers files" do
-      console = subject.call(output)
+      console = subject.call([], output)
       console.must_match "modified: [0]    on_stage.rb"
       console.must_match "modified: [1]    staged.rb"
       console.must_match "[2] brandnew.rb"
@@ -43,7 +25,7 @@ class StatusTest < MiniTest::Spec
     it "indexes files" do
       config.indexer = "CharIndexer"
 
-      console = subject.call(output)
+      console = subject.call([], output)
       console.must_match "modified: [a]    on_stage.rb"
       console.must_match "modified: [b]    staged.rb"
       console.must_match "[c] brandnew.rb"
@@ -57,13 +39,13 @@ class StatusTest < MiniTest::Spec
     end
 
     it "doesn't show ignored files count per default" do
-      subject.call(output).wont_match(/Ignored files:/)
+      subject.call([], output).wont_match(/Ignored files:/)
     end
 
     it "shows ignored files when ignoring" do
       config.ignored_files = ["new.rb", "brandnew.rb", "staged.rb"] # TODO: make this more generic.
 
-      console = subject.call(output)
+      console = subject.call([], output)
       console.must_match "[1] ../lib/new.rb" # this file has a new index since all other ignored.
       console.must_match "Ignored files: 3"
       console.wont_match " staged.rb"
@@ -71,18 +53,5 @@ class StatusTest < MiniTest::Spec
       console.wont_match " brandnew.rb"
       console.must_match " ../lib/new.rb"
     end
-
-    it "also ignores files when commiting" do
-      config.ignored_files = ["new.rb", "brandnew.rb", "staged.rb"] # TODO: make this more generic.
-
-      commit = Nit::Commit.new(config)
-      commit.instance_eval do
-        def system(command)
-          command
-        end
-      end
-
-      commit.call(output, [1]).must_equal "git add ../lib/new.rb && git commit"
-    end
   end
 end

data/test/test_helper.rb

@@ -1,2 +1,23 @@
 require 'minitest/autorun'
 require 'nit/app'
+
+MiniTest::Spec.class_eval do
+  let (:output) do <<-EOF
+    # On branch master
+    # Changes not staged for commit:
+    #   (use "git add <file>..." to update what will be committed)
+    #   (use "git checkout -- <file>..." to discard changes in working directory)
+    #
+    #\tmodified:   on_stage.rb
+    #\tmodified:   staged.rb
+    #
+    # Untracked files:
+    #   (use "git add <file>..." to include in what will be committed)
+    #
+    #\tbrandnew.rb
+    #\tnew.rb
+    #\t../lib/new.rb
+    no changes added to commit (use "git add" and/or "git commit -a")
+    EOF
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nit
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-12 00:00:00.000000000 Z
+date: 2013-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -75,6 +75,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- CHANGES.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -84,14 +85,19 @@ files:
 - lib/nit.rb
 - lib/nit/CHANGES.mk
 - lib/nit/app.rb
-- lib/nit/commit.rb
+- lib/nit/command.rb
+- lib/nit/command/commit.rb
+- lib/nit/command/dynamic.rb
+- lib/nit/command/ignore.rb
+- lib/nit/command/pull.rb
+- lib/nit/command/push.rb
+- lib/nit/command/status.rb
 - lib/nit/config.rb
 - lib/nit/files.rb
-- lib/nit/ignore.rb
 - lib/nit/lines.rb
-- lib/nit/status.rb
 - lib/nit/version.rb
 - nit.gemspec
+- test/commands_test.rb
 - test/config_test.rb
 - test/dummies/stage/.gitignore
 - test/dummies/stage/brandnew.rb
@@ -152,6 +158,7 @@ signing_key:
 specification_version: 4
 summary: Nit improves your git workflows.
 test_files:
+- test/commands_test.rb
 - test/config_test.rb
 - test/dummies/stage/.gitignore
 - test/dummies/stage/brandnew.rb

data/lib/nit/ignore.rb

@@ -1,36 +0,0 @@
-module Nit
-  class Ignore < Status
-    def initialize(*)
-      super
-      @ignores = Files.new(@config.ignored_files)
-    end
-    attr_reader :ignores
-
-  private
-    def process(state, indexes)
-      return show if indexes.size == 0
-
-      file_list = state.files.evaluate(indexes).compact
-
-      @config.ignored_files=(@config.ignored_files + file_list)
-    end
-
-    def show
-      return if ignores.size == 0
-
-      output = "Ignored files:\n"
-      ignores.each { |f| output << "[#{ignores.index(f)}] #{f}\n" }
-
-      output
-    end
-  end
-
-  class Unignore < Ignore
-  private
-    def process(state, indexes)
-      file_list = state.ignored.evaluate(indexes).compact
-
-      @config.ignored_files=(@config.ignored_files - file_list.map(&:to_s)) # FIXME: make this work with strings and File instances.
-    end
-  end
-end

data/lib/nit/status.rb

@@ -1,94 +0,0 @@
-module Nit
-  class Status
-    # Encapsulates the process of computing the file index from `git status`.
-    class State # DISCUSS: alternative names: Screen, ScreenState, FileIndexes?
-      # TODO: test me.
-      def initialize(screen_state, config)
-        @screen = Lines.new(screen_state)
-
-        @files, @ignored = files_for(screen, config)
-      end
-      attr_reader :files, :ignored, :screen
-
-    private
-      def files_for(screen, config)
-        files = screen.files
-
-        ignored = [] # TODO: that must be implemented by Files.
-        files.delete_if { |f| config.ignored_files.include?(f.path) ? ignored << f : false }
-
-        [Files.new(files, config.indexer), Files.new(ignored, config.indexer)]
-      end
-    end
-
-
-    def initialize(config)
-      @config = config
-      extend config.index_renderer
-    end
-
-    def call(original=`git status`, *args)
-      state = State.new(original, @config)
-
-      process(state, *args)
-    end
-
-  private
-    def process(state)
-      files, screen, ignored = state.files, state.screen, state.ignored
-
-      files.each do |file| # TODO: should we have redundant file patterns here? it is better readable, thou.
-        ln = file.line
-        i  = files.index(file)
-
-        if ln.match(screen.file_patterns[:modified])
-          process_modified(i, file, ln)
-        elsif ln.match(screen.file_patterns[:new])
-          process_new(i, file, ln)
-        end
-      end
-
-      # TODO: should be pluggable:
-      ignore_files(screen, ignored)
-      bold_branch(screen)
-
-      screen.to_s
-    end
-
-    module AppendIndexRenderer
-      def process_modified(i, file, line)
-        line << "  [#{i}]"
-      end
-
-      def process_new(*args)
-        process_modified(*args)
-      end
-    end
-
-    module PrependIndexRenderer
-      def process_modified(i, file, line)
-        line.sub!("#\tmodified:", "#\tmodified: [#{i}] ")
-      end
-
-      def process_new(i, file, line)
-        line.sub!("#\t", "#\t [#{i}] ")
-      end
-    end
-
-
-    def bold_branch(lines)
-      lines.find(/# On branch (.+)/) do |ln, matches|
-        line = "# On branch \033[1m#{matches[1]}\033[22m"
-        ln.replace(line)
-      end
-    end
-
-    def ignore_files(screen, ignored)
-      return unless ignored.size > 0
-
-      ignored.each { |f| f.line.delete  }
-      screen << "#"
-      screen << "#   Ignored files: #{ignored.size}"
-    end
-  end
-end