chit 0.0.6

data/Manifest.txt

@@ -0,0 +1,9 @@
+Manifest.txt
+README.txt
+Rakefile
+bin/chit
+lib/chit.rb
+lib/wrap.rb
+resources/chitrc
+tools/chit-bash-completion.sh
+tools/chit.tmCommand

data/README.txt

@@ -0,0 +1,130 @@
+= Chit
+
+http://github.com/robin/chit
+
+== DESCRIPTION:
+
+Chit is a command line cheat sheet utility based on git.
+
+== FEATURES:
+
+Chit was inspired by 'cheat' (http://cheat.errtheblog.com/) by Chris Wanstrath. You can use chit to access and manage cheat sheets easily. 
+
+There are several differences between ‘cheat’ and ‘chit’. By using chit, besides the wonderful features of ‘cheat’, you get:
+
+1. Git powered cheat sheet repository. You can specify where you get the sheets and where to share them.
+2. Your own private cheat sheets. Everybody has some project related or smoe cheat sheets which are not mean to public. You can also put them into chit
+3. Directory support. You can group cheat sheets by directory now.
+4. One less letter to type.
+
+== SYNOPSIS:
+
+To initialize chit repositories
+
+$ chit --init
+
+This will be run automatically when you run chit for the first time. 
+
+To get a cheat sheet:
+
+$ chit [cheatsheet]
+
+To edit a cheat sheet, use the --edit/-e switch.
+
+$ cheat [cheatsheet] --edit
+
+To add a cheat sheet, use the --add/-a switch.
+
+$ cheat [cheatsheet] --add
+
+During editing a cheat sheet, empty the content will get the cheat sheet removed.
+
+A prefix '@' indicates the cheat sheet is in private mode. A private cheat sheet is kept in another repository.
+
+To get your private cheat sheet:
+
+$ chit @[cheatsheet]
+
+The prefix '@' works the same for both --edit/-e and --add/-a.
+
+The cheat sheet can be in a path. For example:
+
+$ chit mysql/select
+
+will get the cheat sheet 'select' under mysql.
+
+To show all the cheat sheets:
+
+$ chit [all|sheets]
+
+To show all the private cheat sheets:
+
+$ chit @[all|sheets]
+
+To find cheat sheets begin with 'name', use the --find/-f switch
+
+$ chit name --find
+
+To search cheat sheets content with 'text', use the --search/-s switch
+
+$ chit text --search
+
+To move or rename a sheet, use '--mv/-m' switch
+
+$ chit zsh_if zsh/if -m
+
+== INSTALL:
+
+sudo gem install robin-chit -s http://gems.github.com
+
+chit --init
+
+== CONFIGURATION:
+
+Before run 'chit', you may want to config ~/.chitrc which is a YAML file.
+
+* root: local path to store the cheat sheet. By default, it is ~/.chit
+* add_if_not_exist: when set as 'true', if no sheets found, a new one will be created and waiting for editing. Leave it blank and quit the editor if you don't 
+want to add a new one.
+* main: 
+* clone-from: where to get the public cheat sheets. You can use git://github.com/robin/chitsheet.git, which is a snap shoot of http://cheat.errtheblog.com/.
+* private:
+* clone-from: where to get the private cheat sheets. If not specified, a new git repository will be init for private cheat sheets.
+
+== REQUIREMENTS:
+
+* rubygems
+* git
+
+== LICENSE:
+
+This software is shared by MIT License
+
+Copyright (c) 2008 Robin Lu
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+== BY:
+
+Robin Lu
+
+http://www.robinlu.com
+
+iamawalrus[at]gmail[dot]com

data/Rakefile

@@ -0,0 +1,19 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require './lib/chit.rb'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "chit"
+    gemspec.summary = "A command line cheat sheet utility based on git"
+    gemspec.description = "A command line cheat sheet utility based on git"
+    gemspec.email = "iamawalrus@gmail.com"
+    gemspec.homepage = "http://github.com/robin/chit"
+    gemspec.authors = ["Robin Lu"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+# vim: syntax=Ruby

data/bin/chit

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'chit'
+Chit.run(ARGV)

data/lib/chit.rb

@@ -0,0 +1,252 @@
+$:.unshift File.dirname(__FILE__)
+%w(rubygems git tempfile fileutils yaml wrap).each {|f| require f}
+
+module Chit
+  extend self
+  VERSION = '0.0.6'
+  
+  defaults = {
+    'root'  => File.join("#{ENV['HOME']}",".chit")
+  }
+  
+  CHITRC = File.join("#{ENV['HOME']}",".chitrc")
+  
+  FileUtils.cp(File.join(File.dirname(__FILE__), "..","resources","chitrc"), CHITRC) unless File.exist?(CHITRC)
+  
+  CONFIG = defaults.merge(YAML.load_file(CHITRC))
+  
+  def run(args)
+    unless File.exist?(main_path) && File.exist?(private_path)
+      return unless init_chit
+    end
+    args = args.dup
+    
+    return unless parse_args(args)
+
+    if %w[sheets all].include? @sheet
+      return list_all()
+    end
+    
+    unless File.exist?(sheet_file)
+      update
+    end
+    
+    unless File.exist?(sheet_file)
+      if args.delete('--no-add').nil? && CONFIG['add_if_not_exist']
+        add(sheet_file)
+      else
+        puts "Error!:\n  #{@sheet} not found"
+        puts "Possible sheets:"
+        search_title
+      end
+    else
+      format = 'html' if args.delete('--html')
+      show(sheet_file,format)
+    end
+  end
+  
+  def parse_args(args)
+    init_chit and return if args.delete('--init')
+    update and return if args.delete('--update')
+    
+    @sheet = args.shift || 'chit'
+    is_private = (@sheet =~ /^@(.*)/)
+    @sheet = is_private ? $1 : @sheet
+
+    @working_dir = is_private ? private_path : main_path
+    @git = Git.open(@working_dir)
+
+    @fullpath = File.join(@working_dir, "#{@sheet}.yml")
+    
+    add(sheet_file) and return if (args.delete('--add')||args.delete('-a'))
+    edit(sheet_file) and return if (args.delete('--edit')||args.delete('-e'))
+    search_title and return if (args.delete('--find')||args.delete('-f'))
+    search_content and return if (args.delete('--search')||args.delete('-s'))
+    
+    if (args.delete('--mv') || args.delete('-m'))
+      target = args.shift
+      mv_to(target) and return if target
+      puts "Target not specified!"
+      return
+    end
+    true
+  end
+  
+  def list_all
+    puts all_sheets.sort.join("\n")
+  end
+  
+  def mv_to(target)
+    if target =~ /^@(.*)/
+      target = $1
+    end
+    target_path = File.join(@working_dir, "#{target}.yml")
+    prepare_dir(target_path)
+    @git.lib.mv(sheet_file, target_path)
+    sheet = YAML.load(IO.read(target_path)).to_a.first
+    body = sheet[-1]
+    title = parse_title(target)
+    open(target_path,'w') {|f| f << {title => body}.to_yaml}
+    @git.add
+    @git.commit_all(" #{@sheet} moved to #{target}")
+  end
+  
+  def search_content
+    @git.grep(@sheet).each {|file, lines|
+      title = title_of_file(file.split(':')[1])
+      lines.each {|l|
+        puts "#{title}:#{l[0]}:  #{l[1]}"
+      }
+    }
+  end
+  
+  def search_title
+    reg = Regexp.compile("^#{@sheet}")
+    files = all_sheets.select {|sheet| sheet =~ reg }
+    puts "  " + files.sort.join("\n  ")
+    true
+  end
+  
+  def sheet_file
+    @fullpath
+  end
+  
+  def init_chit
+    FileUtils.mkdir_p(CONFIG['root'])
+    if CONFIG['main']['clone-from']
+      if File.exist?(main_path)
+        puts "Main chit has already been initialized."
+      else
+        puts "Initialize main chit from #{CONFIG['main']['clone-from']} to #{CONFIG['root']}/main"
+        Git.clone(CONFIG['main']['clone-from'], 'main', :path => CONFIG['root'])
+        puts "Main chit initialized."        
+      end
+    else
+      puts "ERROR: configuration for main chit repository is missing!"
+      return
+    end
+    
+    unless File.exist?(private_path)
+      if CONFIG['private'] && CONFIG['private']['clone-from']
+        puts "Initialize private chit from #{CONFIG['private']['clone-from']} to #{CONFIG['root']}/private"
+        Git.clone(CONFIG['private']['clone-from'], 'private', :path => CONFIG['root'])
+        puts "Private chit initialized."
+      else
+        puts "Initialize private chit from scratch to #{CONFIG['root']}/private"
+        git = Git.init(private_path)
+        FileUtils.touch(File.join(CONFIG['root'],'private','.gitignore'))
+        git.add
+        git.commit_all("init private repository")
+        puts "Private chit initialized."
+      end
+    else
+      puts "Private chit has already been initialized."
+    end
+    puts "Chit init done."
+    true
+  end
+  
+  def update
+    if CONFIG['main']['clone-from']
+      g = Git.open(main_path)
+      g.pull
+    end
+  rescue
+    puts "ERROR: can not update main chit."
+    puts $!
+  end
+  
+  def main_path
+    File.join(CONFIG['root'], 'main')
+  end
+  
+  def private_path
+    File.join(CONFIG['root'], 'private')
+  end
+  
+  def show(file,format=nil)
+    sheet = YAML.load(IO.read(file)).to_a.first
+    sheet[-1] = sheet.last.join("\n") if sheet[-1].is_a?(Array)
+    case format
+    when 'html'
+      puts "<h1>#{sheet.first}</h1>"
+      puts "<pre>#{sheet.last.gsub("\r",'').gsub("\n", "\n  ").wrap}</pre>"
+    else
+      puts sheet.first + ':'
+      puts '  ' + sheet.last.gsub("\r",'').gsub("\n", "\n  ").wrap      
+    end
+  end
+  
+  def rm(file)
+    @git.remove(file)
+    @git.commit_all("#{@sheet} removed")
+  rescue Git::GitExecuteError
+    FileUtils.rm_rf(file)
+  end
+  
+  def add(file)
+    unless File.exist?(file)
+      prepare_dir(file)
+      title = parse_title(@sheet)
+      yml = {"#{title}" => ''}.to_yaml
+      open(file, 'w') {|f| f << yml}
+    end
+    edit(file)
+  end
+  
+  def edit(file)
+    sheet = YAML.load(IO.read(file)).to_a.first
+    sheet[-1] = sheet.last.gsub("\r", '')
+    body, title = write_to_tempfile(*sheet), sheet.first
+    if body.strip.empty?
+      rm(file)
+    else
+      open(file,'w') {|f| f << {title => body}.to_yaml}
+      @git.add
+      st = @git.status
+      unless st.added.empty? && st.changed.empty? && st.deleted.empty? && st.untracked.empty?
+        @git.commit_all(" #{@sheet} updated")        
+      end
+    end
+    true
+  end
+  
+  private
+  def parse_title(sheet_name)
+    sheet_name.split(File::Separator).join('::')
+  end
+  
+  def prepare_dir(file)
+    breaker = file.rindex(File::Separator)+1
+    path = file[0,breaker]
+    FileUtils.mkdir_p(path)
+  end
+  
+  def editor
+    ENV['VISUAL'] || ENV['EDITOR'] || "vim"
+  end
+  
+  def write_to_tempfile(title, body = nil)
+    title = title.gsub(/\/|::/, '-')
+    # god dammit i hate tempfile, this is so messy but i think it's
+    # the only way.
+    tempfile = Tempfile.new(title + '.cheat')
+    tempfile.write(body) if body
+    tempfile.close
+    system "#{editor} #{tempfile.path}"
+    tempfile.open
+    body = tempfile.read
+    tempfile.close
+    body
+  end
+  
+  def all_sheets
+    @git.ls_files.to_a.map {|f| 
+      title_of_file(f[0])}
+  end
+  
+  def title_of_file(f)
+    f[0..((f.rindex('.')||0) - 1)]
+  end
+  
+end

data/lib/wrap.rb

@@ -0,0 +1,42 @@
+# >> Evan Weaver
+# => http://blog.evanweaver.com/articles/2006/09/03/smart-plaintext-wrapping
+class String
+  def wrap(width = 80, hanging_indent = 0, magic_lists = false)
+    lines = self.split(/\n/)
+
+    lines.collect! do |line|
+
+      if magic_lists 
+        line =~ /^([\s\-\d\.\:]*\s)/
+      else 
+        line =~ /^([\s]*\s)/
+      end
+
+      indent = $1.length + hanging_indent rescue hanging_indent
+
+      buffer = ""
+      first = true
+
+      while line.length > 0
+        first ? (i, first = 0, false) : i = indent              
+        pos = width - i
+
+        if line.length > pos and line[0..pos] =~ /^(.+)\s/
+          subline = $1
+        else 
+          subline = line[0..pos]
+        end
+        buffer += " " * i + subline + "\n"
+        line.tail!(subline.length)
+      end
+      buffer[0..-2]
+    end
+
+    lines.join("\n")
+  end
+
+  def tail!(pos)
+    self[0..pos] = ""
+    strip!
+  end
+end

data/resources/chitrc

@@ -0,0 +1,8 @@
+# root: 
+# add_if_not_exist: true
+main:
+  clone-from: git://github.com/robin/chitsheet.git
+#  push-to:
+private:
+#   clone-from:
+#   push-to:

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: chit
+version: !ruby/object:Gem::Version 
+  version: 0.0.6
+platform: ruby
+authors: 
+- Robin Lu
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-19 00:00:00 +08:00
+default_executable: chit
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: schacon-git
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.5.3
+    version: 
+description: Chit is A command line tool for cheat sheet utility based on git.
+email: 
+- iamawalrus@gmail.com
+executables: 
+- chit
+extensions: []
+
+extra_rdoc_files: 
+- Manifest.txt
+- README.txt
+files: 
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/chit
+- lib/chit.rb
+- lib/wrap.rb
+- resources/chitrc
+- test/test_chit.rb
+has_rdoc: true
+homepage: http://github.com/robin/chit
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: chit
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: Chit is A command line tool for cheat sheet utility based on git.
+test_files: 
+- test/test_chit.rb