rubycut-babushka 0.10.6

data/lib/babushka/core_patches/blank.rb

@@ -0,0 +1,22 @@
+# #blank? means (nil? or empty?). Instead of defining it on all objects and
+# checking if they respond to the #empty? method when #blank? is called, we
+# define it only on the classes where it has meaning. That means we also
+# have to define it on nil, since it is also considered 'blank'.
+
+module Enumerable
+  def blank?
+    empty?
+  end
+end
+
+class String
+  def blank?
+    empty?
+  end
+end
+
+class NilClass
+  def blank?
+    true
+  end
+end

data/lib/babushka/core_patches/bytes.rb

@@ -0,0 +1,52 @@
+# Lifted from activesupport-3.0.5/lib/active_support/core_ext/numeric/bytes.rb
+class Numeric
+  KILOBYTE = 1024
+  MEGABYTE = KILOBYTE * 1024
+  GIGABYTE = MEGABYTE * 1024
+  TERABYTE = GIGABYTE * 1024
+  PETABYTE = TERABYTE * 1024
+  EXABYTE  = PETABYTE * 1024
+
+  # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
+  def bytes
+    self
+  end
+  alias :byte :bytes
+
+  def kilobytes
+    self * KILOBYTE
+  end
+  alias :kilobyte :kilobytes
+
+  def megabytes
+    self * MEGABYTE
+  end
+  alias :megabyte :megabytes
+
+  def gigabytes
+    self * GIGABYTE
+  end
+  alias :gigabyte :gigabytes
+
+  def terabytes
+    self * TERABYTE
+  end
+  alias :terabyte :terabytes
+
+  def petabytes
+    self * PETABYTE
+  end
+  alias :petabyte :petabytes
+
+  def exabytes
+    self * EXABYTE
+  end
+  alias :exabyte :exabytes
+
+  alias :kb :kilobytes
+  alias :mb :megabytes
+  alias :gb :gigabytes
+  alias :tb :terabytes
+  alias :pb :petabytes
+  alias :eb :exabytes
+end

data/lib/babushka/core_patches/hash.rb

@@ -0,0 +1,107 @@
+class Hash
+  # Return a new hash filtered to exclude any key-value pairs whose keys appear
+  # in +keys+.
+  def discard *keys
+    dup.discard!(*keys)
+  end
+
+  # Filter this hash in-place so any key-value pairs whose keys appear in
+  # +keys+ are removed.
+  def discard! *keys
+    keys.each {|k| delete k }
+    self
+  end
+
+  # Return a new hash filtered to contain only the key-value pairs whose keys
+  # appear in +keys+.
+  def slice *keys
+    dup.slice!(*keys)
+  end
+
+  # Filter this hash in-place so it contains only the key-value pairs whose
+  # keys appear in +keys+.
+  def slice! *keys
+    keys.inject({}) {|acc,key|
+      acc[key] = self.delete(key) if self.has_key?(key)
+      acc
+    }
+  end
+
+  # Reverse-merge +other+ into this hash in-place; that is, merge all
+  # key-value pairs in +other+ whose keys are not already present in self.
+  def defaults! other
+    replace other.merge(self)
+  end
+
+  # Return a new hash consisting of +other+ reverse-merged into this hash;
+  # that is, equal to +other.merge(self)+.
+  def defaults other
+    dup.defaults! other
+  end
+
+  # Return a new hash with the same keys as this hash, but with values
+  # generated by yielding each key-value pair to +block+.
+  def map_values &block
+    dup.map_values!(&block)
+  end
+
+  # Update this hash in-place by replacing each value with the result of
+  # yielding the corresponding key-value pair to the block.
+  def map_values! &block
+    keys.each {|k|
+      self[k] = yield k, self[k]
+    }
+    self
+  end
+
+  # Return a new hash filtered to contain just the key-value pairs for which
+  # the block returns true. That is, like Hash#select, but returning a hash
+  # instead of an array of tuples.
+  def selekt &block
+    hsh = {}
+    each_pair {|k,v|
+      hsh[k] = v if yield(k,v)
+    }
+    hsh
+  end
+
+  # Return a new hash recursively filtered to remove all key-value pairs for
+  # which the block returned true. That is, like Hash#reject, except sub-hashes
+  # are also filtered.
+  def reject_r &block
+    dup.reject_r!(&block)
+  end
+
+  # Recursively filter this hash in-place to remove all key-value pairs for
+  # which the block returned true. That is, like Hash#reject!, except
+  # sub-hashes are also filtered.
+  def reject_r! &block
+    each_pair {|k,v|
+      if yield k, v
+        self.delete k
+      elsif v.is_a? Hash
+        self[k] = v.reject_r(&block)
+      end
+    }
+  end
+
+  # Converts this hash to a string that can be submitted as HTTP parameters.
+  # The keys and values are encoded, so the string is safe to submit exactly as
+  # it is returned.
+  #
+  # This isn't a recursive implementation, because I didn't need it to be :)
+  #
+  # Example:
+  # {'name' => 'Sigur Rós', 'album' => 'Takk...'}.to_http_params
+  #   #=> "name=Sigur%20R%C3%B3s&album=Takk..."
+  def to_http_params
+    require 'uri'
+
+    keys.map {|key|
+      [
+        URI.escape(key.to_s),
+        URI.escape(fetch(key).to_s)
+      ].join('=')
+    }.join( '&')
+  end
+end

data/lib/babushka/core_patches/hashish.rb

@@ -0,0 +1,14 @@
+class Hashish
+  # Return a new hash whose default value is an empty array; i.e. querying any
+  # un-assigned key will assign and return an empty array to that key.
+  def self.array
+    Hash.new {|hsh,k| hsh[k] = [] }
+  end
+
+  # Return a new hash whose default value is an empty hash; i.e. querying any
+  # un-assigned key will assign and return an empty hash to that key. Note that
+  # the empty hash is a regular hash and doesn't have any default keys of its own.
+  def self.hash
+    Hash.new {|hsh,k| hsh[k] = {} }
+  end
+end

data/lib/babushka/core_patches/integer.rb

@@ -0,0 +1,25 @@
+class Integer
+  # Return a string describing this integer as a human-readable, approximated
+  # duration, assuming it is a number of seconds. The description will be
+  # either 'now', 'less than a minute', or a value in minutes, hours or days.
+  # Some examples:
+  #   12.xsecs      #=> "less than a minute"
+  #   80.xsecs      #=> "1 minute"
+  #   1337.xsecs    #=> "22 minutes"
+  #   1234567.xsecs #=> "14 days"
+  def xsecs
+    value = self.abs
+    past = (self < 0)
+
+    case value
+    when 0; return 'now'
+    when 1...60; return "less than a minute#{' ago' if past}"
+    when 61...3600;        value /= 60;        unit = 'minute'
+    when 3600...(3600*24); value /= 3600;      unit = 'hour'
+    else                   value /= (3600*24); unit = 'day'
+    end
+
+    value = 1 if value == 0
+    "#{value.commas} #{unit}#{'s' unless value == 1}#{' ago' if past}"
+  end
+end

data/lib/babushka/core_patches/io.rb

@@ -0,0 +1,8 @@
+class IO
+  # Return true iff reading from this IO object would return data immediately,
+  # and not block while waiting for data.
+  def ready_for_read?
+    result = IO.select([self], [], [], 0)
+    result && (result.first.first == self)
+  end
+end

data/lib/babushka/core_patches/numeric.rb

@@ -0,0 +1,16 @@
+class Numeric
+  # Return a string representation of this value with commas between the
+  # thousands groupings.
+  # Some examples:
+  # 3.commas     #=> "3"
+  # 314.commas   #=> "314"
+  # 31459.commas #=> "31,459"
+  def commas
+    if self < 1000
+      to_s
+    else
+      whole, fract = self.to_s.split('.')
+      [ whole.reverse.scan(/\d{1,3}/).join(',').reverse, fract ].squash.join('.')
+    end
+  end
+end

data/lib/babushka/core_patches/object.rb

@@ -0,0 +1,27 @@
+alias :L :proc
+
+class Object
+  # Return this object's metaclass; i.e. the value of self within a
+  # 'class << self' block.
+  def metaclass
+    class << self; self end
+  end
+
+  # Return this object after yielding it to the block. This is useful for
+  # neatly working with an object in some way before returning it:
+  #   def valmorphanize
+  #     process.tap {|result|
+  #       log "Oops!" unless result
+  #     }
+  #   end
+  def tap &block
+    yield self
+    self
+  end unless Object.respond_to?(:tap)
+
+  # Return self unmodified after logging the output of #inspect, along with
+  # the point at which +tapp+ was called.
+  def tapp
+    tap { puts "#{File.basename caller[2]}: #{self.inspect}" }
+  end
+end

data/lib/babushka/core_patches/string.rb

@@ -0,0 +1,116 @@
+class String
+  # Return a Dep::Requirement that specifies the dep that should later be
+  # called, and the arguments that should be passed. This allows requiring
+  # deps with a less noisy syntax, and the lookup is lazy (it happens at
+  # the point the dep is invoked, from its parent dep in Dep#process_deps).
+  #
+  #   dep 'user has a password', :username do
+  #     requires 'user exists'.with(username)
+  #   end
+  def with *args
+    Babushka::Dep::Requirement.new(self, args)
+  end
+
+  # Returns true iff +other+ appears exactly at the start of +self+.
+  def starts_with? other
+    self[0, other.length] == other
+  end
+
+  # Returns true iff +other+ appears exactly at the end of +self+.
+  def ends_with? other
+    self[-other.length, other.length] == other
+  end
+
+  # Return a duplicate of +self+, with +other+ prepended to it if it doesn't already start with +other+.
+  def start_with other
+    starts_with?(other) ? self : other + self
+  end
+
+  # Return a duplicate of +self+, with +other+ appended to it if it doesn't already end with +other+.
+  def end_with other
+    ends_with?(other) ? self : self + other
+  end
+
+  # Extracts specified values from arbitrary, multiline strings. Most common
+  # formats are handled. When there are multiple matches across a multi-line
+  # string, the first is returned. If there is no match, the empty string is
+  # returned.
+  #
+  # With a simple key/value format:
+  #   'key: value'.val_for('key')  #=> 'value'
+  #   'key = value'.val_for('key') #=> 'value'
+  #   'key value'.val_for('key')   #=> 'value'
+  #
+  # Whitespace is handled correctly:
+  #   '  key: value '.val_for('key') #=> 'value'
+  #   '  key value '.val_for('key')  #=> 'value'
+  #
+  # Leading non-word characters form part of the key:
+  #   '*key: value'.val_for('*key') #=> 'value'
+  #   '-key: value'.val_for('-key') #=> 'value'
+  #   '-key: value'.val_for('key')  #=> nil
+  #
+  # But not if they're separated from the key:
+  #   '* key: value'.val_for('key') #=> 'value'
+  #
+  # Spaces within the key are handled properly:
+  #   'key with spaces: value'.val_for('key with spaces')         #=> 'value'
+  #   '- key with spaces: value'.val_for('key with spaces')       #=> 'value'
+  #   ' --  key with spaces: value'.val_for('key with spaces')    #=> 'value'
+  #   'space-separated key: value'.val_for('space-separated key') #=> 'value'
+  #
+  # As are values containing spaces:
+  #   'key: space-separated value'.val_for('key')                         #=> 'space-separated value'
+  #   'key with spaces: space-separated value'.val_for('key with spaces') #=> 'space-separated value'
+  def val_for key
+    split("\n").grep(
+      # The key we're after, maybe preceded by non-word chars and spaces, and
+      # followed either by a word/non-word boundary or whitespace.
+      key.is_a?(Regexp) ? key : /(^|^[^\w]*\s+)#{Regexp.escape(key)}(\b|(?=\s))/
+    ).map {|l|
+      l.sub(/^[^\w]*\s+/, '').
+        sub(key.is_a?(Regexp) ? key : /^#{Regexp.escape(key)}(\b|(?=\s))\s*[:=]?/, '').
+        sub(/[;,]\s*$/, '').
+        strip
+    }.first
+  end
+
+  def / other
+    (empty? ? other.p : (p / other))
+  end
+
+  # Create a VersionStr from this string.
+  def to_version
+    Babushka::VersionStr.new self
+  end
+
+  # Return a new string with the contents of this string surrounded in escape
+  # sequences such that it will render as described in +description+.
+  # Some examples:
+  #   'Hello world!'.colorize('green')   #=> "\e[0;32;29mHello world!\e[0m"
+  #   'Hello world!'.colorize('on red')  #=> "\e[0;29;41mHello world!\e[0m"
+  #   'Hello world!'.colorize('reverse') #=> "\e[0;29;7mHello world!\e[0m"
+  def colorize description = '', start_at = nil
+    if start_at.nil? || (cut_point = index(start_at)).nil?
+      Colorizer.instance.colorize self, description
+    else
+      self[0...cut_point] + Colorizer.instance.colorize(self[cut_point..-1], description)
+    end
+  end
+
+  # As +colorize+, but modify this string in-place instead of returning a new one.
+  def colorize! description = nil, start_at = nil
+    replace colorize(description, start_at) unless description.nil?
+  end
+
+  # Return a new string with all color-related escape sequences removed.
+  def decolorize
+    dup.decolorize!
+  end
+
+  # Remove all color-related escape sequences from this string in-place.
+  def decolorize!
+    gsub!(/\e\[\d+[;\d]*m/, '')
+    self
+  end
+end

data/lib/babushka/core_patches/symbol.rb

@@ -0,0 +1,12 @@
+unless :to_proc.respond_to? :to_proc
+  class Symbol
+    # Returns a Proc object which responds to a method whose name is this
+    # symbol.
+    #
+    # This is a fallback implementation for older rubies that don't have
+    # a built-in Symbol#to_proc.
+    def to_proc
+      L{|*args| args.shift.__send__ self, *args }
+    end
+  end
+end

data/lib/babushka/core_patches/try.rb

@@ -0,0 +1,15 @@
+# The implementation of #try as found in activesupport:
+#   lib/active_support/core_ext/object/try.rb
+#
+# Try is just a nil-swallowing send, which means return nil when called on
+# nil and just send like normal when called on any other object.
+
+class Object
+  alias_method :try, :__send__
+end
+
+class NilClass
+  def try *args
+    nil
+  end
+end

data/lib/babushka/core_patches/uri.rb

@@ -0,0 +1,24 @@
+require 'uri'
+module URI
+  module Escape
+    alias_method :original_escape, :escape
+
+    # Patch URI.escape to prevent multiple escapes, by unescaping the input
+    # before escaping it.
+    #
+    # For example, URI.escape normally behaves like this:
+    #   URI.escape "path with spaces"      #=> "path%20with%20spaces"
+    #   URI.escape "/path%20with%20spaces" #=> "/path%2520with%2520spaces"
+    #
+    # This patched version behaves like this:
+    #   URI.escape "/path with spaces"     #=> "/path%20with%20spaces"
+    #   URI.escape "/path%20with%20spaces" #=> "/path%20with%20spaces"
+    #
+    # This is pretty cheeky, but as far as I can see it won't cause any
+    # problems - I can't see any situation where a doubly-escaped entity is a
+    # good thing.
+    def escape str, unsafe = URI::UNSAFE
+      URI.original_escape URI.unescape(str), unsafe
+    end
+  end
+end