git.cworth.org Git - sup/blob - lib/sup/util.rb

   1 require 'thread'
   2 require 'lockfile'
   3 require 'mime/types'
   4 require 'pathname'
   5
   6 ## time for some monkeypatching!
   7 class Lockfile
   8   def gen_lock_id
   9     Hash[
  10          'host' => "#{ Socket.gethostname }",
  11          'pid' => "#{ Process.pid }",
  12          'ppid' => "#{ Process.ppid }",
  13          'time' => timestamp,
  14          'pname' => $0,
  15          'user' => ENV["USER"]
  16         ]
  17   end
  18
  19   def dump_lock_id lock_id = @lock_id
  20       "host: %s\npid: %s\nppid: %s\ntime: %s\nuser: %s\npname: %s\n" %
  21         lock_id.values_at('host','pid','ppid','time','user', 'pname')
  22     end
  23
  24   def lockinfo_on_disk
  25     h = load_lock_id IO.read(path)
  26     h['mtime'] = File.mtime path
  27     h
  28   end
  29
  30   def touch_yourself; touch path end
  31 end
  32
  33 class Pathname
  34   def human_size
  35     s =
  36       begin
  37         size
  38       rescue SystemCallError
  39         return "?"
  40       end
  41     s.to_human_size
  42   end
  43
  44   def human_time
  45     begin
  46       ctime.strftime("%Y-%m-%d %H:%M")
  47     rescue SystemCallError
  48       "?"
  49     end
  50   end
  51 end
  52
  53 ## more monkeypatching!
  54 module RMail
  55   class EncodingUnsupportedError < StandardError; end
  56
  57   class Message
  58     def self.make_file_attachment fn
  59       bfn = File.basename fn
  60       t = MIME::Types.type_for(bfn).first || MIME::Types.type_for("exe").first
  61       make_attachment IO.read(fn), t.content_type, t.encoding, bfn.to_s
  62     end
  63
  64     def charset
  65       if header.field?("content-type") && header.fetch("content-type") =~ /charset="?(.*?)"?(;|$)/i
  66         $1
  67       end
  68     end
  69
  70     def self.make_attachment payload, mime_type, encoding, filename
  71       a = Message.new
  72       a.header.add "Content-Disposition", "attachment; filename=#{filename.inspect}"
  73       a.header.add "Content-Type", "#{mime_type}; name=#{filename.inspect}"
  74       a.header.add "Content-Transfer-Encoding", encoding if encoding
  75       a.body =
  76         case encoding
  77         when "base64"
  78           [payload].pack "m"
  79         when "quoted-printable"
  80           [payload].pack "M"
  81         when "7bit", "8bit", nil
  82           payload
  83         else
  84           raise EncodingUnsupportedError, encoding.inspect
  85         end
  86       a
  87     end
  88   end
  89 end
  90
  91 class Range
  92   ## only valid for integer ranges (unless I guess it's exclusive)
  93   def size
  94     last - first + (exclude_end? ? 0 : 1)
  95   end
  96 end
  97
  98 class Module
  99   def bool_reader *args
 100     args.each { |sym| class_eval %{ def #{sym}?; @#{sym}; end } }
 101   end
 102   def bool_writer *args; attr_writer(*args); end
 103   def bool_accessor *args
 104     bool_reader(*args)
 105     bool_writer(*args)
 106   end
 107
 108   def defer_all_other_method_calls_to obj
 109     class_eval %{
 110       def method_missing meth, *a, &b; @#{obj}.send meth, *a, &b; end
 111       def respond_to?(m, include_private = false)
 112         @#{obj}.respond_to?(m, include_private)
 113       end
 114     }
 115   end
 116 end
 117
 118 class Object
 119   def ancestors
 120     ret = []
 121     klass = self.class
 122
 123     until klass == Object
 124       ret << klass
 125       klass = klass.superclass
 126     end
 127     ret
 128   end
 129
 130   ## "k combinator"
 131   def returning x; yield x; x; end
 132
 133   ## clone of java-style whole-method synchronization
 134   ## assumes a @mutex variable
 135   ## TODO: clean up, try harder to avoid namespace collisions
 136   def synchronized *meth
 137     meth.each do
 138       class_eval <<-EOF
 139         alias unsynchronized_#{meth} #{meth}
 140         def #{meth}(*a, &b)
 141           @mutex.synchronize { unsynchronized_#{meth}(*a, &b) }
 142         end
 143       EOF
 144     end
 145   end
 146
 147   def ignore_concurrent_calls *meth
 148     meth.each do
 149       mutex = "@__concurrent_protector_#{meth}"
 150       flag = "@__concurrent_flag_#{meth}"
 151       oldmeth = "__unprotected_#{meth}"
 152       class_eval <<-EOF
 153         alias #{oldmeth} #{meth}
 154         def #{meth}(*a, &b)
 155           #{mutex} = Mutex.new unless defined? #{mutex}
 156           #{flag} = true unless defined? #{flag}
 157           run = #{mutex}.synchronize do
 158             if #{flag}
 159               #{flag} = false
 160               true
 161             end
 162           end
 163           if run
 164             ret = #{oldmeth}(*a, &b)
 165             #{mutex}.synchronize { #{flag} = true }
 166             ret
 167           end
 168         end
 169       EOF
 170     end
 171   end
 172 end
 173
 174 class String
 175   def camel_to_hyphy
 176     self.gsub(/([a-z])([A-Z0-9])/, '\1-\2').downcase
 177   end
 178
 179   def find_all_positions x
 180     ret = []
 181     start = 0
 182     while start < length
 183       pos = index x, start
 184       break if pos.nil?
 185       ret << pos
 186       start = pos + 1
 187     end
 188     ret
 189   end
 190
 191   ## one of the few things i miss from perl
 192   def ucfirst
 193     self[0 .. 0].upcase + self[1 .. -1]
 194   end
 195
 196   ## a very complicated regex found on teh internets to split on
 197   ## commas, unless they occurr within double quotes.
 198   def split_on_commas
 199     split(/,\s*(?=(?:[^"]*"[^"]*")*(?![^"]*"))/)
 200   end
 201
 202   ## ok, here we do it the hard way. got to have a remainder for purposes of
 203   ## tab-completing full email addresses
 204   def split_on_commas_with_remainder
 205     ret = []
 206     state = :outstring
 207     pos = 0
 208     region_start = 0
 209     while pos <= length
 210       newpos = case state
 211         when :escaped_instring, :escaped_outstring: pos
 212         else index(/[,"\\]/, pos)
 213       end
 214
 215       if newpos
 216         char = self[newpos]
 217       else
 218         char = nil
 219         newpos = length
 220       end
 221
 222       case char
 223       when ?"
 224         state = case state
 225           when :outstring: :instring
 226           when :instring: :outstring
 227           when :escaped_instring: :instring
 228           when :escaped_outstring: :outstring
 229         end
 230       when ?,, nil
 231         state = case state
 232           when :outstring, :escaped_outstring:
 233             ret << self[region_start ... newpos].gsub(/^\s+|\s+$/, "")
 234             region_start = newpos + 1
 235             :outstring
 236           when :instring: :instring
 237           when :escaped_instring: :instring
 238         end
 239       when ?\\
 240         state = case state
 241           when :instring: :escaped_instring
 242           when :outstring: :escaped_outstring
 243           when :escaped_instring: :instring
 244           when :escaped_outstring: :outstring
 245         end
 246       end
 247       pos = newpos + 1
 248     end
 249
 250     remainder = case state
 251       when :instring
 252         self[region_start .. -1].gsub(/^\s+/, "")
 253       else
 254         nil
 255       end
 256
 257     [ret, remainder]
 258   end
 259
 260   def wrap len
 261     ret = []
 262     s = self
 263     while s.length > len
 264       cut = s[0 ... len].rindex(/\s/)
 265       if cut
 266         ret << s[0 ... cut]
 267         s = s[(cut + 1) .. -1]
 268       else
 269         ret << s[0 ... len]
 270         s = s[len .. -1]
 271       end
 272     end
 273     ret << s
 274   end
 275
 276   def normalize_whitespace
 277     gsub(/\t/, "    ").gsub(/\r/, "")
 278   end
 279 end
 280
 281 class Numeric
 282   def clamp min, max
 283     if self < min
 284       min
 285     elsif self > max
 286       max
 287     else
 288       self
 289     end
 290   end
 291
 292   def in? range; range.member? self; end
 293
 294   def to_human_size
 295     if self < 1024
 296       to_s + "b"
 297     elsif self < (1024 * 1024)
 298       (self / 1024).to_s + "k"
 299     elsif self < (1024 * 1024 * 1024)
 300       (self / 1024 / 1024).to_s + "m"
 301     else
 302       (self / 1024 / 1024 / 1024).to_s + "g"
 303     end
 304   end
 305 end
 306
 307 class Fixnum
 308   def to_character
 309     if self < 128 && self >= 0
 310       chr
 311     else
 312       "<#{self}>"
 313     end
 314   end
 315
 316   ## hacking the english language
 317   def pluralize s
 318     to_s + " " +
 319       if self == 1
 320         s
 321       else
 322         if s =~ /(.*)y$/
 323           $1 + "ies"
 324         else
 325           s + "s"
 326         end
 327       end
 328   end
 329 end
 330
 331 class Hash
 332   def - o
 333     Hash[*self.map { |k, v| [k, v] unless o.include? k }.compact.flatten_one_level]
 334   end
 335
 336   def select_by_value v=true
 337     select { |k, vv| vv == v }.map { |x| x.first }
 338   end
 339 end
 340
 341 module Enumerable
 342   def map_with_index
 343     ret = []
 344     each_with_index { |x, i| ret << yield(x, i) }
 345     ret
 346   end
 347
 348   def sum; inject(0) { |x, y| x + y }; end
 349
 350   def map_to_hash
 351     ret = {}
 352     each { |x| ret[x] = yield(x) }
 353     ret
 354   end
 355
 356   # like find, except returns the value of the block rather than the
 357   # element itself.
 358   def argfind
 359     ret = nil
 360     find { |e| ret ||= yield(e) }
 361     ret || nil # force
 362   end
 363
 364   def argmin
 365     best, bestval = nil, nil
 366     each do |e|
 367       val = yield e
 368       if bestval.nil? || val < bestval
 369         best, bestval = e, val
 370       end
 371     end
 372     best
 373   end
 374
 375   ## returns the maximum shared prefix of an array of strings
 376   ## optinally excluding a prefix
 377   def shared_prefix caseless=false, exclude=""
 378     return "" if empty?
 379     prefix = ""
 380     (0 ... first.length).each do |i|
 381       c = (caseless ? first.downcase : first)[i]
 382       break unless all? { |s| (caseless ? s.downcase : s)[i] == c }
 383       next if exclude[i] == c
 384       prefix += first[i].chr
 385     end
 386     prefix
 387   end
 388
 389   def max_of
 390     map { |e| yield e }.max
 391   end
 392 end
 393
 394 class Array
 395   def flatten_one_level
 396     inject([]) { |a, e| a + e }
 397   end
 398
 399   def to_h; Hash[*flatten]; end
 400   def rest; self[1..-1]; end
 401
 402   def to_boolean_h; Hash[*map { |x| [x, true] }.flatten]; end
 403
 404   def last= e; self[-1] = e end
 405   def nonempty?; !empty? end
 406 end
 407
 408 class Time
 409   def to_indexable_s
 410     sprintf "%012d", self
 411   end
 412
 413   def nearest_hour
 414     if min < 30
 415       self
 416     else
 417       self + (60 - min) * 60
 418     end
 419   end
 420
 421   def midnight # within a second
 422     self - (hour * 60 * 60) - (min * 60) - sec
 423   end
 424
 425   def is_the_same_day? other
 426     (midnight - other.midnight).abs < 1
 427   end
 428
 429   def is_the_day_before? other
 430     other.midnight - midnight <=  24 * 60 * 60 + 1
 431   end
 432
 433   def to_nice_distance_s from=Time.now
 434     later_than = (self < from)
 435     diff = (self.to_i - from.to_i).abs.to_f
 436     text =
 437       [ ["second", 60],
 438         ["minute", 60],
 439         ["hour", 24],
 440         ["day", 7],
 441         ["week", 4.345], # heh heh
 442         ["month", 12],
 443         ["year", nil],
 444       ].argfind do |unit, size|
 445         if diff.round <= 1
 446           "one #{unit}"
 447         elsif size.nil? || diff.round < size
 448           "#{diff.round} #{unit}s"
 449         else
 450           diff /= size.to_f
 451           false
 452         end
 453       end
 454     if later_than
 455       text + " ago"
 456     else
 457       "in " + text
 458     end
 459   end
 460
 461   TO_NICE_S_MAX_LEN = 9 # e.g. "Yest.10am"
 462   def to_nice_s from=Time.now
 463     if year != from.year
 464       strftime "%b %Y"
 465     elsif month != from.month
 466       strftime "%b %e"
 467     else
 468       if is_the_same_day? from
 469         strftime("%l:%M%P")
 470       elsif is_the_day_before? from
 471         "Yest."  + nearest_hour.strftime("%l%P")
 472       else
 473         strftime "%b %e"
 474       end
 475     end
 476   end
 477 end
 478
 479 ## simple singleton module. far less complete and insane than the ruby
 480 ## standard library one, but automatically forwards methods calls and
 481 ## allows for constructors that take arguments.
 482 ##
 483 ## You must have #initialize call "self.class.i_am_the_instance self"
 484 ## at some point or everything will fail horribly.
 485 module Singleton
 486   module ClassMethods
 487     def instance; @instance; end
 488     def instantiated?; defined?(@instance) && !@instance.nil?; end
 489     def deinstantiate!; @instance = nil; end
 490     def method_missing meth, *a, &b
 491       raise "no instance defined!" unless defined? @instance
 492
 493       ## if we've been deinstantiated, just drop all calls. this is
 494       ## useful because threads that might be active during the
 495       ## cleanup process (e.g. polling) would otherwise have to
 496       ## special-case every call to a Singleton object
 497       return nil if @instance.nil?
 498
 499       @instance.send meth, *a, &b
 500     end
 501     def i_am_the_instance o
 502       raise "there can be only one! (instance)" if defined? @instance
 503       @instance = o
 504     end
 505   end
 506
 507   def self.included klass
 508     klass.extend ClassMethods
 509   end
 510 end
 511
 512 ## wraps an object. if it throws an exception, keeps a copy.
 513 class Recoverable
 514   def initialize o
 515     @o = o
 516     @error = nil
 517     @mutex = Mutex.new
 518   end
 519
 520   attr_accessor :error
 521
 522   def clear_error!; @error = nil; end
 523   def has_errors?; !@error.nil?; end
 524
 525   def method_missing m, *a, &b; __pass m, *a, &b end
 526
 527   def id; __pass :id; end
 528   def to_s; __pass :to_s; end
 529   def to_yaml x; __pass :to_yaml, x; end
 530   def is_a? c; @o.is_a? c; end
 531
 532   def respond_to?(m, include_private=false)
 533     @o.respond_to?(m, include_private)
 534   end
 535
 536   def __pass m, *a, &b
 537     begin
 538       @o.send(m, *a, &b)
 539     rescue Exception => e
 540       @error ||= e
 541       raise
 542     end
 543   end
 544 end
 545
 546 ## acts like a hash with an initialization block, but saves any
 547 ## newly-created value even upon lookup.
 548 ##
 549 ## for example:
 550 ##
 551 ## class C
 552 ##   attr_accessor :val
 553 ##   def initialize; @val = 0 end
 554 ## end
 555 ##
 556 ## h = Hash.new { C.new }
 557 ## h[:a].val # => 0
 558 ## h[:a].val = 1
 559 ## h[:a].val # => 0
 560 ##
 561 ## h2 = SavingHash.new { C.new }
 562 ## h2[:a].val # => 0
 563 ## h2[:a].val = 1
 564 ## h2[:a].val # => 1
 565 ##
 566 ## important note: you REALLY want to use #member? to test existence,
 567 ## because just checking h[anything] will always evaluate to true
 568 ## (except for degenerate constructor blocks that return nil or false)
 569 class SavingHash
 570   def initialize &b
 571     @constructor = b
 572     @hash = Hash.new
 573   end
 574
 575   def [] k
 576     @hash[k] ||= @constructor.call(k)
 577   end
 578
 579   defer_all_other_method_calls_to :hash
 580 end
 581
 582 class OrderedHash < Hash
 583   alias_method :store, :[]=
 584   alias_method :each_pair, :each
 585   attr_reader :keys
 586
 587   def initialize *a
 588     @keys = []
 589     a.each { |k, v| self[k] = v }
 590   end
 591
 592   def []= key, val
 593     @keys << key unless member?(key)
 594     super
 595   end
 596
 597   def values; keys.map { |k| self[k] } end
 598   def index key; @keys.index key end
 599
 600   def delete key
 601     @keys.delete key
 602     super
 603   end
 604
 605   def each; @keys.each { |k| yield k, self[k] } end
 606 end
 607
 608 ## easy thread-safe class for determining who's the "winner" in a race (i.e.
 609 ## first person to hit the finish line
 610 class FinishLine
 611   def initialize
 612     @m = Mutex.new
 613     @over = false
 614   end
 615
 616   def winner?
 617     @m.synchronize { !@over && @over = true }
 618   end
 619 end
 620
 621 class Iconv
 622   def self.easy_decode target, charset, text
 623     return text if charset =~ /^(x-unknown|unknown[-_ ]?8bit|ascii[-_ ]?7[-_ ]?bit)$/i
 624     charset = case charset
 625                 when /UTF[-_ ]?8/i: "utf-8"
 626                 when /(iso[-_ ])?latin[-_ ]?1$/i: "ISO-8859-1"
 627                 when /iso[-_ ]?8859[-_ ]?15/i: 'ISO-8859-15'
 628                 when /unicode[-_ ]1[-_ ]1[-_ ]utf[-_]7/i: "utf-7"
 629                 else charset
 630               end
 631
 632     # Convert:
 633     #
 634     # Remember - Iconv.open(to, from)!
 635     Iconv.iconv(target + "//IGNORE", charset, text + " ").join[0 .. -2]
 636   end
 637 end