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

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