utils 0.0.0

data/Rakefile

@@ -0,0 +1,68 @@
+begin
+  require 'rake/gempackagetask'
+rescue LoadError
+end
+require 'rake/clean'
+require 'rbconfig'
+include Config
+
+PKG_NAME    = 'utils'
+PKG_VERSION = File.read('VERSION').chomp
+PKG_FILES   = Dir['**/*']#FileList['**/*'].exclude(/(CVS|\.svn|pkg|.git*)/)
+PKG_FILES.reject! { |f| f =~ /\Apkg/ }
+
+if defined? Gem
+  spec = Gem::Specification.new do |s|
+    s.name = PKG_NAME
+    s.version = PKG_VERSION
+    s.summary = "Some useful command line utilities"
+    s.description = "This ruby gem provides some useful command line utilities"
+
+    s.files = PKG_FILES
+
+    s.require_path = 'lib'
+
+    s.bindir = "bin"
+    s.executables.concat Dir['bin/*'].map { |f| File.basename(f) }
+    s.add_dependency 'spruz'
+    s.add_dependency 'term-ansicolor'
+
+    s.author = "Florian Frank"
+    s.email = "flori@ping.de"
+    s.homepage = "http://flori.github.com/utils"
+  end
+
+  task :gemspec do
+    File.open('utils.gemspec', 'w') do |output|
+      output.write spec.to_ruby
+    end
+  end
+
+  Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_tar = true
+    pkg.package_files += PKG_FILES
+  end
+end
+
+desc m = "Writing version information for #{PKG_VERSION}"
+task :version do
+  puts m
+  File.open(File.join('lib', PKG_NAME, 'version.rb'), 'w') do |v|
+    v.puts <<EOT
+module Utils
+  # Utils version
+  VERSION         = '#{PKG_VERSION}'
+  VERSION_ARRAY   = VERSION.split(/\\./).map { |x| x.to_i } # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+end
+EOT
+  end
+end
+
+desc "Default task: write version and test"
+task :default => [ :version, :test ]
+
+desc "Prepare a release"
+task :release => [ :clean, :version, :gemspec, :package ]

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/bin/chroot-exec

@@ -0,0 +1,12 @@
+#!/bin/sh
+DIR=$1
+test -z "$DIR" && exit 1
+PRG=$2
+test -z "$PRG" && PRG=/bin/bash
+mount -t proc none $DIR/proc
+mount -o bind /dev $DIR/dev
+[ -e "$DIR/etc/resolv.conf" ] && cp -vLf "$DIR/etc/resolv.conf" "$DIR/etc/resolv.conf.bak"
+cp -vLf /etc/resolv.conf "$DIR/etc/resolv.conf"
+chroot $DIR $PRG
+umount $DIR/proc
+umount $DIR/dev

data/bin/chroot-libs

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+include FileUtils::Verbose
+
+msg = "Usage: #$0 EXECUTABLE DIR [LIB ..]"
+executable = ARGV.shift or fail msg
+dir = ARGV.shift or fail msg 
+dir = File.expand_path dir
+mkdir_p dir
+
+executable = `which #{executable}`.chomp
+libs = `ldd #{executable}`.gsub(/^(?:.*?\s+=>\s+|\s+)(.*?)\(.*/, '\1').grep(/\S/).map { |x| x.strip }
+libs.concat ARGV
+cd dir
+for l in libs
+  cp l, File.basename(l)
+end

data/bin/classify

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require 'spruz/go'
+include Spruz::GO
+
+class ::String
+  def camelize(first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    else
+      self[0].chr.downcase + camelize(self)[1..-1]
+    end
+  end
+
+  def underscore
+    word = dup
+    word.gsub!(/::/, '/')
+    word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+end
+
+opts = go 'bd'
+
+string  = ARGV.shift or fail "need a class/filepath/filename"
+
+if opts['d']
+  string = string.sub(/.*::/, '') if opts['b']
+  print string.underscore + '.rb'
+else
+  string = File.basename(string) if opts['b']
+  string = string.gsub(/#{Regexp.quote(File.extname(string))}\Z/, '')
+  print string.camelize
+end

data/bin/discover

@@ -0,0 +1,137 @@
+#!/usr/bin/env ruby
+
+require 'utils'
+include Utils::Patterns
+require 'term/ansicolor'
+require 'spruz/xt'
+
+class ::String
+  include Term::ANSIColor
+end
+
+class ::File
+  include Utils::FileXt
+end
+
+class Finder
+  include Utils::Find
+
+  def initialize(opts = {})
+    @args    = opts[:args] || {}
+    @roots   = opts[:roots] || []
+    pattern_opts = opts.subhash(:pattern) | {
+      :cset  => @args['a'],
+      :icase => @args['i'],
+    }
+    @pattern = @args['r'] ?
+      RegexpPattern.new(pattern_opts) :
+      FuzzyPattern.new(pattern_opts)
+    @directory = @args['d']
+    @only_directory = @args['D']
+    @pathes  = []
+  end
+
+  attr_reader :pathes
+
+  def attempt_match?(path)
+    stat = File.stat(path)
+    stat.symlink? and stat = File.lstat(path)
+    if @only_directory
+      stat.directory?
+    elsif @directory
+      stat.directory? || stat.file? && (stat.size == 0 || File.ascii?(path))
+    else
+      stat.file? && (stat.size == 0 || File.ascii?(path))
+    end
+  rescue SystemCallError => e
+    warn "Caught #{e.class}: #{e}"
+    nil
+  end
+
+  def search
+    pathes = []
+    find(*@roots) { |file| pathes << file }
+    pathes.flatten!
+    pathes.uniq!
+    pathes.map! { |p| a = File.split(p) ; a.unshift(p) ; a }
+    pathes = pathes.map! do |path, dir, file|
+      if do_match = attempt_match?(path) and $DEBUG
+        warn "Attempt match of #{path.inspect}"
+      end
+      if do_match and match = @pattern.match(file)
+        if FuzzyPattern === @pattern
+          current = 0
+          bold_file = ''
+          score, e = 0, 0
+          for i in 1...(match.size)
+            match[i] or next
+            b = match.begin(i)
+            bold_file << file[current...b]
+            bold_file << file[b, 1].bold
+            score += (b - e)
+            e = match.end(i)
+            current = b + 1
+          end
+          bold_file << match.post_match
+          [ score, file.size, path, File.join(dir, bold_file) ]
+        else
+          bold_file = file[0...match.begin(0)] <<
+            file[match.begin(0)...match.end(0)].bold <<
+            file[match.end(0)..-1]
+          [ 0, file.size, path, File.join(dir, bold_file) ]
+        end
+      end
+    end
+    pathes.compact!
+    @pathes, output = pathes.sort.transpose.values_at(-2, -1)
+    if !@args['e'] && output && !output.empty?
+      puts output
+    end
+    self
+  end
+end
+
+include Spruz::GO
+
+def edit_files(pathes)
+  system "edit #{pathes.map { |x| "'#{x}'" } * ' '}"
+end
+
+def usage
+  puts <<-EOT
+Usage: #{File.basename($0)} [OPTS] PATTERN [PATHES]
+
+PATTERN is a pattern expression which is find the files. PATHES are the
+directory and file pathes that are searched.
+
+Options are
+
+  -r          interpret PATTERN argument as regex not fuzzy
+  -d          discover directorіes as well
+  -D          discover only directories
+  -c          disable color output
+  -i          use case insensitive matches
+  -e          open the matching files with edit command
+  -a CSET     use only character set CSET from PATTERN
+  -h          display this help
+
+  EOT
+  exit 1
+end
+
+args = go 'a:rdDcieh'
+args['h'] and usage 
+pattern = ARGV.shift or usage
+roots = (ARGV.empty? ? [ Dir.pwd ] : ARGV).map { |f| File.expand_path(f) }
+
+Term::ANSIColor.coloring = (STDIN.tty? && ENV['TERM'] !~ /dumb/) && !args['c']
+STDOUT.sync = true
+
+finder = Finder.new(
+  :pattern => pattern,
+  :args    => args,
+  :roots   => roots
+).search
+if args['e']
+  edit_files finder.pathes
+end

data/bin/edit

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'tempfile'
+
+def cmd(*parts)
+  command = parts.inject([]) do |a, p|
+    case
+    when p == nil, p == []
+      a
+    when p.respond_to?(:to_ary)
+      a.concat p.to_ary
+    else
+      a << p.to_s
+    end
+  end
+  $DEBUG and warn command * ' '
+  command
+end
+
+case `uname -s`
+when /\Adarwin/i
+  vim = if File.directory?('/Applications/Installed')
+          '/Applications/Installed/MacVim.app/Contents/MacOS/Vim'
+        elsif File.directory?('/Applications')
+          '/Applications/MacVim.app/Contents/MacOS/Vim'
+        else
+          fail "cannot find MacVim.app"
+        end
+else
+  vim       = 'gvim'
+  geometry  = [ '-geometry', '80x59' ]
+end
+servername  = [ '--servername', "G#{ENV['USER'].upcase}" ]
+
+argv = ARGV.dup
+if argv.empty?
+  if !STDIN.tty?
+    file = File.new(File.join(Dir.tmpdir, "edit_tmp.#$$"), 'w')
+    until STDIN.eof?
+      buffer = STDIN.read(8192)
+      file.write buffer
+    end
+    file.close
+    argv << file.path
+  elsif `#{vim} -g --serverlist`.split.member?(servername)
+    system *cmd(vim, '-g', geometry, servername, '--remote', "stupid_trick#{rand}")
+    sleep 1
+    exec *cmd(vim, '-g', geometry, servername, '--remote-send', '<ESC>:bw<CR>')
+  else
+    exec *cmd(vim, '-g', geometry, servername)
+  end
+end
+unless argv.empty?
+  lineno_re = /^\s*([^:]+):(\d+)/
+  if argv.first =~ lineno_re
+    for a in argv
+      if a =~ lineno_re
+        system *cmd(vim, '-g', geometry, servername, '--remote', $1)
+        sleep 1
+        system *cmd(vim, '-g', geometry, servername, '--remote-send', "<ESC>:#$2<CR>")
+      else
+        system *cmd(vim, '-g', geometry, servername, '--remote', a)
+      end
+      if a != argv.last
+        STDOUT.print "Press enter to edit the next file."
+        STDOUT.flush
+        STDIN.gets
+      end
+    end
+  else
+    exec *cmd(vim, '-g', geometry, servername, '--remote', *argv)
+  end
+end
+exit 0

data/bin/errf

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require 'term/ansicolor'
+
+class String
+  include Term::ANSIColor
+end
+
+file = ARGV.shift
+name = ARGV.shift
+ENV['RUBYOPT'] = "#{ENV['RUBYOPT']} -Iext:lib:test:tests"
+
+STDOUT.sync = true
+begin
+  output =
+    if name
+      IO.popen("testrb -p '' -n #{name} #{file}", 'r')
+    else
+      IO.popen("testrb -p '' #{file}", 'r')
+    end
+  until output.eof?
+    line = output.readline.uncolored
+    new_line = line.chomp
+    if new_line.sub!(%r(^(?:\s|[\/\[])*([^:]+):(\d+):(.*))) { "#$1:#$2:#$3" }
+      puts new_line
+    else
+      puts line
+    end
+  end
+ensure
+  output and output.close
+end

data/bin/git-empty

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+NAME=$1
+test "$NAME" || exit 1
+
+git symbolic-ref HEAD refs/heads/$NAME
+rm .git/index
+git clean -fdx

data/bin/myex

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+
+require 'spruz'
+include Spruz::GO
+
+def usage
+  puts <<EOT
+Usage: #{File.basename($0)} list|create|truncate|insert|replace [OPTION] [TABLES]
+
+  Commands are
+    - list:     display all tables in the backup
+
+    - create:   display all create table statements in the backup. If TABLES
+                are given, display only those statements.
+      -d        if this OPTION is given, first drop the table (if it exists)
+                before creation.
+
+    - truncate: all tables or the given TABLES, if they exist.
+
+    - insert:   extract insert statemnts from the backup. If TABLES are given,
+                extract only those statements for these TABLES.
+      -t        if this OPTION is given, truncate the table, before starting
+                to insert.
+
+    - replace:  extract insert statemnts from the backup, and convert them
+                into replace statements. If TABLES are given, extract only
+                those statements for these TABLES.
+EOT
+  exit 1
+end
+
+def bell(n = 1, s = 1)
+  n.times do
+    STDERR.print "\a\b"
+    sleep s
+  end
+end
+
+cmd = ARGV.shift or usage
+opts = go('dtD')
+
+STDOUT.sync = true
+case cmd
+when 'list'
+  STDIN.grep(/^CREATE TABLE `([^`]+)` \(/) { puts $1 }
+when 'create'
+  STDIN.grep(/^CREATE TABLE `([^`]+)` \(/) do |stmt|
+    table = $1
+    next unless ARGV.empty? or ARGV.member?(table)
+    if opts['d']
+      puts "DROP TABLE IF EXISTS `#{table}`;"
+      warn "Dropped table #{table}."
+    end
+    line = stmt
+    puts line
+    until line =~ /;$/
+      line = STDIN.readline
+      puts line
+    end
+    warn "Created table #{table}."
+  end
+when 'truncate'
+  STDIN.grep(/^CREATE TABLE `([^`]+)` \(/) do |stmt|
+    table = $1
+    next unless ARGV.empty? or ARGV.member?(table)
+    puts "TRUNCATE TABLE `#{table}`;"
+    warn "Truncated table #{table}."
+  end
+when 'insert'
+  truncated = {}
+  STDIN.grep(/^INSERT INTO `(#{ARGV.empty? ? '[^`]+' : ARGV * '|'})`/) do |stmt|
+    table = $1
+    if opts['t'] and not truncated.key?(table)
+      puts "TRUNCATE TABLE `#{table}`;"
+      truncated[table] = true
+      warn "Truncated table #{table}."
+    end
+    puts stmt
+    warn "Inserted into table #{table}."
+  end
+when 'replace'
+  STDIN.grep(/^INSERT INTO `(#{ARGV.empty? ? '[^`]+' : ARGV * '|'})`/) do |stmt|
+    table = $1
+    puts stmt.sub(/^INSERT INTO `(?:[^`]+)`/, "REPLACE INTO `#{table}`")
+    warn "Replaced into table #{table}."
+  end
+else
+  usage
+end
+bell 3