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   ## a very complicated regex found on teh internets to split on
 192   ## commas, unless they occurr within double quotes.
 193   def split_on_commas
 194     split(/,\s*(?=(?:[^"]*"[^"]*")*(?![^"]*"))/)
 195   end
 196
 197   ## ok, here we do it the hard way. got to have a remainder for purposes of
 198   ## tab-completing full email addresses
 199   def split_on_commas_with_remainder
 200     ret = []
 201     state = :outstring
 202     pos = 0
 203     region_start = 0
 204     while pos <= length
 205       newpos = case state
 206         when :escaped_instring, :escaped_outstring: pos
 207         else index(/[,"\\]/, pos)
 208       end
 209
 210       if newpos
 211         char = self[newpos]
 212       else
 213         char = nil
 214         newpos = length
 215       end
 216
 217       case char
 218       when ?"
 219         state = case state
 220           when :outstring: :instring
 221           when :instring: :outstring
 222           when :escaped_instring: :instring
 223           when :escaped_outstring: :outstring
 224         end
 225       when ?,, nil
 226         state = case state
 227           when :outstring, :escaped_outstring:
 228             ret << self[region_start ... newpos].gsub(/^\s+|\s+$/, "")
 229             region_start = newpos + 1
 230             :outstring
 231           when :instring: :instring
 232           when :escaped_instring: :instring
 233         end
 234       when ?\\
 235         state = case state
 236           when :instring: :escaped_instring
 237           when :outstring: :escaped_outstring
 238           when :escaped_instring: :instring
 239           when :escaped_outstring: :outstring
 240         end
 241       end
 242       pos = newpos + 1
 243     end
 244
 245     remainder = case state
 246       when :instring
 247         self[region_start .. -1].gsub(/^\s+/, "")
 248       else
 249         nil
 250       end
 251
 252     [ret, remainder]
 253   end
 254
 255   def wrap len
 256     ret = []
 257     s = self
 258     while s.length > len
 259       cut = s[0 ... len].rindex(/\s/)
 260       if cut
 261         ret << s[0 ... cut]
 262         s = s[(cut + 1) .. -1]
 263       else
 264         ret << s[0 ... len]
 265         s = s[len .. -1]
 266       end
 267     end
 268     ret << s
 269   end
 270
 271   def normalize_whitespace
 272     gsub(/\t/, "    ").gsub(/\r/, "")
 273   end
 274 end
 275
 276 class Numeric
 277   def clamp min, max
 278     if self < min
 279       min
 280     elsif self > max
 281       max
 282     else
 283       self
 284     end
 285   end
 286
 287   def in? range; range.member? self; end
 288
 289   def to_human_size
 290     if self < 1024
 291       to_s + "b"
 292     elsif self < (1024 * 1024)
 293       (self / 1024).to_s + "k"
 294     elsif self < (1024 * 1024 * 1024)
 295       (self / 1024 / 1024).to_s + "m"
 296     else
 297       (self / 1024 / 1024 / 1024).to_s + "g"
 298     end
 299   end
 300 end
 301
 302 class Fixnum
 303   def to_character
 304     if self < 128 && self >= 0
 305       chr
 306     else
 307       "<#{self}>"
 308     end
 309   end
 310
 311   ## hacking the english language
 312   def pluralize s
 313     to_s + " " +
 314       if self == 1
 315         s
 316       else
 317         if s =~ /(.*)y$/
 318           $1 + "ies"
 319         else
 320           s + "s"
 321         end
 322       end
 323   end
 324 end
 325
 326 class Hash
 327   def - o
 328     Hash[*self.map { |k, v| [k, v] unless o.include? k }.compact.flatten_one_level]
 329   end
 330
 331   def select_by_value v=true
 332     select { |k, vv| vv == v }.map { |x| x.first }
 333   end
 334 end
 335
 336 module Enumerable
 337   def map_with_index
 338     ret = []
 339     each_with_index { |x, i| ret << yield(x, i) }
 340     ret
 341   end
 342
 343   def sum; inject(0) { |x, y| x + y }; end
 344
 345   def map_to_hash
 346     ret = {}
 347     each { |x| ret[x] = yield(x) }
 348     ret
 349   end
 350
 351   # like find, except returns the value of the block rather than the
 352   # element itself.
 353   def argfind
 354     ret = nil
 355     find { |e| ret ||= yield(e) }
 356     ret || nil # force
 357   end
 358
 359   def argmin
 360     best, bestval = nil, nil
 361     each do |e|
 362       val = yield e
 363       if bestval.nil? || val < bestval
 364         best, bestval = e, val
 365       end
 366     end
 367     best
 368   end
 369
 370   ## returns the maximum shared prefix of an array of strings
 371   ## optinally excluding a prefix
 372   def shared_prefix caseless=false, exclude=""
 373     return "" if empty?
 374     prefix = ""
 375     (0 ... first.length).each do |i|
 376       c = (caseless ? first.downcase : first)[i]
 377       break unless all? { |s| (caseless ? s.downcase : s)[i] == c }
 378       next if exclude[i] == c
 379       prefix += first[i].chr
 380     end
 381     prefix
 382   end
 383
 384   def max_of
 385     map { |e| yield e }.max
 386   end
 387 end
 388
 389 class Array
 390   def flatten_one_level
 391     inject([]) { |a, e| a + e }
 392   end
 393
 394   def to_h; Hash[*flatten]; end
 395   def rest; self[1..-1]; end
 396
 397   def to_boolean_h; Hash[*map { |x| [x, true] }.flatten]; end
 398
 399   def last= e; self[-1] = e end
 400   def nonempty?; !empty? end
 401 end
 402
 403 class Time
 404   def to_indexable_s
 405     sprintf "%012d", self
 406   end
 407
 408   def nearest_hour
 409     if min < 30
 410       self
 411     else
 412       self + (60 - min) * 60
 413     end
 414   end
 415
 416   def midnight # within a second
 417     self - (hour * 60 * 60) - (min * 60) - sec
 418   end
 419
 420   def is_the_same_day? other
 421     (midnight - other.midnight).abs < 1
 422   end
 423
 424   def is_the_day_before? other
 425     other.midnight - midnight <=  24 * 60 * 60 + 1
 426   end
 427
 428   def to_nice_distance_s from=Time.now
 429     later_than = (self < from)
 430     diff = (self.to_i - from.to_i).abs.to_f
 431     text =
 432       [ ["second", 60],
 433         ["minute", 60],
 434         ["hour", 24],
 435         ["day", 7],
 436         ["week", 4.345], # heh heh
 437         ["month", 12],
 438         ["year", nil],
 439       ].argfind do |unit, size|
 440         if diff.round <= 1
 441           "one #{unit}"
 442         elsif size.nil? || diff.round < size
 443           "#{diff.round} #{unit}s"
 444         else
 445           diff /= size.to_f
 446           false
 447         end
 448       end
 449     if later_than
 450       text + " ago"
 451     else
 452       "in " + text
 453     end
 454   end
 455
 456   TO_NICE_S_MAX_LEN = 9 # e.g. "Yest.10am"
 457   def to_nice_s from=Time.now
 458     if year != from.year
 459       strftime "%b %Y"
 460     elsif month != from.month
 461       strftime "%b %e"
 462     else
 463       if is_the_same_day? from
 464         strftime("%l:%M%P")
 465       elsif is_the_day_before? from
 466         "Yest."  + nearest_hour.strftime("%l%P")
 467       else
 468         strftime "%b %e"
 469       end
 470     end
 471   end
 472 end
 473
 474 ## simple singleton module. far less complete and insane than the ruby
 475 ## standard library one, but automatically forwards methods calls and
 476 ## allows for constructors that take arguments.
 477 ##
 478 ## You must have #initialize call "self.class.i_am_the_instance self"
 479 ## at some point or everything will fail horribly.
 480 module Singleton
 481   module ClassMethods
 482     def instance; @instance; end
 483     def instantiated?; defined?(@instance) && !@instance.nil?; end
 484     def deinstantiate!; @instance = nil; end
 485     def method_missing meth, *a, &b
 486       raise "no instance defined!" unless defined? @instance
 487
 488       ## if we've been deinstantiated, just drop all calls. this is
 489       ## useful because threads that might be active during the
 490       ## cleanup process (e.g. polling) would otherwise have to
 491       ## special-case every call to a Singleton object
 492       return nil if @instance.nil?
 493
 494       @instance.send meth, *a, &b
 495     end
 496     def i_am_the_instance o
 497       raise "there can be only one! (instance)" if defined? @instance
 498       @instance = o
 499     end
 500   end
 501
 502   def self.included klass
 503     klass.extend ClassMethods
 504   end
 505 end
 506
 507 ## wraps an object. if it throws an exception, keeps a copy.
 508 class Recoverable
 509   def initialize o
 510     @o = o
 511     @error = nil
 512     @mutex = Mutex.new
 513   end
 514
 515   attr_accessor :error
 516
 517   def clear_error!; @error = nil; end
 518   def has_errors?; !@error.nil?; end
 519
 520   def method_missing m, *a, &b; __pass m, *a, &b end
 521
 522   def id; __pass :id; end
 523   def to_s; __pass :to_s; end
 524   def to_yaml x; __pass :to_yaml, x; end
 525   def is_a? c; @o.is_a? c; end
 526
 527   def respond_to?(m, include_private=false)
 528     @o.respond_to?(m, include_private)
 529   end
 530
 531   def __pass m, *a, &b
 532     begin
 533       @o.send(m, *a, &b)
 534     rescue Exception => e
 535       @error ||= e
 536       raise
 537     end
 538   end
 539 end
 540
 541 ## acts like a hash with an initialization block, but saves any
 542 ## newly-created value even upon lookup.
 543 ##
 544 ## for example:
 545 ##
 546 ## class C
 547 ##   attr_accessor :val
 548 ##   def initialize; @val = 0 end
 549 ## end
 550 ##
 551 ## h = Hash.new { C.new }
 552 ## h[:a].val # => 0
 553 ## h[:a].val = 1
 554 ## h[:a].val # => 0
 555 ##
 556 ## h2 = SavingHash.new { C.new }
 557 ## h2[:a].val # => 0
 558 ## h2[:a].val = 1
 559 ## h2[:a].val # => 1
 560 ##
 561 ## important note: you REALLY want to use #member? to test existence,
 562 ## because just checking h[anything] will always evaluate to true
 563 ## (except for degenerate constructor blocks that return nil or false)
 564 class SavingHash
 565   def initialize &b
 566     @constructor = b
 567     @hash = Hash.new
 568   end
 569
 570   def [] k
 571     @hash[k] ||= @constructor.call(k)
 572   end
 573
 574   defer_all_other_method_calls_to :hash
 575 end
 576
 577 class OrderedHash < Hash
 578   alias_method :store, :[]=
 579   alias_method :each_pair, :each
 580   attr_reader :keys
 581
 582   def initialize *a
 583     @keys = []
 584     a.each { |k, v| self[k] = v }
 585   end
 586
 587   def []= key, val
 588     @keys << key unless member?(key)
 589     super
 590   end
 591
 592   def values; keys.map { |k| self[k] } end
 593   def index key; @keys.index key end
 594
 595   def delete key
 596     @keys.delete key
 597     super
 598   end
 599
 600   def each; @keys.each { |k| yield k, self[k] } end
 601 end
 602
 603 ## easy thread-safe class for determining who's the "winner" in a race (i.e.
 604 ## first person to hit the finish line
 605 class FinishLine
 606   def initialize
 607     @m = Mutex.new
 608     @over = false
 609   end
 610
 611   def winner?
 612     @m.synchronize { !@over && @over = true }
 613   end
 614 end
 615
 616 class Iconv
 617   def self.easy_decode target, charset, text
 618     return text if charset =~ /^(x-unknown|unknown[-_ ]?8bit|ascii[-_ ]?7[-_ ]?bit)$/i
 619     charset = case charset
 620                 when /UTF[-_ ]?8/i: "utf-8"
 621                 when /(iso[-_ ])?latin[-_ ]?1$/i: "ISO-8859-1"
 622                 when /iso[-_ ]?8859[-_ ]?15/i: 'ISO-8859-15'
 623                 when /unicode[-_ ]1[-_ ]1[-_ ]utf[-_]7/i: "utf-7"
 624                 else charset
 625               end
 626
 627     # Convert:
 628     #
 629     # Remember - Iconv.open(to, from)!
 630     Iconv.iconv(target + "//IGNORE", charset, text + " ").join[0 .. -2]
 631   end
 632 end