utils 0.0.0

data/bin/number_files

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+include FileUtils::Verbose
+
+def usage
+  STDERR.puts "Usage: #$0 prefix"
+end
+
+ARGV.empty? and usage
+prefix = ARGV.shift
+files = ARGV.sort_by do |x|
+  if m = /(\d+)/.match(x)
+    [ m.pre_match == prefix ? -1 : 0, m[1].to_i ]
+  else
+    [ -1, 0 ]
+  end
+end
+for f in files
+  mv f, f + '.tmp'
+end
+i = 1
+for f in files
+  mv f + '.tmp', sprintf("%s%03u", prefix, i)
+  i += 1
+end

data/bin/same_files

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require 'utils'
+include Utils::MD5
+
+def find_same(*pathes)
+  files = Hash.new { |h,k| h[k] = {} }
+  Utils::Find.find(*pathes) do |filename|
+    file_stat = File.stat(filename)
+    if file_stat.file?
+      size = file_stat.size
+      $DEBUG and warn "Encountered '#{filename}' (#{size} bytes)."
+      files[size][filename] = true
+    end
+  end
+
+  files = files.inject({}) do |h, (_,fs)|
+    keys = fs.keys
+    if keys.size >= 2
+      keys.each { |k| h[k] = true }
+    end
+    h
+  end.keys
+
+  md5s = Hash.new { |h,k| h[k] = [] }
+  for filename in files
+    md5sum = md5 filename
+    md5s[md5sum] << filename
+  end
+  files = md5s.values
+  files.reject! { |fs| fs.size < 2 }
+  files
+end
+
+puts find_same(*ARGV).map { |fs| [ fs.size, fs ] }.sort.map { |c, fs|
+  "#{c}\t#{fs.sort.map { |f| "'#{f}'" } * "\t"}"
+}

data/bin/search

@@ -0,0 +1,205 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require 'utils'
+include Utils::Patterns
+require 'term/ansicolor'
+require 'spruz/xt'
+
+class ::String
+  include Term::ANSIColor
+end
+
+class ::File
+  include Utils::FileXt
+end
+
+class Grepper
+  PRUNE = /\A(\.svn|\.git|CVS|tmp)\Z/
+  SKIP  = /(\A\.|\.sw[pon]\Z|~\Z)/
+
+  class Queue
+    def initialize(max_size)
+      @max_size, @data = max_size, []
+    end
+
+    attr_reader :max_size
+
+    def data
+      @data.dup
+    end
+
+    def push(x)
+      @data.shift if @data.size > @max_size
+      @data << x
+      self
+    end
+    alias << push
+  end
+
+  def initialize(opts = {})
+    @args  = opts[:args] || {}
+    @roots = opts[:roots] || []
+    if n = @args.values_at(*%w[A B C]).compact.first
+      if n.to_s =~ /\A\d+\Z/ and (n = n.to_i) >= 1
+        @queue = Queue.new n
+      else
+        raise ArgumentError, "needs to be an integer number >= 1"
+      end
+    end
+    @pathes  = []
+    pattern_opts = opts.subhash(:pattern) | {
+      :cset  => @args['a'],
+      :icase => @args['i'],
+    }
+    @pattern = @args['R'] ?
+      FuzzyPattern.new(pattern_opts) :
+      RegexpPattern.new(pattern_opts)
+    @name_pattern =
+      if name_pattern = @args['N']
+        RegexpPattern.new(:pattern => name_pattern)
+      elsif name_pattern = @args['n']
+        FuzzyPattern.new(:pattern => name_pattern)
+      end
+    @skip_pattern =
+      if skip_pattern = @args['S']
+        RegexpPattern.new(:pattern => skip_pattern)
+      elsif skip_pattern = @args['s']
+        FuzzyPattern.new(:pattern => skip_pattern)
+      end
+  end
+
+  attr_reader :pathes
+
+  def match(filename)
+    @filename = filename
+    bn = File.basename(filename)
+    @output = []
+    s = File.stat(filename)
+    if s.directory? && bn =~ PRUNE
+      $DEBUG and warn "Pruning '#{filename}'."
+      Utils::Find.prune
+    end
+    if s.file? && bn !~ SKIP && (!@name_pattern || @name_pattern.match(bn))
+      File.open(filename, 'rb') do |file|
+        if file.binary? != true
+          $DEBUG and warn "Matching '#{filename}'."
+          match_lines file
+        else
+          $DEBUG and warn "Skipping binary file '#{filename}'."
+        end
+      end
+    else
+      $DEBUG and warn "Skipping '#{filename}'."
+    end
+    unless @output.empty?
+      case
+      when @args['l'], @args['e']
+        @output.uniq!
+        @pathes.concat @output
+      else
+        STDOUT.puts @output
+      end
+      @output.clear
+    end
+    self
+  rescue SystemCallError => e
+    warn "Caught #{e.class}: #{e}"
+    nil
+  end
+
+  def match_lines(file)
+    for line in file
+      if m = @pattern.match(line)
+        @skip_pattern and @skip_pattern =~ line and next
+        line[m.begin(0)...m.end(0)] = m[0].on_yellow
+        @queue and @queue << line
+        if @args['l'] or @args['e']
+          @output << @filename
+        elsif @args['L']
+          @output << "#{@filename}:#{file.lineno}"
+        else
+          @output << "#{@filename}:#{file.lineno}".red
+          if @args['B'] or @args['C']
+            @output.concat @queue.data
+          else
+            @output << line
+          end
+          if @args['A'] or @args['C']
+            where = file.tell
+            @queue.max_size.times do
+              file.eof? and break
+              line = file.readline 
+              @queue << line
+              @output << line
+            end
+            file.seek where
+          end
+        end
+      else
+        @queue and @queue << line
+      end
+    end
+  end
+
+  def search
+    for dir in @roots
+      Utils::Find.find(dir) { |filename| match(filename) }
+    end
+    @pathes.sort!
+    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 used to match against the content of
+the files. PATHES are the directory and file pathes that are searched.
+
+Options are
+
+  -n PATTERN  only search files whose names match fuzzy PATTERN
+  -N PATTERN  only search files whose names match regex PATTERN
+  -s PATTERN  skip lines that match fuzzy PATTERN
+  -S PATTERN  skip lines that match regex PATTERN
+  -A NUMBER   displays NUMBER lines of context after the match
+  -B NUMBER   displays NUMBER lines of context before the match
+  -C NUMBER   displays NUMBER lines of context around the match
+  -l          just list the pathes of the files with matches
+  -L          list only the path:linenumber of the files with matches
+  -R          interpret PATTERN argument as fuzzy not regex
+  -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:B:C:s:S:n:N:a:RcilLeh'
+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
+
+grepper = Grepper.new(
+  :pattern => pattern,
+  :args    => args,
+  :roots   => roots
+).search
+case
+when args['e'] then edit_files grepper.pathes
+when args['l'] then puts grepper.pathes
+end

data/bin/sedit

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+exec sudo edit $*

data/bin/sshscreen

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+include FileUtils::Verbose
+require 'spruz/go'
+include Spruz::GO
+
+=begin
+~/.ssh/config:
+
+Host *
+  ForwardX11 = yes
+  ControlMaster auto
+  ControlPath ~/.ssh/%r@%h:%p.sock
+=end
+
+def usage
+  puts <<EOT
+Usage: #{File.basename($0)} [OPTS] [user@]remote[:port]"
+
+OPTS is one of
+  -N                  list all session names on the specified remote
+  -n NAME             name of the screen session to attach to
+  -t [HOST[:PORT]]    host:port to tunnel if different from LOCALPORT
+  -l LOCALPORT        the localport to forward to
+  -h                  to display this help
+
+EOT
+  exit 1
+end
+
+arguments = ARGV.dup
+opts = go 'l:t:n:hN', arguments
+usage if opts['h'] or arguments.size != 1
+user_remote = arguments.shift
+user, remote, rport =
+  case user_remote
+  when /\A(?:([^@:]+)@)?([^@:]+)(?::(\d+))?\Z/
+    user = $1 || ENV['USER']
+    user.to_s.empty? and fail "user required to login"
+    [ user, $2, $3 || '22' ]
+  else
+    usage
+  end
+lport = opts['l']
+tunnel, tport = if tunnel_port = opts['t']
+  case tunnel_port
+  when /\A([^:]+)(?::(\d+))?\Z/
+    [ $1, $2 || '22' ]
+  else
+    usage
+  end
+else
+  [ 'localhost', lport ]
+end
+ssh_dir = File.expand_path('~/.ssh')
+mkdir_p ssh_dir
+sock_file = "#{ssh_dir}/#{user}@#{remote}:#{rport}.sock"
+if opts['N']
+  exec "ssh -p #{rport} -S #{sock_file} #{user}@#{remote} screen -ls"
+elsif lport
+  File.exist? sock_file and rm_f sock_file
+  exec "ssh -p #{rport} -Mt -L localhost:#{lport}:#{tunnel}:#{tport}"\
+    " -S #{sock_file} #{user}@#{remote} screen -DUR #{opts['n']}"
+else
+  File.exist? sock_file and rm_f sock_file
+  exec "ssh -p #{rport} -Mt -S #{sock_file} #{user}@#{remote} screen -DUR #{opts['n']}"
+end

data/bin/term

@@ -0,0 +1,21 @@
+#!/bin/sh
+
+if [ "x-x" = x"$1" ]; then
+    EXIT="; exit"; shift;
+fi
+
+if [[ -d "$1" ]]; then
+    WD=`cd "$1"; pwd`; shift;
+else
+    WD="'`pwd`'";
+fi
+
+COMMAND="cd $WD; $@"
+echo "$COMMAND $EXIT"
+
+osascript 2>/dev/null <<EOF
+    tell application "Terminal"
+        activate
+        do script with command "$COMMAND $EXIT"
+    end tell
+EOF

data/bin/unquarantine_apps

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+prefix=$1
+if [ -d $prefix/Applications ]
+then
+  cd $prefix/Applications
+  xattr -rd com.apple.quarantine
+fi

data/bin/untest

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'spruz/xt/write'
+
+for filename in ARGV
+  File.open(filename) do |input|
+    write(filename) do |output|
+      until input.eof?
+        line = input.readline
+        line.sub!(/^(\s*)test "(.+)" do\s*$/) do
+          "#$1def test_" << $2.downcase.gsub(/\A[^a-z]/, '').gsub(/[ -]/, '_').delete('^0-9a-z_')
+        end
+        output.puts line
+      end
+    end
+  end
+end

data/bin/utils-install-config

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'utils'
+
+puts 'Install config into home directory? (yes/NO)'
+if gets =~ /^yes$/i
+  Utils::Config.install_config
+else
+  exit 1
+end

data/bin/vacuum_firefox_sqlite

@@ -0,0 +1,22 @@
+#!/bin/sh
+
+case `uname -s` in
+Darwin)
+  profiles="$HOME/Library/Application Support/Firefox/Profiles/"
+  ;;
+*)
+  profiles="$HOME/.mozilla/firefox/"
+  ;;
+esac
+
+cd "$profiles"
+for p in *.default
+do
+  cd $p
+  for db in *.sqlite
+  do
+    echo "Vacuuming $db..."
+    sqlite3 $db VACUUM
+  done
+  cd -
+done

data/bin/xmp

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+require 'open3'
+
+class String
+  unless method_defined?(:lines)
+    def lines
+      self
+    end
+  end
+end
+
+MARKER = "!XMP#{Time.new.to_i}_#{rand(1000000)}!"
+XMPRE = Regexp.new("^" + Regexp.escape(MARKER) + '\[([0-9]+)\] => (.*)')
+VAR = "_xmp_#{Time.new.to_i}_#{rand(1000000)}"
+WARNING_RE = /-:([0-9]+): warning: (.*)/
+interpreter = ARGV
+interpreter << 'ruby' << '-w' if interpreter.empty?
+
+IO.popen(interpreter.first, 'w') do |script|
+  script.write <<-TEST
+    begin
+      require 'rubygems'
+    rescue LoadError
+      exit 1
+    end
+    exit 0
+  TEST
+end
+if $?.exitstatus == 1
+  ENV['RUBYOPT'] = ENV['RUBYOPT'].gsub(/-rr?ubygems/i, '')
+end
+code = STDIN.read
+
+idx = 0
+newcode = code.gsub(/^(.*) # =>.*/) do |l|
+  expr = $1
+  (/^\s*#/ =~ l) ? l :
+  %!((#{VAR} = (#{expr}); $stderr.puts("#{MARKER}[#{idx+=1}] => " + #{VAR}.inspect) || #{VAR}))!
+end
+stdin, stdout, stderr = Open3::popen3(*interpreter)
+stdin.puts newcode
+stdin.close
+output = stderr.readlines
+
+results = Hash.new{|h,k| h[k] = []}
+output.grep(XMPRE).each do |line|
+  result_id, result = XMPRE.match(line).captures
+  results[result_id.to_i] << result
+end
+
+idx = 0
+annotated = code.gsub(/^(.*) # =>.*/) do |l|
+  expr = $1
+  (/^\s*#/ =~ l) ? l : "#{expr} # => " + (results[idx+=1] || []).join(", ")
+end.gsub(/ # !>.*/, '').gsub(/# (>>|~>)[^\n]*\n/m, "");
+
+warnings = {}
+output.join.lines.grep(WARNING_RE).map do |x|
+  md = WARNING_RE.match(x)
+  warnings[md[1].to_i] = md[2]
+end
+idx = 0
+annotated = annotated.lines.map do |line|
+  w = warnings[idx+=1]
+  w ? (line.chomp + " # !> #{w}") : line
+end
+puts annotated
+output.reject!{|x| /^-:[0-9]+: warning/.match(x)}
+if exception = /^-:[0-9]+:.*/m.match(output.join)
+  puts exception[0].map{|line| "# ~> " + line }
+end
+if (s = stdout.read) != ""
+  puts "# >> #{s.inspect}" 
+end