6 ## time for some monkeypatching!
10 'host' => "#{ Socket.gethostname }",
11 'pid' => "#{ Process.pid }",
12 'ppid' => "#{ Process.ppid }",
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')
25 h = load_lock_id IO.read(path)
26 h['mtime'] = File.mtime path
30 def touch_yourself; touch path end
38 rescue SystemCallError
46 ctime.strftime("%Y-%m-%d %H:%M")
47 rescue SystemCallError
53 ## more monkeypatching!
55 class EncodingUnsupportedError < StandardError; end
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
65 if header.field?("content-type") && header.fetch("content-type") =~ /charset="?(.*?)"?(;|$)/i
70 def self.make_attachment payload, mime_type, encoding, filename
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
79 when "quoted-printable"
81 when "7bit", "8bit", nil
84 raise EncodingUnsupportedError, encoding.inspect
92 ## only valid for integer ranges (unless I guess it's exclusive)
94 last - first + (exclude_end? ? 0 : 1)
100 args.each { |sym| class_eval %{ def #{sym}?; @#{sym}; end } }
102 def bool_writer *args; attr_writer(*args); end
103 def bool_accessor *args
108 def defer_all_other_method_calls_to obj
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)
123 until klass == Object
125 klass = klass.superclass
131 def returning x; yield x; x; end
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
139 alias unsynchronized_#{meth} #{meth}
141 @mutex.synchronize { unsynchronized_#{meth}(*a, &b) }
147 def ignore_concurrent_calls *meth
149 mutex = "@__concurrent_protector_#{meth}"
150 flag = "@__concurrent_flag_#{meth}"
151 oldmeth = "__unprotected_#{meth}"
153 alias #{oldmeth} #{meth}
155 #{mutex} = Mutex.new unless defined? #{mutex}
156 #{flag} = true unless defined? #{flag}
157 run = #{mutex}.synchronize do
164 ret = #{oldmeth}(*a, &b)
165 #{mutex}.synchronize { #{flag} = true }
176 self.gsub(/([a-z])([A-Z0-9])/, '\1-\2').downcase
179 def find_all_positions x
191 ## one of the few things i miss from perl
193 self[0 .. 0].upcase + self[1 .. -1]
196 ## a very complicated regex found on teh internets to split on
197 ## commas, unless they occurr within double quotes.
199 split(/,\s*(?=(?:[^"]*"[^"]*")*(?![^"]*"))/)
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
211 when :escaped_instring, :escaped_outstring: pos
212 else index(/[,"\\]/, pos)
225 when :outstring: :instring
226 when :instring: :outstring
227 when :escaped_instring: :instring
228 when :escaped_outstring: :outstring
232 when :outstring, :escaped_outstring:
233 ret << self[region_start ... newpos].gsub(/^\s+|\s+$/, "")
234 region_start = newpos + 1
236 when :instring: :instring
237 when :escaped_instring: :instring
241 when :instring: :escaped_instring
242 when :outstring: :escaped_outstring
243 when :escaped_instring: :instring
244 when :escaped_outstring: :outstring
250 remainder = case state
252 self[region_start .. -1].gsub(/^\s+/, "")
264 cut = s[0 ... len].rindex(/\s/)
267 s = s[(cut + 1) .. -1]
276 def normalize_whitespace
277 gsub(/\t/, " ").gsub(/\r/, "")
292 def in? range; range.member? self; end
297 elsif self < (1024 * 1024)
298 (self / 1024).to_s + "k"
299 elsif self < (1024 * 1024 * 1024)
300 (self / 1024 / 1024).to_s + "m"
302 (self / 1024 / 1024 / 1024).to_s + "g"
309 if self < 128 && self >= 0
316 ## hacking the english language
333 Hash[*self.map { |k, v| [k, v] unless o.include? k }.compact.flatten_one_level]
336 def select_by_value v=true
337 select { |k, vv| vv == v }.map { |x| x.first }
344 each_with_index { |x, i| ret << yield(x, i) }
348 def sum; inject(0) { |x, y| x + y }; end
352 each { |x| ret[x] = yield(x) }
356 # like find, except returns the value of the block rather than the
360 find { |e| ret ||= yield(e) }
365 best, bestval = nil, nil
368 if bestval.nil? || val < bestval
369 best, bestval = e, val
375 ## returns the maximum shared prefix of an array of strings
376 ## optinally excluding a prefix
377 def shared_prefix caseless=false, exclude=""
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
390 map { |e| yield e }.max
395 def flatten_one_level
396 inject([]) { |a, e| a + e }
399 def to_h; Hash[*flatten]; end
400 def rest; self[1..-1]; end
402 def to_boolean_h; Hash[*map { |x| [x, true] }.flatten]; end
404 def last= e; self[-1] = e end
405 def nonempty?; !empty? end
410 sprintf "%012d", self
417 self + (60 - min) * 60
421 def midnight # within a second
422 self - (hour * 60 * 60) - (min * 60) - sec
425 def is_the_same_day? other
426 (midnight - other.midnight).abs < 1
429 def is_the_day_before? other
430 other.midnight - midnight <= 24 * 60 * 60 + 1
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
441 ["week", 4.345], # heh heh
444 ].argfind do |unit, size|
447 elsif size.nil? || diff.round < size
448 "#{diff.round} #{unit}s"
461 TO_NICE_S_MAX_LEN = 9 # e.g. "Yest.10am"
462 def to_nice_s from=Time.now
465 elsif month != from.month
468 if is_the_same_day? from
470 elsif is_the_day_before? from
471 "Yest." + nearest_hour.strftime("%l%P")
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.
483 ## You must have #initialize call "self.class.i_am_the_instance self"
484 ## at some point or everything will fail horribly.
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
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?
499 @instance.send meth, *a, &b
501 def i_am_the_instance o
502 raise "there can be only one! (instance)" if defined? @instance
507 def self.included klass
508 klass.extend ClassMethods
512 ## wraps an object. if it throws an exception, keeps a copy.
522 def clear_error!; @error = nil; end
523 def has_errors?; !@error.nil?; end
525 def method_missing m, *a, &b; __pass m, *a, &b end
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
532 def respond_to?(m, include_private=false)
533 @o.respond_to?(m, include_private)
539 rescue Exception => e
546 ## acts like a hash with an initialization block, but saves any
547 ## newly-created value even upon lookup.
552 ## attr_accessor :val
553 ## def initialize; @val = 0 end
556 ## h = Hash.new { C.new }
561 ## h2 = SavingHash.new { C.new }
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)
576 @hash[k] ||= @constructor.call(k)
579 defer_all_other_method_calls_to :hash
582 class OrderedHash < Hash
583 alias_method :store, :[]=
584 alias_method :each_pair, :each
589 a.each { |k, v| self[k] = v }
593 @keys << key unless member?(key)
597 def values; keys.map { |k| self[k] } end
598 def index key; @keys.index key end
605 def each; @keys.each { |k| yield k, self[k] } end
608 ## easy thread-safe class for determining who's the "winner" in a race (i.e.
609 ## first person to hit the finish line
617 @m.synchronize { !@over && @over = true }
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 /unicode[-_]1[-_]1[-_]utf[-_]7/i: "utf-7"
633 # Remember - Iconv.open(to, from)!
634 Iconv.iconv(target + "//IGNORE", charset, text + " ").join[0 .. -2]