nit 0.0.1 → 0.0.2

checksums.yaml

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

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.nit

data/README.md

@@ -1,29 +1,219 @@
 # Nit
 
-TODO: Write a gem description
+_Improving your Git workflow since 2013._
+
+Nit is a thin command-line wrapper for git. It gives you handy shortcuts for your everyday work with git, reduces your typing and is easily extendable with your own commands.
+
 
 ## Installation
 
-Add this line to your application's Gemfile:
+```
+gem install nit
+```
+
+This will install the `nit` shell command.
+
+
+## Status
+
+The blank `nit` command will be your best friend.
+
+```shell
+nit
+```
+
+It's a `git status` on LSD.
+
+```shell
+# 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)
+#
+#	modified:   on_stage.rb  [a]
+#	modified:   staged.rb  [b]
+#
+# Untracked files:
+#   (use "git add <file>..." to include in what will be committed)
+#
+#	brandnew.rb  [c]
+#	new.rb  [d]
+```
+
+First of all, it shows you the current branch in bold.
+
+## File Indexes
+
+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.
+
+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.
+
+## Commit
+
+To commit files, you no longer use the filename but their indexes.
+
+```shell
+nit commit a c
+```
+
+Which will run
+
+```
+git add on_stage.rb
+git add brandnew.rb
+git commit
+```
+
+Note that nits adds and commits an already staged file _and_ an untracked file in the same step.
+
+This could also be run as
+
+```shell
+nit commit ac
+```
+
+Nit will extract the correct indexes.
+
+
+## Auto-Expansion Of Commands
+
+You don't have to type `nit commit` everytime. Use a short-cut, nit figures out what command you want. This command will work, too.
+
+```shell
+nit co abc
+```
+
+## Add
+
+Adding with nit becomes obsolete. It is handled by the `commit` command.
+
+
+## Ignoring Files
+
+When files on the status screen get in your way you can _ignore_ them. Nit will simply not consider them anymore until you `unignore` them.
+
+Ignoring files is roughly equivalent to `git stash`. However, instead of having to remember dozens of stashes, you simply tell nit to hide files from your status. That helps focusing on the files you are actually working on. Trust us.
+
+
+```shell
+nit ignore a d
+```
+
+This tells nit to ignore `on_stage.rb` and `new.rb`.
+
+```shell
+$ nit
+
+# 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)
+#
+#	modified:   staged.rb  [a]
+#
+# Untracked files:
+#   (use "git add <file>..." to include in what will be committed)
+#
+#	brandnew.rb  [b]
+#
+# Ignored files: 2
+```
+
+The ignored files are now longer visible. However, the last line reminds you that there are files ignored.
+
+To get a list of ignored files, run:
+
+```shell
+nit ignore
+```
+
+```shell
+[a] on_stage.rb
+[b] new.rb
+```
+
+If you want to commit to the ignored files, just unignore them, again.
+
+```shell
+nit unignore a
+```
+
+## Push
+
+To push your changes, run the following command.
+
+```shell
+nit push
+```
+
+Will figure out the current branch and run
+
+```shell
+git push origin <current branch>
+```
+
+## Pull
+
+The same works for `nit pull`.
+
+
+## Arbitrary Commands
+
+You can use nit's index interpolation for any git command.
+
+```shell
+nit diff ab
+``
+
+
+## Manual Configuration
+
+Some operations require nit to save application state. This is done in the `.nit` YAML file in your working directory. You can manually edit it.
+
+
+## Alternative Indexing
+
+You can have number-based indexing.
+
+```shell
+modified:   on_stage.rb  [0]
+modified:   staged.rb  [1]
+```
+
+In `.nit`, do
+
+```yaml
+indexer = "IntegerIndexer"
+```
+
+Some people prefer the index prepending the file name.
+
+```shell
+modified:  [0] on_stage.rb
+modified:  [1] staged.rb
+
+```
+
+Nap in the park.
+
+```yaml
+index_renderer = "PrependIndexRenderer"
+```
 
-    gem 'nit'
+## Extending Nit
 
-And then execute:
+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.
 
-    $ bundle
 
-Or install it yourself as:
+## More
 
-    $ gem install nit
+There are plenty of more features planned for the upcoming versions.
 
-## Usage
 
-TODO: Write usage instructions here
+## License
 
-## Contributing
+Copyright (c) 2013, Nick Sutterer <apotonick@gmail.com>
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+Released under the MIT License.

data/Rakefile

@@ -1 +1,12 @@
 require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+desc 'Test the nit gem.'
+task :default => :test
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.test_files = FileList["test/status_test.rb"] + FileList['test/*_test.rb']
+  test.verbose = true
+end

data/Thorfile

@@ -0,0 +1,19 @@
+$:.unshift File.expand_path("../lib", __FILE__)
+
+require 'bundler'
+require 'thor/rake_compat'
+
+class Default < Thor
+  include Thor::RakeCompat
+  Bundler::GemHelper.install_tasks
+
+  desc "build", "Build nit-#{Nit::VERSION}.gem into the pkg directory"
+  def build
+    Rake::Task["build"].execute
+  end
+
+  desc "install", "Build and install nit-#{Nit::VERSION}.gem into system gems"
+  def install
+    Rake::Task["install"].execute
+  end
+end

data/bin/nit

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require "nit/app"
+Nit::App.start

data/lib/nit/CHANGES.mk

@@ -0,0 +1,7 @@
+h2. 0.0.2
+
+* First real release.
+
+h2. 0.0.1
+
+* Claiming the `nit` gem name.

data/lib/nit/app.rb

@@ -0,0 +1,80 @@
+require "thor"
+require "nit/files"
+require "nit/lines"
+require "nit/status"
+require "nit/commit"
+require "nit/config"
+require "nit/ignore"
+
+
+
+# TODO:
+# * diff workflow: going through changed files, adding them while reading!
+# * nit unstage => git reset HEAD
+# * nit ignore (save time and last changed!)
+# * nit unignore
+# * nit co -a => git commit -a
+# * nit co 1<tab> => filename
+
+module Nit
+  class App < Thor
+    include Actions
+
+    default_command(:status)
+
+    desc "status", "bla"
+    def status
+      puts Status.new(config).call
+    end
+
+    desc "commit", "blubb"
+    def commit(*args)
+      puts Commit.new(config).call(`git status`, args)
+    end
+
+    desc "ignore", "blubb"
+    def ignore(*args)
+      puts Ignore.new(config).call(`git status`, args)
+    end
+
+    desc "unignore", "blubb"
+    def unignore(*args)
+      puts Unignore.new(config).call(`git status`, args)
+    end
+
+
+    desc "pull", "pull from current branch at origin"
+    def pull
+      `git pull origin #{current_branch}`
+    end
+
+    desc "push", "push to current branch at origin"
+    def push
+      `git push origin #{current_branch}`
+    end
+
+  private
+    def current_branch
+      output = `git branch`
+      branch = output.match(/\* (.+)/)[1].strip
+    end
+
+    def config
+      @config ||= Config.new # TODO: eventually pass path.
+    end
+
+    # def self.dynamic_command_class
+    #   DynamicCommand
+    # end
+
+    #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)}`
+      end
+    end
+  end
+end

data/lib/nit/commit.rb

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

data/lib/nit/config.rb

@@ -0,0 +1,81 @@
+require "psych"
+require "thor"
+
+module Nit
+  class Config < Thor::Group # we have to derive from Group to get the create_file working - that's messy.
+    include Thor::Actions
+    # Warning: this API will soon change.
+
+    class File
+      def initialize(name, app) # FIXME: i hate the app dependency for #create_file.
+        @name = name
+        @app  = app
+      end
+
+      def read(key)
+        return unless exist?
+        yaml_hash[key]
+      end
+
+      def write(key, value)
+        @app.create_file(@name, Psych.dump({})) unless exist?
+
+        hash = yaml_hash
+        hash[key] = value
+        ::File.open(@name, "w") { |f| f.write(Psych.dump(hash))  }
+      end
+
+      def rm!
+        @app.remove_file(@name)
+      end
+
+    private
+      def exist?
+        ::File.exist?(@name)
+      end
+
+      def yaml_hash
+        Psych.load_file(@name) || {}
+      end
+    end
+
+
+    def initialize
+      super
+      @file = File.new(filename, self) # FIXME: remove the Thor::App dependency, see above!
+    end
+
+    def ignored_files
+      file.read("ignored_files") or []
+    end
+
+    def ignored_files=(files)
+      file.write("ignored_files", files.collect(&:to_s))
+    end
+
+    def indexer
+      const = file.read("indexer") || "CharIndexer"
+      Nit::Files.const_get(const)
+    end
+
+    def indexer=(value)
+      file.write("indexer", value)
+    end
+
+    def index_renderer
+      const = file.read("index_renderer") || "AppendIndexRenderer"
+      Nit::Status.const_get(const)
+    end
+
+    def index_renderer=(value)
+      file.write("index_renderer", value)
+    end
+
+  private
+    attr_reader :file
+
+    def filename
+      ".nit"
+    end
+  end
+end

data/lib/nit/files.rb

@@ -0,0 +1,60 @@
+module Nit
+  class Files < Array
+    def initialize(arr=[], indexer=IntegerIndexer)
+      super(arr)
+      extend indexer
+    end
+
+    # we could also use a dedicated object here.
+    module PublicMethods
+      def [](index)
+        super(index.to_i)
+      end
+
+      # Return list of file names for indexes.
+      def evaluate(indexes)
+        indexes.collect { |i| self[i] }
+      end
+
+       # decorator:
+      def list(indexes)
+        indexes.collect { |i| self[i] }.join(" ")
+      end
+    end
+    include PublicMethods
+
+  private
+
+    module IntegerIndexer
+    end
+
+    module CharIndexer
+      def [](char)
+        index = map.index(char)
+        super(index)
+      end
+
+      def evaluate(chars)
+        super(split(chars)) # "nit commit abc"
+      end
+
+      def index(file)
+        map[super]
+      end
+
+      def list(indexes)
+        super(split(indexes))
+      end
+
+    private
+      def map
+        ("a".."z").collect(&:to_s)
+      end
+
+      def split(chars)
+        return chars unless chars.find { |c| c.length > 1 } # DISCUSS: what if "> aa bcd xx" where xx is actually an index?
+        chars.first.split("")
+      end
+    end
+  end
+end

data/lib/nit/ignore.rb

@@ -0,0 +1,36 @@
+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/lines.rb

@@ -0,0 +1,63 @@
+module Nit
+  class Lines < Array
+    def initialize(text)
+      super(text.split("\n").collect { |ln| Line.new(ln, self) })
+    end
+
+    def find(pattern)
+      each do |ln|
+        next unless matches = ln.match(pattern)
+
+        yield ln, matches
+      end
+    end
+
+    def files
+      files = []
+
+      for type, pattern in file_patterns
+        find(pattern) do |ln, matches|
+          files << file = File.new(matches[1].strip, ln)
+        end
+      end
+
+      files
+    end
+
+    def to_s
+      join("\n")
+    end
+
+  #private
+    def file_patterns
+      {
+        modified: /#\tmodified:(.+)/,
+        new: /#\t([^modified:].+)/
+      }
+    end
+  end
+
+  class Line < String
+    def initialize(string, screen)
+      super(string)
+      @screen = screen
+    end
+
+    # Deletes the entire line from the screen.
+    def delete
+      @screen.delete(self)
+    end
+  end
+
+  class File
+    def initialize(path, line)
+      @path, @line = path, line
+    end
+
+    attr_reader :path, :line
+
+    def to_s
+      path.to_s
+    end
+  end
+end